OOP Concepts — Abstraction, Encapsulation, Inheritance, Polymorphism

🎯 Learning Objectives

• Explain the four pillars of OOP with concrete analogies
• Distinguish between abstraction and encapsulation
• Describe how subtyping enables polymorphism
• Understand how dynamic dispatch works at runtime
• Compare Java's OOP implementation with Python's

📋 Prerequisites

• Java Introduction (01-java-introduction.md): Basic Java syntax
• Memory Model (03-memory-model.md): References, heap allocation
• BSCS1002 — Python: You've used classes and objects in Python

1. Intuition: Why Object-Oriented Programming?

1.1 What Problem Does OOP Solve?

1. Assembly-line approach (procedural): Have a single huge list of instructions: "Cut board A, nail to board B, attach door C, paint wall D..."
2. Modular approach (OOP): Build rooms as separate modules. Each room has its own door, windows, and walls. You can reuse the "Bedroom" design in multiple houses, customize it, and fix a leaky window without touching the rest of the house. OOP organizes code around objects (things in the real world) rather than actions. This makes large programs easier to understand, maintain, and extend.

1.2 The Four Pillars (Mental Model)

2. Abstraction — Hiding Complexity

2.1 Intuition

2.2 In Code

java
// WHAT it does (accessible interface)
public class CoffeeMachine {
    public Coffee brew(EspressoOrder order) { ... }
    public Coffee brew(LatteOrder order) { ... }
    // HOW it does it (hidden from users)
    private void heatWater() { ... }
    private void grindBeans() { ... }
    private void pressurize() { ... }
}

2.3 Java Mechanisms for Abstraction

• Abstract classes (abstract class): Partially implemented classes that cannot be instantiated
• Interfaces (interface): Fully abstract contracts that classes implement
• Methods: Public methods define the API; private methods are implementation details

3. Encapsulation — Data Protection

3.1 Intuition

3.2 In Code

java
public class BankAccount {
    private double balance;  // Private — cannot access from outside
    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        }
    }
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    public boolean withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
    public double getBalance() {  // Controlled access via getter
        return balance;
    }
}

3.3 The private Keyword

• Setting an invalid value (e.g., negative balance)
• Dependencies on internal implementation (you can change the internal structure without affecting external code)

3.4 Getters and Setters

java
public class Person {
    private String name;
    private int age;
    // Getter
    public String getName() {
        return name;
    }
    // Setter with validation
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        }
    }
}

4. Inheritance — "Is-a" Relationship

4.1 Intuition

4.2 In Code

java
// Base class (parent)
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}
// Derived class (child) — Dog IS-A Animal
public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // Call parent constructor
    }
    public void bark() {
        System.out.println(name + " says Woof!");
    }
    @Override
    public void eat() {  // Override parent's method
        System.out.println(name + " is eating dog food.");
    }
}

4.3 Key Concepts

java
public class Dog extends Animal { ... }

java
super(name);              // Call parent constructor
super.eat();              // Call parent method

4.4 Constructor Chaining

java
Dog d = new Dog("Buddy");
// 1. Animal("Buddy") runs first (super class)
// 2. Dog("Buddy") runs next (subclass)

4.5 Method Overriding

java
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println(name + " is eating cat food.");
    }
}

4.6 final Keyword on Classes and Methods

• final class: Cannot be extended (e.g., String, Integer)
• final method: Cannot be overridden

java
public final class FinalClass { }  // Cannot be inherited
public class Parent {
    public final void cannotOverride() { }
}

5. Polymorphism — Many Forms

5.1 Intuition

5.2 Compile-Time Polymorphism (Method Overloading)

java
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

5.3 Runtime Polymorphism (Dynamic Dispatch)

java
Animal myPet = new Dog("Buddy");  // Reference is Animal, actual is Dog
myPet.eat();  // Calls Dog's eat() — dynamic dispatch!

5.4 Upcasting and Downcasting

java
Dog dog = new Dog("Buddy");
Animal animal = dog;  // Upcast — Dog → Animal (always safe)

java
Animal animal = new Dog("Buddy");
Dog dog = (Dog) animal;      // OK — animal IS a Dog
Cat cat = (Cat) animal;      // Compiles but ClassCastException at runtime!

java
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // Safe
}

5.5 Polymorphism Enables Flexibility

java
public class Zoo {
    public void feedAll(Animal[] animals) {
        for (Animal a : animals) {
            a.eat();  // Each animal eats its own way
        }
    }
}
// Usage
Animal[] animals = {new Dog("Buddy"), new Cat("Kitty"), new Dog("Max")};
Zoo zoo = new Zoo();
zoo.feedAll(animals);
// Buddy is eating dog food.
// Kitty is eating cat food.
// Max is eating dog food.

6. Understanding static Members

6.1 Instance vs Static

java
public class Student {
    public String name;           // Instance variable
    public static int count;      // Class variable (one shared value)
    public static final String COLLEGE = "IIT Madras";  // Constant
    public Student(String name) {
        this.name = name;
        count++;  // Increment shared counter
    }
}
// Usage
Student s1 = new Student("Alice");
Student s2 = new Student("Bob");
System.out.println(Student.count);  // 2 — shared across instances
System.out.println(s1.COLLEGE);     // IIT Madras

7. Java vs Python: OOP Comparison

8. Common Pitfalls

