OOP Features & Advanced Topics: Inheritance, Polymorphism, Abstraction, Interfaces, Nested Classes & Design Patterns

Core OOP Principles in Java

1. Inheritance: Code Reusability & Hierarchy

Inheritance allows a subclass (child) to inherit fields/methods from a superclass (parent). Java supports single-level, multilevel, hierarchical, and multiple inheritance via interfaces.

How It Works

class Vehicle {  // Superclass
    String brand;
    void display() { System.out.println("Brand: " + brand); }
}

class Car extends Vehicle {  // Subclass
    String model;
    void showModel() { System.out.println("Model: " + model); }
}

Execution Trace:

Types of Inheritance

classDiagram
    class Vehicle {
        <<abstract>>
        +String brand
        +display()
    }
    class Car {
        +String model
        +showModel()
    }
    class Bike {
        +int speed
        +accelerate()
    }
    Vehicle <|-- Car
    Vehicle <|-- Bike
    Car --> Bike : "Hierarchical (Incorrect: Should be separate)"
    note for Car "Extends Vehicle"
    note for Bike "Extends Vehicle"

Real-World Example:

• eSewa’s Payment System:
  • Superclass: Payment (fields: amount, transactionId; method: process()).
  • Subclasses: OnlinePayment (extends Payment, adds cardDetails), CashPayment (extends Payment, adds receiptId).
  • Why? Avoids rewriting process() logic for each payment type.

2. Polymorphism: "One Interface, Many Forms"

Polymorphism enables method overriding (runtime) and method overloading (compile-time).

Method Overriding

class Animal {
    void sound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("Bark!"); }
}

State After Execution:

Method Overloading

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

Comparison Table:

Real-World Example:

• Ncell’s Billing System:
  • Overloading: calculateBill(int minutes) vs. calculateBill(int minutes, int dataUsage).
  • Overriding: Customer (base) has generateBill(), while PremiumCustomer overrides it to include discounts.

3. Abstraction: Hiding Implementation

Abstraction is achieved via abstract classes and interfaces.

Abstract Class

abstract class Shape {
    abstract double area();  // No body
    void display() { System.out.println("Shape"); }  // Concrete
}
class Circle extends Shape {
    double radius;
    @Override double area() { return 3.14 * radius * radius; }
}

State After Circle c = new Circle(); c.area();:

classDiagram
    class Shape {
        <<abstract>>
        +abstract double area()
    }
    class Circle {
        +double radius
        +double area()
    }
    Shape <|-- Circle
    note for Circle "Concrete implementation of area()"

Interfaces

interface Drivable {
    void start();
    void stop();
}
class Car implements Drivable {
    public void start() { System.out.println("Engine starts"); }
    public void stop() { System.out.println("Engine stops"); }
}

Key Differences:

Real-World Example:

• Pathao’s Ride System:
  • Interface: PaymentMethod (methods: processPayment()).
  • Implementations: CreditCardPayment, CashPayment, KhaltiPayment.
  • Why? Ensures all payment methods follow the same contract.

4. Nested Classes & Inner Classes

Nested classes improve encapsulation and scope control.

Types

1. Static Nested Class:

   class Outer {
       static class Nested {
           void display() { System.out.println("Static Nested"); }
       }
   }
   

2. Inner Class (Non-static):

   class Outer {
       class Inner {
           void display() { System.out.println("Inner Class"); }
       }
   }
   

3. Anonymous Class:

   Runnable r = new Runnable() {
       public void run() { System.out.println("Anonymous Runnable"); }
   };
   

4. Local Class:

   void method() {
       class Local { void show() { System.out.println("Local Class"); } }
       Local l = new Local();
       l.show();
   }
   

Real-World Example:

• Google Maps’ Route Planner:
  • Outer class: Map.
  • Inner class: RouteCalculator (accesses Map's private locations list).
  • Why? Avoids exposing locations to external classes.

5. Design Patterns in Java

Design patterns are reusable solutions to common problems.

Singleton Pattern (Ensures One Instance)

class Database {
    private static Database instance;
    private Database() {}  // Private constructor
    public static Database getInstance() {
        if (instance == null) instance = new Database();
        return instance;
    }
}

Execution Trace:

Real-World Example:

• NEPSE’s Trading System:
  • Singleton Market class ensures only one instance manages stock prices.

Factory Pattern (Object Creation)

interface Vehicle {
    void drive();
}
class Car implements Vehicle { public void drive() { System.out.println("Driving Car"); } }
class Bike implements Vehicle { public void drive() { System.out.println("Riding Bike"); } }

class VehicleFactory {
    public Vehicle getVehicle(String type) {
        if (type.equals("car")) return new Car();
        else return new Bike();
    }
}

State After VehicleFactory factory = new VehicleFactory(); factory.getVehicle("car");:

classDiagram
    class VehicleFactory {
        +Vehicle getVehicle(String type)
    }
    class Vehicle {
        <<abstract>>
        +abstract void drive()
    }
    class Car {
        +void drive()
    }
    VehicleFactory --> Car : "Creates"
    note for Car "Output: Driving Car"

Real-World Example:

• eSewa’s Payment Factory:
  • PaymentFactory.createPayment("khalti") returns KhaltiPayment object.

In the Real World

1. Khalti’s Payment Gateway:

   • Polymorphism: Uses interfaces like PaymentProcessor with implementations (CreditCardProcessor, KhaltiProcessor).
   • Singleton: Ensures one TransactionLogger instance across all payments.

2. Daraz’s Order Queue:

   • Priority Queue (via PriorityQueue class): Orders are processed based on priority (e.g., "Express" > "Standard").
   • State After Adding Orders:

3. Ncell’s Billing System:
   • Strategy Pattern: Different billing strategies (PrepaidStrategy, PostpaidStrategy) selected at runtime.
   • Code Snippet:

     interface BillingStrategy { double calculateBill(int usage); }
     class PrepaidStrategy implements BillingStrategy { ... }
     class PostpaidStrategy implements BillingStrategy { ... }
     

Exam Tip

1. Inheritance Questions:

   • Always show UML diagrams for class hierarchies.
   • Compare Java’s single inheritance with C++’s multiple inheritance.

2. Polymorphism:

   • For overriding, trace method calls at runtime (e.g., Animal a = new Dog(); a.sound(); → Bark!).
   • For overloading, list all method signatures in the answer.

3. Abstraction:

   • Abstract classes = "partial blueprint" (can have concrete methods).
   • Interfaces = "full contract" (Java 8+ allows default methods).

4. Design Patterns:

   • Singleton: Emphasize private constructor + static getter.
   • Factory: Show interface + concrete classes + factory method.

5. Nested Classes:

   • Anonymous classes are often used in event handling (e.g., button clicks in Swing).
   • Local classes are useful for short-lived objects (e.g., inside a method).

6. Real-World Mapping:

   • Relate eSewa’s payment to Strategy Pattern.
   • Relate Ncell’s billing to Method Overloading/Overriding.

Pro Tip: For coding questions (e.g., "Create a Distance class"), always:

1. Declare private fields.
2. Use constructors for initialization.
3. Implement getters/setters if needed.
4. Add methods for operations (e.g., add(), compare()).