Chapter 6: Objects and Classes – Thinking in Java

• A Class is a blueprint. It is a template that defines what a "thing" will look like and what it will do. It doesn't actually exist in memory as a "thing" yet; it’s just a plan.
  
  
• An Object is an instance of that class. If the class is the blueprint for a house, the object is the actual house built of bricks and mortar where someone lives.
  
  

1. Fields (State/Attributes): These are variables that belong to the class. They represent what the object is or has (e.g., a Car has a color, a model, and a topSpeed).
   
   
2. Methods (Behavior): These are functions defined inside the class. They represent what the object does (e.g., a Car can accelerate(), brake(), and honk()).
   
   

class Smartphone {
    // 1. Fields (Attributes)
    String brand;
    String model;
    int storageCapacity;
    double batteryLevel;

    // 2. Methods (Behaviors)
    void makeCall(String contactName) {
        System.out.println("Calling " + contactName + "...");
    }

    void checkBattery() {
        System.out.println("Battery is at: " + batteryLevel + "%");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create an object of the Smartphone class
        Smartphone myPhone = new Smartphone();

        // Assigning values to the fields (using the dot operator)
        myPhone.brand = "Apple";
        myPhone.model = "iPhone 15";
        myPhone.batteryLevel = 85.5;

        // Calling methods
        myPhone.makeCall("Mom");
        myPhone.checkBattery();
    }
}

• It has the exact same name as the class.
  
  
• It has no return type (not even void).
  
  

class Smartphone {
    String brand;
    String model;

    // Constructor
    Smartphone(String b, String m) {
        brand = b;
        model = m;
        System.out.println("A new phone has been created!");
    }
}

// Now we can create a phone in one line:
Smartphone yourPhone = new Smartphone("Samsung", "Galaxy S23");

class Smartphone {
    String brand; // This belongs to the class

    Smartphone(String brand) { 
        this.brand = brand; // "Set THIS object's brand to the brand passed in"
    }
}

• The Stack: This is where local variables and method calls live. It's fast but small. When a method finishes, its stack memory is wiped.
  
  
• The Heap: This is where all objects live. When you say new Smartphone(), Java carves out a chunk of space in the Heap.
  
  

1. The myPhone variable is stored on the Stack.
   
   
2. The actual object data is stored on the Heap.
   
   
3. The variable on the Stack simply holds a reference (the memory address) to the object on the Heap.
   
   

1. Mark your variables as private.
   
   
2. Provide public methods called Getters and Setters to access/modify them.
   
   

class BankAccount {
    private double balance; // No one can change this directly!

    // Setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            System.out.println("Invalid deposit amount!");
        }
    }

    // Getter
    public double getBalance() {
        return balance;
    }
}

class Player {
    private String name;
    private int health;
    private int level;

    // Constructor
    public Player(String name) {
        this.name = name;
        this.health = 100; // Default health
        this.level = 1;    // Default level
    }

    public void takeDamage(int damage) {
        this.health -= damage;
        if (this.health < 0) this.health = 0;
        System.out.println(name + " took damage! Health: " + health);
    }

    public void heal(int amount) {
        this.health += amount;
        if (this.health > 100) this.health = 100;
        System.out.println(name + " healed. Health: " + health);
    }

    public void displayStats() {
        System.out.println("--- " + name + " ---");
        System.out.println("Level: " + level);
        System.out.println("Health: " + health);
    }
}

public class Game {
    public static void main(String[] args) {
        Player p1 = new Player("Aragorn");
        Player p2 = new Player("Legolas");

        p1.takeDamage(30);
        p2.heal(10);
        
        p1.displayStats();
        p2.displayStats();
    }
}

• Classes are blueprints; Objects are the real-world instances.
  
  
• Objects have State (Fields) and Behavior (Methods).
  
  
• Constructors initialize objects when they are created with the new keyword.
  
  
• this differentiates between class variables and parameters.
  
  
• Encapsulation protects data by making fields private and using Getters/Setters.
  
  
• Objects live on the Heap, while references to them live on the Stack.