Java Mini Series | The Foundation – Objects, Classes and the Main Method

So, you’ve decided to learn Java. Excellent choice. It’s a powerhouse language running on billions of devices, from enterprise servers to Android apps. But where do you start? The syntax can seem intimidating, and the concepts abstract. Forget everything you’ve heard about its difficulty. We’re going to strip it down to its absolute core. By the end of this post, you will understand the fundamental mental model of Java: Object-Oriented Programming (OOP). It all begins with two concepts: Java Classes and Objects.

This isn’t just academic theory; this is the grammar of the Java language. Misunderstand this, and everything that follows will feel shaky. Understand this, and you have a rock-solid foundation to build upon.

The Core Idea: Blueprints and Buildings

Imagine you’re an architect designing a new neighborhood. You wouldn’t draw every single house individually. That would be insane. Instead, you create one detailed blueprint. This blueprint defines the structure: the number of floors, the placement of doors and windows, the layout of the rooms. It’s a plan, a template. It is not a house you can live in. Now, a construction crew uses that single blueprint to build 50 actual houses. Each house is a physical, tangible object you can interact with. Each one has the same structure (from the blueprint) but its own unique state: different families live inside, different colors are painted on the walls, different cars are in the driveways.

In Java:

• The Class is the blueprint.

• The Object is the actual house built from that blueprint.

This is the essence of Object-Oriented Programming. We write code that defines blueprints (classes) and then our program creates and uses individual instances (objects). This model is powerful because it mirrors how we think about the real world.

Breaking Down the Blueprint: Your First Class

Let’s translate our architect analogy into code. We’ll create a simple class representing a Dog. A class has two primary ingredients:

1. State (Fields/Attributes): What the object knows. These are variables unique to each object (e.g., name, age, breed).

2. Behavior (Methods): What the object does. These are actions the object can perform (e.g., bark(), eat(), sleep()).

Here’s what that looks like:

public class Dog {

    // State - Fields (About the Dog)
    String name;
    String breed;
    int age;

    // Behavior - Methods (what a Dog "does")
    void bark() {
        System.out.println("Woof! Woof!");
    }

    void sleep() {
        System.out.println("Zzzzz...");
    }
}

• public class Dog: This declares a new class named Dog. The public keyword means it’s accessible from anywhere (don’t worry about this for now).

• String name;: This is a field declaration. It states that every Dog object we create will have a piece of data called name that holds text (String).

• void bark() { ... }: This is a method declaration. It defines an action. void means it doesn’t return any value. When called, it will execute the code between the curly braces {}—in this case, printing “Woof! Woof!” to the console.

Important: We’ve just defined the blueprint. We haven’t created a single actual dog yet. This code, on its own, won’t produce any output.

Bringing Objects to Life: The new Keyword

A blueprint is useless until you build something from it. In Java, we create objects from a class using the powerful new keyword.

public class Main {
    public static void main(String[] args) {
        // Using the 'new' keyword to create Objects from the Class
        Dog myDog = new Dog();
        Dog neighborsDog = new Dog();

        // Setting the state (data) for each object
        myDog.name = "Fido";
        myDog.breed = "Golden Retriever";
        myDog.age = 3;

        neighborsDog.name = "Rex";
        neighborsDog.breed = "German Shepherd";
        neighborsDog.age = 5;

        // Triggering behavior on each object
        myDog.bark(); // Output: Woof! Woof!
        neighborsDog.bark(); // Output: Woof! Woof!

        System.out.println(myDog.name); // Output: Fido
        System.out.println(neighborsDog.name); // Output: Rex
    }
}

See what happened? We created two separate Dog objects from the one Dog class. Each has its own independent state. Telling myDog to bark doesn’t make neighborsDog bark. They are distinct entities, just like two real dogs.

The Engine Room: The main Method

You might have noticed the strange-looking public static void main(String[] args) method in the example above. This is non-negotiable in Java; it’s the entry point of your application. When you run a Java program, the Java Virtual Machine (JVM) looks for this exact method and starts executing the code inside it. Think of it as the ignition key that starts the car. Without it, nothing happens.

Let’s break down this cryptic signature:

• public: Allows the JVM to access it.

• static: Means this method belongs to the class itself, not to any specific object. This is why the JVM can call it before any objects are created.

• void: It doesn’t return any value.

• main: The mandatory name.

• String[] args: This allows you to pass command-line arguments to your program.

For now, just memorize it as the magic boilerplate code that makes your program run. You’ll understand static more deeply in a future post.

Memory Hook: “A Class is a cookie cutter. An Object is the actual cookie.” You design the cookie cutter (class) once. Then, you can press it into play-doh all day long, creating perfect, distinct copies (objects) every time. Each cookie can then be decorated differently (unique state).

Recall Trigger: This code snippet is your cheat sheet. See if you can read it and explain what each part does before moving on.

// 1. The Blueprint (Class)
public class Car {
    // State
    String model;
    int year;

    // Behavior
    void startEngine() {
        System.out.println("Vroom! The " + model + "'s engine is on.");
    }
}

// 2. The Program using the Blueprint
public class Showroom {
    public static void main(String[] args) {
        // Create Objects
        Car myCar = new Car();
        Car dadsCar = new Car();

        // Set State
        myCar.model = "Model 3";
        dadsCar.model = "F-150";

        // Trigger Behavior
        myCar.startEngine(); // Output: Vroom! The Model 3's engine is on.
    }
}

Your First Practical Use: Modeling the Real World

Why do we go through all this trouble? Because it allows us to model complex problems in a way that makes sense. Imagine building a simple bookstore application:

• You’d create a Book class with fields like title, author, price, and isInStock.

• You’d create methods like addToCart() or calculateShipping().

• Then, for every physical book in the store’s database, you create a Book object holding its specific information.

This organizational principle is why Java scales so well from small scripts to massive enterprise systems.

Retention Score: Do You Get It?

Before you move on to the next post (The Engine: Methods and Control Flow), give yourself a quick self-assessment. Can you do the following?

• 90% – Expert: Explain the difference between a Class and an Object to a friend without using programming jargon. Write a new class for a Cat with two fields and one method, then create two Cat objects in the main method and give them different states.

• 75% – Getting It: You look at the Car example above and can clearly identify which parts are the class definition, the object creation, the state, and the behavior. You understand why the main method is needed.

• <60% – Review Needed: The words class, new, and object still feel fuzzy. Go back and re-read the “Blueprint and Buildings” section. Type out the Dog example yourself—don’t just copy-paste. The physical act of typing code is a powerful learning tool.

If you’re not at least at 75%, play around with the code examples. Change the field names, add new methods like sleep(), and see what happens. Tinkering is the best way to learn.

Next Up: In the next post, we’ll bring these objects to life by diving deep into Methods and Control Flow (if statements, loops), teaching your objects how to make decisions and perform complex actions.