Pitfall 1: Confusing Overloading with Overriding

java
public class Parent {
    public void doSomething(int x) { }
}
public class Child extends Parent {
    public void doSomething(double x) { }  // OVERLOADING, not overriding!
}

Pitfall 2: Accessing Private Members in Subclass

java
public class Parent {
    private int secret = 42;
}
public class Child extends Parent {
    public void show() {
        System.out.println(secret);  // Compile error!
    }
}

Pitfall 3: instanceof with null

java
Dog dog = null;
if (dog instanceof Dog) {  // Returns false, not NullPointerException!
    System.out.println("It's a dog");
}

Pitfall 4: Static Methods Cannot Be Overridden

java
public class Parent {
    public static void greet() {
        System.out.println("Parent");
    }
}
public class Child extends Parent {
    public static void greet() {  // This HIDES, not overrides
        System.out.println("Child");
    }
}
// Usage
Parent p = new Child();
p.greet();  // Prints "Parent", not "Child"!

Pitfall 5: Forgetting super() Call

java
public class Parent {
    public Parent(int x) {
        System.out.println("Parent: " + x);
    }
}
public class Child extends Parent {
    public Child() {
        // Implicit super() — but Parent has no no-arg constructor!
    }
}

9. Practice Questions

Q1: What is the output?

java
class A {
    public void show() {
        System.out.println("A");
    }
}
class B extends A {
    public void show() {
        System.out.println("B");
    }
}
public class Test {
    public static void main(String[] args) {
        A obj = new B();
        obj.show();
    }
}

Answer: B

Dynamic dispatch: Even though the reference type is A, the actual object is B. Java determines at runtime which show() to call based on the actual object type (B). Q2: What is wrong with this code?

java
public class Main {
    public static void main(String[] args) {
        Animal a = new Animal("Generic");
    }
}
abstract class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void sound();
}

Answer: Animal is abstract, so you cannot instantiate it with new Animal(...). Abstract classes can only be extended by concrete subclasses. Fix: Create a concrete subclass or remove abstract from the class declaration. Q3: Explain the output

java
class Parent {
    int x = 10;
}
class Child extends Parent {
    int x = 20;
}
public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.x);

        Child c = new Child();
        System.out.println(c.x);
    }
}

Answer: 10 then 20

Fields are not polymorphic! Java resolves field access at compile-time based on reference type, not runtime type. p.x uses Parent.x = 10 because p is declared as Parent. c.x uses Child.x = 20 because c is declared as Child. This is called field shadowing, not overriding. Q4: What is encapsulation and why is it important?

Answer: Encapsulation is the bundling of data (fields) with methods that operate on that data, while restricting direct access to the internal state. It's important because:

1. Protection: Prevents invalid state (e.g., negative age, empty name)
2. Flexibility: Internal implementation can change without affecting external code
3. Maintainability: Dependencies are clearly defined through the public API
4. Testing: Components can be tested in isolation

In Java, encapsulation is achieved through private fields with public getter/setter methods. Q5: What is the difference between abstraction and encapsulation?

Answer:

Q6: What is the output? Explain the concept.

java
class MathUtils {
    public static int square(int x) {
        return x * x;
    }
}
public class Test {
    public static void main(String[] args) {
        int result = MathUtils.square(5);
        System.out.println(result);
    }
}

Answer: 25

The square method is static, meaning it belongs to the class, not to any instance. It is called using the class name (MathUtils.square(5)) without creating an object. Static methods can only access other static members directly. Q7: Why does this code throw ClassCastException?

java
Animal a = new Dog();
Cat c = (Cat) a;

Answer: The Animal reference a actually points to a Dog object. Downcasting it to Cat asks the JVM to treat a Dog as a Cat, which is impossible. instanceof check would prevent this:

java
if (a instanceof Cat) {
    Cat c = (Cat) a;  // Safe
} else {
    System.out.println("Not a cat");
}

Q8: Which OOP pillar does method overriding implement?

Answer: Polymorphism — specifically runtime polymorphism (dynamic dispatch). Overriding allows a subclass to provide its own implementation of a method defined in the parent class. When called through a parent reference, the JVM determines at runtime which version to execute based on the actual object type.

Related: Method overloading implements compile-time polymorphism (also called static polymorphism or ad-hoc polymorphism). Q9: What does super do in a constructor?

Answer: super() calls the parent class constructor. It must be the first statement in a constructor. If you don't explicitly write super(), the compiler inserts an implicit super() call to the no-arg constructor. If the parent class has no no-arg constructor, you must explicitly call super(args).

java
public Child(int x) {
    super(x);  // Must be first statement
    // Other initialization...
}

Q10: Can you override a private method? A static method? A final method?

Answer:

• Private method: No. Private methods are not visible to subclasses, so they cannot be overridden (they can be redeclared, but that's a new method, not an override).
• Static method: No. Static methods are hidden, not overridden. The method called depends on the reference type, not the object type.
• Final method: No. final explicitly prevents overriding.

📐 Key Concepts

🔗 Cross-References

• Next: Arrays — first concrete data structure
• Related: Polymorphism, Abstract Classes & Interfaces
• Python Comparison: BSCS1002 — OOP in Python
• Reference: Oracle Java Tutorials — Object-Oriented Programming Concepts Join Discord Previous1.4 Control FlowNext2.1 Arrays