The Four Pillars of OOP

• Class = blueprint: state (fields) + behavior (methods)
• Object = one instance, created at runtime
• Constructor runs on creation to initialise state
• No constructor defined → compiler adds a no-arg default

Car c = new Car("red");
c.drive();

one object, method called through the reference c

• b = a copies the reference, not the object
• Both point to the same object

• Encapsulation = data plus the methods that act on it, in one class
• Fields are private; outside code uses public methods
• Getters/setters validate input and let internals change without breaking callers

private double balance;
public void deposit(double x) {
    if (x <= 0)
        throw new IllegalArgumentException();
    balance += x;
}

balance can never get a bad value

• Abstraction = expose what an object does, hide how
• Built with abstract class and interface
• Model only the essential behavior

• Public getter returning the internal mutable list leaks state

• Inheritance = subclass reuses and extends a superclass
• Models is-a: a Dog is an Animal
• Syntax: class Dog extends Animal
• Subclass gets the non-private fields and methods

• super(...) calls the parent constructor: first statement in the child constructor
• super.method() calls the parent version of a method
• Java allows one superclass only
• Multiple behavior: implement several interfaces

class Dog extends Animal {
  Dog() { super("Rex"); }
  void speak() {
    super.speak();
  }
}

parent constructor first, then parent method

• Polymorphism = one call, behaviour depends on the object
• Overloading: same name, different parameters, same class; compile time (static binding)
• Overriding: subclass redefines inherited method, same signature; runtime (dynamic dispatch)

class Animal { void speak() { print("..."); } }
class Dog extends Animal {
  @Override void speak() { print("Woof"); }
}
Animal a = new Dog();
a.speak();

runtime type decides, not the reference type

• static methods are hidden, not overridden
• private and final methods cannot be overridden

• Composition = has-a: a field holds another object
• Work is delegated to it (Car has an Engine)

• Engine is passed in; start() delegates to it

• Inheriting only to reuse code: fragile base class, a parent change breaks every child
• Deep hierarchies are hard to follow: keep them shallow

• Inheritance = is-a, extends, super()
• Reference type decides what you can call
• Object type decides which override runs

Animal a = new Dog();
a.speak(); // Dog.speak() runs
a.fetch(); // compile error

Animal has no fetch()

• extends for is-a, composition for has-a
• Default to composition
• Use @Override and final deliberately