Unit 8: Inheritance & Polymorphism

Opening Hook — The Code Behind Every UPI Payment

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — Inheritance & Polymorphism from Scratch

1. Types of Inheritance in Java

Inheritance allows a new class to acquire the properties and behaviours of an existing class. The existing class is called the parent/super/base class, and the new class is the child/sub/derived class.

Java
// Single Inheritance
class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

// Multilevel Inheritance
class Puppy extends Dog {
    void play() {
        System.out.println("Puppy plays");
    }
}

// Hierarchical Inheritance
class Cat extends Animal {
    void meow() {
        System.out.println("Cat meows");
    }
}

2. The extends Keyword & IS-A Relationship

The extends keyword establishes an IS-A relationship. When you write class SavingsAccount extends BankAccount, you're saying "a SavingsAccount IS-A BankAccount." Every SavingsAccount is a BankAccount, but not every BankAccount is a SavingsAccount.

Java
class BankAccount {
    protected String accountHolder;
    protected double balance;

    public BankAccount(String holder, double balance) {
        this.accountHolder = holder;
        this.balance = balance;
    }

    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: ₹" + amount);
    }

    public void displayBalance() {
        System.out.println(accountHolder + " — Balance: ₹" + balance);
    }
}

class SavingsAccount extends BankAccount {
    private double interestRate;

    public SavingsAccount(String holder, double balance, double rate) {
        super(holder, balance);  // calls parent constructor
        this.interestRate = rate;
    }

    public double calculateInterest() {
        return balance * interestRate / 100;
    }
}

3. The super Keyword — 3 Uses

Java
// Use 1: Access parent variable
class Vehicle {
    int speed = 100;
}

class Car extends Vehicle {
    int speed = 200;

    void showSpeeds() {
        System.out.println("Car speed: " + speed);           // 200
        System.out.println("Vehicle speed: " + super.speed); // 100
    }
}

// Use 2: Call parent method
class Animal {
    void sound() { System.out.println("Animal makes sound"); }
}

class Dog extends Animal {
    void sound() {
        super.sound();  // calls Animal's sound()
        System.out.println("Dog barks");
    }
}

// Use 3: Call parent constructor
class Person {
    String name;
    Person(String name) { this.name = name; }
}

class Student extends Person {
    int rollNo;
    Student(String name, int rollNo) {
        super(name);   // MUST be first statement
        this.rollNo = rollNo;
    }
}

4. Method Overriding — 5 Rules & @Override

Method overriding allows a child class to provide a specific implementation of a method already defined in the parent class. This is the foundation of runtime polymorphism.

The @Override annotation tells the compiler "I intend to override a parent method." If the method doesn't actually override anything (typo in name, wrong params), the compiler throws an error — saving you from hard-to-find bugs.

Java
class Shape {
    public double area() {
        return 0;
    }
}

class Circle extends Shape {
    double radius;

    Circle(double r) { this.radius = r; }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length, width;

    Rectangle(double l, double w) { length = l; width = w; }

    @Override
    public double area() {
        return length * width;
    }
}

class Triangle extends Shape {
    double base, height;

    Triangle(double b, double h) { base = b; height = h; }

    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

public class ShapeTest {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Triangle(3, 8)
        };
        for (Shape s : shapes) {
            System.out.println(s.getClass().getSimpleName()
                + " area: " + s.area());
        }
    }
}

5. The Object Class — Mother of All Classes

Every class in Java implicitly extends java.lang.Object. Even if you write class Dog { }, it secretly becomes class Dog extends Object { }. The Object class provides methods you can override:

Java
class Student {
    String name;
    int rollNo;

    Student(String name, int rollNo) {
        this.name = name;
        this.rollNo = rollNo;
    }

    @Override
    public String toString() {
        return "Student{" + name + ", Roll: " + rollNo + "}";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student s = (Student) obj;
        return rollNo == s.rollNo && name.equals(s.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, rollNo);
    }
}

6. Compile-Time vs Runtime Polymorphism

Polymorphism means "many forms." A single method name behaves differently based on context.

7. Dynamic Method Dispatch (Runtime Polymorphism)

