Why Objects

Why this matters

• Java gives you no choice: every line of code lives inside a class, so these ideas are the grammar of the language rather than an optional style.
• The four pillars are the vocabulary used in every design discussion and almost every interview, and loose definitions are immediately audible.
• The real payoff is maintenance. Code organised around objects changes in one place when a rule changes.

The problem it solves

Before object orientation, programs were procedures operating on shared data. Any procedure could modify any data, so a change to one field meant auditing every procedure that touched it. As programs grew, nobody could say with confidence what might break.

Object orientation inverts that. Data becomes private to a class, and only that class's methods may touch it. A change to a field is now confined to one file.

Class versus object

public class Book {
    private final String title;       // each object gets its own
    private int copiesAvailable;
    private static int totalBooks;    // one copy, shared by every object

    public Book(String title, int copiesAvailable) {
        this.title = title;
        this.copiesAvailable = copiesAvailable;
        totalBooks++;
    }

    public boolean borrow() {
        if (copiesAvailable == 0) return false;
        copiesAvailable--;
        return true;
    }

    public static int totalBooks() {
        return totalBooks;
    }
}

Book java = new Book("Effective Java", 3);
Book clean = new Book("Clean Code", 1);

java.borrow();
System.out.println(Book.totalBooks());   // 2 — shared across both objects

Each Book has its own title and copiesAvailable. totalBooks belongs to the class, so both constructors incremented the same counter.

The four pillars

The four pillars in one example

// Abstraction: callers depend on what a payment does, not how
public interface PaymentMethod {
    boolean charge(BigDecimal amount);
}

// Encapsulation: balance is private and guarded by the class's own rules
public class Wallet implements PaymentMethod {
    private BigDecimal balance;

    public Wallet(BigDecimal balance) {
        this.balance = balance;
    }

    @Override
    public boolean charge(BigDecimal amount) {
        if (balance.compareTo(amount) < 0) return false;
        balance = balance.subtract(amount);
        return true;
    }
}

// Inheritance: a specialised wallet reusing everything above
public class RewardsWallet extends Wallet {
    public RewardsWallet(BigDecimal balance) {
        super(balance);
    }

    @Override
    public boolean charge(BigDecimal amount) {
        boolean ok = super.charge(amount);
        if (ok) awardPoints(amount);
        return ok;
    }

    private void awardPoints(BigDecimal amount) { }
}

// Polymorphism: this method never changes, whatever you pass it
public void checkout(PaymentMethod method, BigDecimal total) {
    if (!method.charge(total)) {
        throw new IllegalStateException("Payment declined");
    }
}

Adding a new payment method means writing one class. The checkout method is never touched. That is the entire value proposition in one line.

Associations between objects

Objects rarely stand alone. The relationship between two of them has a name, and the name tells you about lifetime.

The practical test is whether the contained object makes sense on its own. If it does, you have aggregation; if it does not, composition. This distinction becomes concrete when you decide whether a constructor should accept a part or build it.

Common misreadings

• "Everything should be an object." Utility classes of static methods, like Math or Collections, are legitimate and correct. Not every concept needs state.
• "Inheritance is the main tool for reuse." Composition is usually the better one, for reasons covered in detail later in this module.
• "Encapsulation means writing a getter and setter for every field." A public setter for every private field is encapsulation in name only. Expose operations, not fields.
• "A class is an object." The class is the definition. new produces objects from it.