Classes & Objects: Blueprints and Buildings

Lesson 1 of 8

Classes & Objects: Blueprints and Buildings

What is it? (The Analogy)

Picture this: you are an architect, and you have just drawn up the blueprint for a house. The blueprint says "there will be 3 bedrooms, 2 bathrooms, a kitchen, and a garage." But here is the thing -- you cannot live in a blueprint. You cannot cook dinner on a blueprint. You cannot park your car inside a blueprint. The blueprint is just a *plan*. It describes what a house *will look like* when someone actually builds it.

Now, when a construction crew takes that blueprint and builds an actual house on 123 Main Street -- THAT is a real, physical thing you can live in. And the cool part? They can use the same blueprint to build another house on 456 Oak Avenue. Same plan, different house. Each house has its own address, its own paint color, its own furniture inside. They are independent -- painting one house red does not magically turn the other house red.

In Java, a class is the blueprint, and an object is the actual house built from it. The class describes what properties (fields) and behaviors (methods) something will have. The object is a real, living instance of that class sitting in your computer's memory. You write the class ONCE, but you can create as many objects from it as you want. Each object has its own copy of the data. This is the most fundamental concept in all of Object-Oriented Programming, and everything else builds on top of it.

Why do we need it?

Let's feel the pain of life WITHOUT classes and objects. Imagine you are writing a program to manage students at a school. Without OOP, you might do something like this:

java

1// WITHOUT classes -- total chaos!
2String student1Name = "Alice";
3int student1Age = 16;
4double student1Gpa = 3.8;
5
6String student2Name = "Bob";
7int student2Age = 17;
8double student2Gpa = 3.2;
9
10String student3Name = "Charlie";
11int student3Age = 16;
12double student3Gpa = 3.5;
13
14// Want 100 students? Good luck creating 300 variables!
15// Want to pass a student to a method? Pass 3 separate arguments every time!
16// Want to add a new field like "email"? Change EVERY method in the program!

That is a NIGHTMARE. The data for each student is scattered across separate variables with no connection between them. Now look at life WITH classes:

java

1// WITH classes -- clean, organized, beautiful!
2Student alice = new Student("Alice", 16, 3.8);
3Student bob = new Student("Bob", 17, 3.2);
4Student charlie = new Student("Charlie", 16, 3.5);
5
6// Want 100 students? Put them in a list!
7// Want to pass a student? Pass ONE object!
8// Want to add "email"? Change ONE class!

Classes let us bundle related data and behavior together into a single, reusable unit. This is the foundation of organized, maintainable code.

How it works -- Step by Step

Define a class -- Write a blueprint that describes the fields (data) and methods (behavior) an object will have.
Declare a variable -- Create a reference variable that can *point to* an object of that class type.
**Instantiate with \new\** -- Use the \new\ keyword to actually build an object in memory (the heap).
The constructor runs -- When \new\ is called, Java runs the constructor to initialize the object's fields.
Use the object -- Call methods on it, read its fields, pass it around to other methods.
Garbage collection -- When no variable points to an object anymore, Java cleans it up automatically.

Let's Build It Together

Let's build a video game character system step by step!

java

1// Step 1: Define the CLASS -- this is our blueprint
2public class GameCharacter {
3
4    // These are FIELDS (instance variables)
5    // Every object created from this class gets its OWN copy
6    String name;
7    int healthPoints;
8    int attackPower;
9    String characterClass;  // "Warrior", "Mage", "Archer"
10
11    // This is a CONSTRUCTOR -- it runs when you say "new GameCharacter(...)"
12    // Think of it as the "initialization ritual" for a new object
13    public GameCharacter(String name, String characterClass, int hp, int attack) {
14        this.name = name;                // "this" refers to the object being created
15        this.characterClass = characterClass;
16        this.healthPoints = hp;
17        this.attackPower = attack;
18    }
19
20    // These are METHODS -- behaviors the object can perform
21    public void attack(GameCharacter target) {
22        System.out.println(name + " attacks " + target.name + " for " + attackPower + " damage!");
23        target.healthPoints -= attackPower;
24
25        if (target.healthPoints <= 0) {
26            System.out.println(target.name + " has been defeated!");
27        } else {
28            System.out.println(target.name + " has " + target.healthPoints + " HP remaining.");
29        }
30    }
31
32    public void heal(int amount) {
33        healthPoints += amount;
34        System.out.println(name + " heals for " + amount + "! HP is now " + healthPoints);
35    }
36
37    public void introduce() {
38        System.out.println("I am " + name + ", a " + characterClass
39            + " with " + healthPoints + " HP and " + attackPower + " attack power!");
40    }
41}

java