This is the most powerful feature of inheritance. A parent reference variable can hold a child object, and when you call an overridden method, Java decides at runtime which version to execute based on the actual object type — not the reference type.

Java
class PaymentMethod {
    public void processPayment(double amount) {
        System.out.println("Processing generic payment: ₹" + amount);
    }
}

class UPIPayment extends PaymentMethod {
    @Override
    public void processPayment(double amount) {
        System.out.println("UPI Payment via NPCI: ₹" + amount);
    }
}

class CardPayment extends PaymentMethod {
    @Override
    public void processPayment(double amount) {
        System.out.println("Card Payment via Visa/MC: ₹" + amount);
    }
}

class WalletPayment extends PaymentMethod {
    @Override
    public void processPayment(double amount) {
        System.out.println("Wallet debit: ₹" + amount);
    }
}

public class PaymentGateway {
    public static void main(String[] args) {
        PaymentMethod[] methods = {
            new UPIPayment(),
            new CardPayment(),
            new WalletPayment()
        };

        for (PaymentMethod pm : methods) {
            pm.processPayment(500);  // Dynamic dispatch!
        }
    }
}

8. instanceof Operator & Pattern Matching (Java 16+)

The instanceof operator checks whether an object is an instance of a particular class or interface. It returns true or false.

Java
// Traditional instanceof
if (obj instanceof String) {
    String s = (String) obj;  // manual cast
    System.out.println(s.toUpperCase());
}

// Java 16+ Pattern Matching
if (obj instanceof String s) {  // automatic cast into s
    System.out.println(s.toUpperCase());
}

Java
// Practical example with Shape hierarchy
public static void describeShape(Shape shape) {
    if (shape instanceof Circle c) {
        System.out.println("Circle with radius: " + c.radius);
    } else if (shape instanceof Rectangle r) {
        System.out.println("Rectangle: " + r.length + "x" + r.width);
    } else if (shape instanceof Triangle t) {
        System.out.println("Triangle base: " + t.base);
    }
}

9. The final Keyword — Variable, Method, Class

Java
// final variable — constant
final double GST_RATE = 18.0;
// GST_RATE = 20.0;  // ❌ Compile Error!

// final method — cannot override
class BankAccount {
    public final void getAccountNumber() {
        System.out.println("ACC-12345");
    }
}

class SavingsAccount extends BankAccount {
    // @Override
    // public void getAccountNumber() { }  // ❌ Compile Error!
}

// final class — cannot extend
final class ImmutableConfig {
    private final String dbUrl;
    ImmutableConfig(String url) { this.dbUrl = url; }
}
// class ChildConfig extends ImmutableConfig { }  // ❌ Compile Error!

10. Covariant Return Types

Since Java 5, an overriding method can return a subclass of the return type declared in the parent method. This is called a covariant return type.

Java
class Animal {
    public Animal create() {
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    public Dog create() {   // Dog is subclass of Animal — OK!
        return new Dog();
    }
}

Full Code: BankAccount Hierarchy

Java
class BankAccount {
    protected String holder;
    protected double balance;
    protected String accNo;

    public BankAccount(String holder, String accNo, double balance) {
        this.holder = holder;
        this.accNo = accNo;
        this.balance = balance;
    }

    public void deposit(double amt) { balance += amt; }
    public void withdraw(double amt) {
        if (amt <= balance) balance -= amt;
        else System.out.println("Insufficient funds!");
    }

    public double calculateInterest() { return 0; }

    @Override
    public String toString() {
        return holder + " [" + accNo + "] Balance: ₹" + balance;
    }
}

class SavingsAccount extends BankAccount {
    private double interestRate;

    public SavingsAccount(String h, String a, double b, double rate) {
        super(h, a, b);
        this.interestRate = rate;
    }

    @Override
    public double calculateInterest() {
        return balance * interestRate / 100;
    }
}

class CurrentAccount extends BankAccount {
    private double overdraftLimit;

    public CurrentAccount(String h, String a, double b, double odLimit) {
        super(h, a, b);
        this.overdraftLimit = odLimit;
    }

