Object-Oriented Programming

Every class has three parts: fields (data it stores), a constructor (how to create it), and methods (what it can do). Let's build a Car class step by step:

public class Car {
    // ━━━ FIELDS (data each car stores) ━━━
    String brand;
    int year;
    double mileage;

    // ━━━ CONSTRUCTOR (how to create a car) ━━━
    public Car(String brand, int year) {
        this.brand = brand;    // "this.brand" = the field
        this.year = year;      // "brand" = the parameter
        this.mileage = 0;      // default starting mileage
    }

    // ━━━ METHODS (what a car can do) ━━━
    public void drive(double miles) {
        this.mileage += miles;
    }

    public String displayInfo() {
        return brand + " (" + year + ") — " + mileage + " miles";
    }
}

Now let's USE this class by creating objects:

// Creating objects from the Car blueprint
Car myCar = new Car("Toyota", 2023);
Car friendsCar = new Car("Honda", 2021);

// Each object has its OWN data
myCar.drive(150);
friendsCar.drive(3200);

System.out.println(myCar.displayInfo());
// → "Toyota (2023) — 150.0 miles"

System.out.println(friendsCar.displayInfo());
// → "Honda (2021) — 3200.0 miles"

Inside a method or constructor, this refers to the current object — the specific car, student, or account that the method is being called on. It's most important when parameter names match field names:

// ❌ WITHOUT this — the parameter "shadows" the field
public Car(String brand) {
    brand = brand;  // Sets the parameter to itself! Field unchanged!
}

// ✅ WITH this — clearly distinguishes field from parameter
public Car(String brand) {
    this.brand = brand;  // this.brand = the field, brand = the parameter
}

// this also lets you chain constructors:
public Car(String brand) {
    this(brand, 2024);  // Calls the other constructor
}

Encapsulation means hiding the internal data of an object and only allowing access through controlled methods. Think of a bank account: you can't reach into the vault directly. You go through the teller (methods) who validates your request.

public class BankAccount {
    private double balance;  // PRIVATE — can't be accessed from outside!

    public BankAccount(double initial) {
        if (initial < 0) {
            throw new IllegalArgumentException("Can't start negative!");
        }
        this.balance = initial;
    }

    // GETTER — read-only access
    public double getBalance() {
        return balance;
    }

    // SETTER with validation — controlled write access
    public void deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Amount must be positive!");
            return;
        }
        balance += amount;
    }

    public boolean withdraw(double amount) {
        if (amount > balance) {
            System.out.println("Insufficient funds!");
            return false;
        }
        balance -= amount;
        return true;
    }
}

// Usage:
BankAccount acct = new BankAccount(1000);
acct.deposit(500);       // ✅ Goes through validation
acct.withdraw(200);      // ✅ Checks balance first
// acct.balance = -999;  // ❌ Won't compile — balance is private!

Just like methods, constructors can be overloaded — you can have multiple constructors with different parameter lists, giving users different ways to create objects:

public class Student {
    private String name;
    private String grade;
    private double gpa;

    // Full constructor
    public Student(String name, String grade, double gpa) {
        this.name = name;
        this.grade = grade;
        this.gpa = gpa;
    }

    // Partial constructor (defaults)
    public Student(String name) {
        this(name, "Freshman", 0.0);  // Calls the full constructor
    }

    // Copy constructor
    public Student(Student other) {
        this(other.name, other.grade, other.gpa);
    }
}

// Usage:
Student s1 = new Student("Alice", "Junior", 3.8);
Student s2 = new Student("Bob");          // Freshman, GPA 0.0
Student s3 = new Student(s1);             // Copy of Alice

Instance members belong to each individual object (each car has its own mileage). Static members belong to the class itself and are shared by all objects.

public class Car {
    // Instance field — each car has its own
    private String brand;
    private double mileage;

    // Static field — shared by ALL cars
    private static int totalCarsCreated = 0;

    public Car(String brand) {
        this.brand = brand;
        this.mileage = 0;
        totalCarsCreated++;  // Incremented for EVERY car
    }

    // Static method — called on the CLASS, not an object
    public static int getTotalCars() {
        return totalCarsCreated;
    }
}

Car a = new Car("Toyota");
Car b = new Car("Honda");
Car c = new Car("BMW");
System.out.println(Car.getTotalCars());  // 3 (shared counter)

These four principles are the foundation of object-oriented design. You've already learned the first two — the others come in the next lessons:

By default, printing an object shows something useless like Car@1b6d3586. Override toString() to make it human-readable:

public class Car {
    private String brand;
    private int year;

    @Override
    public String toString() {
        return brand + " (" + year + ")";
    }
}

Car car = new Car("Toyota", 2023);
System.out.println(car);  // "Toyota (2023)" — automatically calls toString()

// Without @Override toString(), it would print: Car@1b6d3586