1// Step 2: CREATE OBJECTS from the blueprint
2public class GameDemo {
3    public static void main(String[] args) {
4
5        // Each "new" creates a SEPARATE object in memory
6        GameCharacter warrior = new GameCharacter("Thorin", "Warrior", 150, 25);
7        GameCharacter mage = new GameCharacter("Gandara", "Mage", 80, 40);
8        GameCharacter archer = new GameCharacter("Legora", "Archer", 100, 30);
9
10        // Each object is independent -- they have their own data!
11        warrior.introduce();  // I am Thorin, a Warrior with 150 HP and 25 attack power!
12        mage.introduce();     // I am Gandara, a Mage with 80 HP and 40 attack power!
13        archer.introduce();   // I am Legora, an Archer with 100 HP and 30 attack power!
14
15        // Objects can interact with each other
16        warrior.attack(mage);    // Thorin attacks Gandara for 25 damage!
17        mage.heal(10);           // Gandara heals for 10! HP is now 65
18        archer.attack(warrior);  // Legora attacks Thorin for 30 damage!
19
20        // IMPORTANT: warrior and mage are DIFFERENT objects
21        // Changing one does NOT affect the other
22        System.out.println(warrior.healthPoints);  // 120 (took 30 damage from archer)
23        System.out.println(mage.healthPoints);     // 65 (took 25 damage, healed 10)
24    }
25}

The Big Aha! When you write \GameCharacter warrior = new GameCharacter(...)\, two things happen: (1) Java allocates space on the heap for a new GameCharacter object, (2) the variable \warrior\ on the stack stores a *reference* (like an address) pointing to that heap object. The variable is NOT the object -- it is a remote control that points to the object.

Visual Mental Model

java

1    THE BLUEPRINT (Class)                    THE BUILDINGS (Objects)
2    +---------------------+
3    |   GameCharacter     |          HEAP MEMORY:
4    |---------------------|          +-------------------------+
5    | - name              |   new    | Object #1 (warrior)     |
6    | - healthPoints      | -------> | name = "Thorin"         |
7    | - attackPower       |          | healthPoints = 150      |
8    | - characterClass    |          | attackPower = 25        |
9    |---------------------|          | characterClass="Warrior"|
10    | + attack()          |          +-------------------------+
11    | + heal()            |
12    | + introduce()       |   new    +-------------------------+
13    +---------------------+ -------> | Object #2 (mage)        |
14                                     | name = "Gandara"        |
15                                     | healthPoints = 80       |
16    STACK MEMORY:                    | attackPower = 40        |
17    +-----------+                    | characterClass = "Mage" |
18    | warrior --|---> points to #1   +-------------------------+
19    | mage   --|---> points to #2
20    | archer --|---> points to #3    +-------------------------+
21    +-----------+                    | Object #3 (archer)      |
22                                     | name = "Legora"         |
23                                     | healthPoints = 100      |
24                                     | attackPower = 30        |
25                                     | characterClass="Archer" |
26                                     +-------------------------+

Real-World Analogy Recap

A class is a cookie cutter, and objects are the cookies. One cookie cutter can stamp out dozens of cookies, and each cookie can be decorated differently (different frosting, sprinkles, etc.). The cookie cutter defines the *shape* -- the cookies are the actual things you eat. In Java, you write the class once, and \new\ stamps out as many objects as you need, each with its own independent data.

Common Mistakes & Gotchas

**Forgetting \new\**: Writing \GameCharacter hero;\ only creates a reference variable set to \null\. You MUST say \new GameCharacter(...)\ to actually create an object. Trying to use a \null\ reference gives you the dreaded \NullPointerException\.
Confusing the reference with the object: The variable \warrior\ is not the object itself -- it is a *pointer* to the object. If you write \GameCharacter copy = warrior;\, both variables now point to the SAME object. Changing \copy.healthPoints\ changes \warrior.healthPoints\ too!
**Forgetting \this\**: Inside a constructor, if your parameter name matches the field name, you MUST use \this.name = name\ to distinguish between the field and the parameter. Without \this\, you are just assigning the parameter to itself.
Thinking classes run code: A class definition does not DO anything by itself. It just sits there. Code only runs when you create objects and call methods, starting from \main()\.
One public class per file: In Java, a file can have at most one \public\ class, and the filename must match that class name exactly (including capitalization).

Interview Tip

Interviewers love asking: "What is the difference between a class and an object?" The killer answer is: "A class is a compile-time blueprint that defines structure and behavior. An object is a runtime instance of that class, living on the heap with its own state. Multiple objects can be created from one class, each maintaining independent state." Bonus points if you mention stack vs heap memory.

Quick Quiz

If you create 5 GameCharacter objects, how many copies of the \name\ field exist in memory? (Hint: each object gets its own copy of instance variables!)
What happens if you write \GameCharacter hero;\ but never use \new\? What value does \hero\ hold?
If \a\ and \b\ both point to the same object, and you change a field through \a\, does \b\ see the change? Why?

Summary -- Key Takeaways

A class is a blueprint/template that defines fields (data) and methods (behavior). It is a compile-time concept.
An object is a runtime instance of a class, created with \new\, living on the heap with its own independent state.
Constructors initialize objects when they are created. They have the same name as the class and no return type.
Variables of a class type hold references (pointers) to objects, not the objects themselves. Understanding this is crucial for avoiding bugs.

Home

Encapsulation: Protecting Your DataNext