    @Override
    public void withdraw(double amt) {
        if (amt <= balance + overdraftLimit) balance -= amt;
        else System.out.println("Exceeds overdraft limit!");
    }

    @Override
    public double calculateInterest() { return 0; }
}

public class BankDemo {
    public static void main(String[] args) {
        BankAccount[] accounts = {
            new SavingsAccount("Rahul", "SB001", 50000, 4.5),
            new CurrentAccount("Priya Corp", "CA001", 100000, 25000)
        };

        for (BankAccount acc : accounts) {
            System.out.println(acc);
            System.out.println("Interest: ₹" + acc.calculateInterest());
            System.out.println();
        }
    }
}

Full Code: Swing JFrame Extension

Java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class CustomFrame extends JFrame {
    private JLabel statusLabel;

    public CustomFrame() {
        super("My Custom Frame — Inheritance Demo");
        setSize(500, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());

        JButton btn = new JButton("Click Me");
        statusLabel = new JLabel("Status: Waiting...");

        btn.addActionListener(e -> statusLabel.setText("Button Clicked!"));

        add(btn);
        add(statusLabel);
        setVisible(true);
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.setColor(Color.BLUE);
        g.drawString("Custom painted text via overridden paint()", 50, 350);
    }

    public static void main(String[] args) {
        new CustomFrame();
    }
}

Learn by Doing — 3-Tier Lab Structure

Problem Set — Syntax, Programming & Interview Questions

Syntax / Output Tracing (5 Questions)

E1. What is the output?

Java
class A { void show() { System.out.print("A "); } }
class B extends A { void show() { System.out.print("B "); } }
class C extends B { void show() { System.out.print("C "); } }
// In main: A obj = new C(); obj.show();

Answer: C — Dynamic dispatch resolves to the actual object type (C).

E2. Does this compile? Why or why not?

Java
class Parent { protected void greet() { } }
class Child extends Parent { private void greet() { } }

Answer: No — private is more restrictive than protected. Violates overriding rule #4.

E3. What is the output?

Java
class X { X() { System.out.print("X "); } }
class Y extends X { Y() { System.out.print("Y "); } }
class Z extends Y { Z() { System.out.print("Z "); } }
// In main: Z obj = new Z();

Answer: X Y Z — Constructors chain from top to bottom. Parent constructors run first.

E4. What is the output?

Java
class A { int x = 10; }
class B extends A { int x = 20; }
// In main: A obj = new B(); System.out.println(obj.x);

Answer: 10 — Variables are NOT polymorphic. obj.x resolves to A's x (reference type).

E5. Does this compile?

Java
final class Immutable { }
class Child extends Immutable { }

Answer: No — Cannot extend a final class.

Programming Questions (8)

P1. Create an Employee hierarchy: Employee → Manager, Developer, Intern. Override calculateSalary() in each.

P2. Build a Vehicle hierarchy with Car, Bike, Truck. Override fuelEfficiency() method.

P3. Create a MediaPlayer class with play(). Extend it to AudioPlayer and VideoPlayer. Demonstrate dynamic dispatch.

P4. Implement a Library system: LibraryItem → Book, Magazine, DVD. Override getLateFee(int days).

P5. Write a class where you override toString(), equals(), and hashCode() for a Product class.

P6. Demonstrate the difference between method overloading and overriding in a single program.

P7. Create a final class Constants with all final static variables for GST rates (5%, 12%, 18%, 28%).

P8. Build a program that uses instanceof with pattern matching (Java 16+) to process different shape types.

Industry-Level Questions (3)

I1. Design a notification system for an e-commerce platform (like Flipkart) where Notification is the parent class and EmailNotification, SMSNotification, PushNotification override send().

I2. Implement a tax calculation system where TaxCalculator is the base class and IncomeTaxCalc, GSTCalc, ProfessionalTaxCalc override calculateTax(double amount).

I3. Design a logging framework where Logger has log(String message) and children FileLogger, ConsoleLogger, DatabaseLogger override it.

Interview Questions (3)

IV1. Asked at Infosys SE Explain the Liskov Substitution Principle (LSP). Give an example where it is violated and how to fix it.

Expected: "If S is a subtype of T, then objects of type T may be replaced with objects of type S without altering the correctness of the program." Classic violation: Square extends Rectangle where setWidth() changes height too.

IV2. Asked at TCS Digital What is the difference between == and equals()? When would you override equals()?

IV3. Asked at Samsung R&D Explain dynamic method dispatch. Can it work with static methods? Why or why not?

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply (Q11–Q15)

class Animal { public void eat() { } }
class Dog extends Animal {
    @Override
    protected void eat() { }  // Line X
}

Analyze (Q16–Q20)

Evaluate (Q21–Q25)

Create (Q26–Q30)

Short Answer Questions (8)

SA1. What is inheritance in Java? Name the types supported.

Expected: Inheritance is the mechanism where a child class acquires properties and methods of a parent class using extends. Types: Single, Multilevel, Hierarchical. Multiple inheritance is NOT supported with classes (use interfaces).

SA2. What are the 3 uses of the super keyword?

Expected: (1) Access parent's variable: super.variableName. (2) Call parent's method: super.methodName(). (3) Call parent's constructor: super(args) — must be first statement in child constructor.

SA3. List the 5 rules of method overriding.

Expected: Same method name, same parameters, IS-A relationship required, access modifier can't be more restrictive, return type must be same or covariant.

SA4. What is the difference between method overloading and overriding?

Expected: Overloading: same name, different parameters, same class, compile-time binding. Overriding: same name, same parameters, parent-child relationship, runtime binding.

SA5. Why should you override hashCode() when you override equals()?

Expected: The contract states: if a.equals(b) is true, their hash codes must be equal. Breaking this makes objects behave incorrectly in HashMap and HashSet.

SA6. What is dynamic method dispatch?

Expected: When a parent reference holds a child object and calls an overridden method, the JVM resolves the call at runtime based on the actual object type, not the reference type.

SA7. What is the diamond problem?

Expected: If class C extends both A and B (both having method show()), the compiler can't determine which show() C inherits. Java avoids this by prohibiting multiple inheritance with classes.

SA8. Explain final keyword with variable, method, and class.

Expected: final variable = constant (value can't change). final method = can't be overridden. final class = can't be extended. Example: String is a final class.

Long Answer Questions (3)

LA1. Explain inheritance in Java with types, syntax, and a complete code example showing multilevel inheritance with constructor chaining.

Expected Answer (key points): Define inheritance, IS-A relationship, extends keyword. Explain single, multilevel, hierarchical types. Discuss diamond problem for why no multiple inheritance. Show complete code: Animal → Dog → Puppy with constructors using super(). Show output demonstrating constructor chaining order (A→B→C). Mention protected/public access for inherited members.

LA2. Differentiate between compile-time and runtime polymorphism. Demonstrate runtime polymorphism with a complete Shape hierarchy program including dynamic method dispatch.

Expected Answer (key points): Define polymorphism. Compare overloading (compile-time, same class, different params) vs overriding (runtime, parent-child, same signature). Write complete Shape → Circle, Rectangle, Triangle with area() override. Create Shape[] array with child objects. Show polymorphic loop calling area(). Explain how JVM resolves at runtime. Mention @Override annotation.

LA3. Explain the Object class in Java. Why is it important? Demonstrate overriding toString(), equals(), and hashCode() in a Student class.

Expected Answer (key points): Every class extends Object implicitly. List methods: toString, equals, hashCode, getClass, clone, finalize, wait, notify. Explain default behaviour of each. Show Student class overriding all three. Explain equals-hashCode contract. Show usage with System.out.println (toString), if-comparison (equals), and HashMap (hashCode). Mention that getClass() is final.

Lab Programs — Lab 7 & Lab 8

Java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class CustomFrame extends JFrame {
    private JLabel statusLabel;
    private JTextField nameField;
    private String greeting = "Welcome to EduArtha!";
    private Color shapeColor = Color.BLUE;

    public CustomFrame() {
        super("Lab 7 — Custom JFrame with Inheritance");
        setSize(600, 500);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout(10));

        // Components
        JLabel nameLabel = new JLabel("Enter your name:");
        nameField = new JTextField(15);
        JButton greetBtn = new JButton("Greet Me");
        JButton colorBtn = new JButton("Change Color");
        statusLabel = new JLabel("Status: Ready");

        // Event listeners
        greetBtn.addActionListener(e -> {
            String name = nameField.getText();
            if (!name.isEmpty()) {
                greeting = "Hello, " + name + "! Welcome to Java!";
                statusLabel.setText("Greeted: " + name);
                repaint();
            }
        });

        colorBtn.addActionListener(e -> {
            shapeColor = (shapeColor == Color.BLUE) ? Color.RED : Color.BLUE;
            repaint();
        });

        add(nameLabel);
        add(nameField);
        add(greetBtn);
        add(colorBtn);
        add(statusLabel);
        setVisible(true);
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);

        // Draw shapes using inheritance-overridden paint()
        g.setColor(shapeColor);
        g.fillOval(50, 150, 100, 100);
        g.fillRect(200, 150, 120, 80);

        // Draw greeting text
        g.setColor(Color.BLACK);
        g.setFont(new Font("Arial", Font.BOLD, 16));
        g.drawString(greeting, 50, 320);

        g.setColor(Color.GRAY);
        g.setFont(new Font("Arial", Font.ITALIC, 12));
        g.drawString("Drawn via overridden paint() — Inheritance in action!", 50, 380);
    }

    public static void main(String[] args) {
        new CustomFrame();
    }
}

Java
// Base class — Employee
class Employee {
    private String name;
    protected double baseSalary;

    public Employee(String name, double salary) {
        this.name = name;
        this.baseSalary = salary;
    }

    public String getName() { return name; }

    // protected — can be widened to public in child
    protected double calculatePay() {
        return baseSalary;
    }

    // public — child must keep public
    public String getRole() {
        return "Employee";
    }

    // final — cannot be overridden
    public final void displayId() {
        System.out.println("EMP-" + hashCode());
    }

    @Override
    public String toString() {
        return getRole() + ": " + name + " | Pay: ₹" + calculatePay();
    }
}

// Manager — widens access from protected to public
class Manager extends Employee {
    private double bonus;

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    @Override
    public double calculatePay() {  // widened: protected → public ✅
        return baseSalary + bonus;
    }

    @Override
    public String getRole() { return "Manager"; }
}

// Developer — uses super to add to parent's calculation
class Developer extends Employee {
    private int overtimeHours;

    public Developer(String name, double salary, int otHours) {
        super(name, salary);
        this.overtimeHours = otHours;
    }

    @Override
    public double calculatePay() {
        return super.calculatePay() + (overtimeHours * 500);
    }

    @Override
    public String getRole() { return "Developer"; }
}

// Intern — minimal override
class Intern extends Employee {
    public Intern(String name, double stipend) {
        super(name, stipend);
    }

    @Override
    public String getRole() { return "Intern"; }
}

// Main class
public class PayrollSystem {
    public static void main(String[] args) {
        Employee[] team = {
            new Manager("Anita Desai", 80000, 20000),
            new Developer("Raj Kumar", 60000, 25),
            new Intern("Sneha Patil", 15000)
        };

        System.out.println("===== Payroll Report =====");
        double totalPayroll = 0;

        for (Employee emp : team) {
            System.out.println(emp);  // calls overridden toString()
            emp.displayId();       // final method — same in all
            totalPayroll += emp.calculatePay();
            System.out.println();
        }

        System.out.println("Total Payroll: ₹" + totalPayroll);

        // instanceof demo
        for (Employee emp : team) {
            if (emp instanceof Manager m) {
                System.out.println(m.getName() + " gets manager benefits");
            }
        }
    }
}

Industry Spotlight — A Day in the Life

Earn With It — OOP Desktop Apps

⏱️ Time to First Earning: 3–4 weeks (complete Labs 7-8, build one portfolio app, create Internshala profile)

Chapter Summary & Code Tweet

Code Tweet (280 chars)

Earning Checkpoint — Unit 8 Readiness

✅ Unit 8 complete. MCQs: 30. Labs 7,8 covered. Ready for Unit 9!

[QR: Link to EduArtha video tutorial — Java Inheritance & Polymorphism]