Week 7: Lab — Inheritance | PL1

1Basic Inheritance — Animal & Dog

Think about it: In a pet management system, all animals share common properties (name, age) and behaviors (makeSound). A Dog is-a Animal — it inherits those features and adds its own (breed). This is the most fundamental inheritance pattern you will use everywhere.

Create an Animal class with fields name (String) and age (int), a constructor, and a method makeSound() that prints "Animal sound". Create a Dog class that extends Animal, adds a breed field, calls super(name, age) in its constructor, and overrides makeSound() to print "Woof!". In main, create a Dog and call both its own method and verify it has the Animal fields.

Expected OutputName: Rex, Age: 3, Breed: Labrador Woof! Rex is 3 years old.

Your Code

class Animal {
    // Fields: name (String), age (int)


    // Constructor: Animal(String name, int age)


    // makeSound() — prints "Animal sound"

}

class Dog extends Animal {
    // Field: breed (String)


    // Constructor: Dog(String name, int age, String breed)
    // Call super(name, age) first!


    // Override makeSound() — prints "Woof!"

}

public class TestDog {
    public static void main(String[] args) {
        Dog d = new Dog("Rex", 3, "Labrador");
        System.out.println("Name: " + d.name + ", Age: " + d.age + ", Breed: " + d.breed);
        d.makeSound();
        System.out.println(d.name + " is " + d.age + " years old.");
    }
}

Animal constructor: Animal(String name, int age) { this.name = name; this.age = age; }. Dog:

class Dog extends Animal { String breed; Dog(String name, int age, String breed) { super(name, age); this.breed = breed; } }

. Override: add @Override then public void makeSound() { System.out.println("Woof!"); }.

2super() Constructor — Person & Employee

Think about it: An HR system stores people and employees. Every employee is a person first — they have a name and age. The super() call ensures the parent class sets up its own fields properly before the child adds its own. Skipping it (when no no-arg constructor exists) causes a compile error.

Create a Person class with name (String) and age (int), a constructor, and a display() method that prints "Person: [name], Age: [age]". Create an Employee class that extends Person, adds jobTitle (String) and salary (double), uses super(name, age), and overrides display() to print the person info plus job and salary. In main, test both classes.

Expected OutputPerson: Hana, Age: 25 Person: Sami, Age: 30 Job: Engineer, Salary: 5000.0

Your Code

class Person {
    // Fields: name (String), age (int)


    // Constructor: Person(String name, int age)


    // display() — prints "Person: [name], Age: [age]"

}

class Employee extends Person {
    // Fields: jobTitle (String), salary (double)


    // Constructor: Employee(String name, int age, String jobTitle, double salary)
    // Call super(name, age) first!


    // Override display() — print Person info, then job and salary

}

public class TestEmployee {
    public static void main(String[] args) {
        Person p = new Person("Hana", 25);
        p.display();

        Employee e = new Employee("Sami", 30, "Engineer", 5000.0);
        e.display();
    }
}

Employee constructor:

Employee(String name, int age, String jobTitle, double salary) { super(name, age); this.jobTitle = jobTitle; this.salary = salary; }

. Override display: @Override public void display() { super.display(); System.out.println("Job: " + jobTitle + ", Salary: " + salary); }.

3Calling super.method() — Vehicle & Car

Think about it: When overriding a method, you sometimes still want the parent's version to run first (e.g., to build on it rather than fully replace it). super.describe() lets you include the parent's output before adding child-specific details — avoiding code duplication.

Create a Vehicle class with brand (String) and speed (int), a constructor, and a describe() method that prints "Vehicle: [brand], Max Speed: [speed] km/h". Create a Car class that extends Vehicle, adds numDoors (int), and overrides describe() — calling super.describe() first, then printing "Doors: [numDoors]". Test in main.

Expected OutputVehicle: Toyota, Max Speed: 180 km/h Doors: 4

Your Code

class Vehicle {
    // Fields: brand (String), speed (int)


    // Constructor: Vehicle(String brand, int speed)


    // describe() — prints "Vehicle: [brand], Max Speed: [speed] km/h"

}

class Car extends Vehicle {
    // Field: numDoors (int)


    // Constructor: Car(String brand, int speed, int numDoors)
    // Use super(brand, speed)


    // Override describe() — call super.describe() FIRST, then print "Doors: [numDoors]"

}

public class TestCar {
    public static void main(String[] args) {
        Car c = new Car("Toyota", 180, 4);
        c.describe();
    }
}

Car's override: @Override public void describe() { super.describe(); System.out.println("Doors: " + numDoors); }. The super.describe() must come before any Car-specific printing so the output order matches exactly.

4Method Overriding — Shape & Rectangle

Think about it: A drawing application has many shapes. Each shape has an area and perimeter, but the formula differs by shape. The parent Shape provides a default implementation (returning 0), while each subclass overrides it with the correct formula. The @Override annotation lets the compiler catch signature mistakes.

Create a Shape class with a color field (String), a constructor, and two methods getArea() and getPerimeter() — both return 0.0. Create a Rectangle class that extends Shape, adds width and height (double), and uses @Override to implement both methods correctly. Print results in main.

Expected OutputColor: Blue Area: 15.0 Perimeter: 16.0

Your Code

class Shape {
    String color;

    // Constructor: Shape(String color)


    // getArea() — returns 0.0


    // getPerimeter() — returns 0.0

}

class Rectangle extends Shape {
    double width, height;

    // Constructor: Rectangle(String color, double width, double height)
    // Use super(color)


    // @Override getArea() — returns width * height


    // @Override getPerimeter() — returns 2 * (width + height)

}

public class TestShape {
    public static void main(String[] args) {
        Rectangle r = new Rectangle("Blue", 3.0, 5.0);
        System.out.println("Color: " + r.color);
        System.out.println("Area: " + r.getArea());
        System.out.println("Perimeter: " + r.getPerimeter());
    }
}

Rectangle constructor: Rectangle(String color, double width, double height) { super(color); this.width = width; this.height = height; }. Override: @Override public double getArea() { return width * height; } and @Override public double getPerimeter() { return 2 * (width + height); }.

5protected Access Modifier — BankAccount & SavingsAccount

Think about it: A bank's base account keeps its balance protected — not private — so that specialized subclasses (like SavingsAccount) can access it directly without going through getters. External code still can't touch it. This is the key role of protected in inheritance.

Create a BankAccount class with a protected field balance (double), a constructor, and a deposit(double amount) method that adds to balance, plus a getBalance() getter. Create a SavingsAccount that extends BankAccount, adds an interestRate (double), and has an applyInterest() method that directly uses balance += balance * interestRate. Test in main.

Expected OutputBalance after deposit: 1500.0 Balance after interest: 1575.0

Your Code

class BankAccount {
    // protected balance (double)


    // Constructor: BankAccount(double balance)


    // deposit(double amount) — adds to balance


    // getBalance() — returns balance

}

class SavingsAccount extends BankAccount {
    // Field: interestRate (double)


    // Constructor: SavingsAccount(double balance, double interestRate)
    // Use super(balance)


    // applyInterest() — directly access balance: balance += balance * interestRate

}

public class TestBank {
    public static void main(String[] args) {
        SavingsAccount acc = new SavingsAccount(1000.0, 0.05);
        acc.deposit(500.0);
        System.out.println("Balance after deposit: " + acc.getBalance());
        acc.applyInterest();
        System.out.println("Balance after interest: " + acc.getBalance());
    }
}

Declare: protected double balance;. applyInterest: public void applyInterest() { balance += balance * interestRate; }. Note: this works because balance is protected, not private. If it were private, you'd need setBalance(getBalance() + ...).

6Overriding toString() — Book

Think about it: Every Java class inherits toString() from Object, but the default output is a cryptic memory address like Book@1b6d3586. Overriding it makes objects human-readable — System.out.println(book) automatically calls your version.

Create a Book class with private fields title (String), author (String), and pages (int). Add a constructor and override toString() from Object to return "Book[title=..., author=..., pages=...]". In main, create two books and print them directly with System.out.println() — Java calls toString() automatically.

Expected OutputBook[title=Clean Code, author=Robert Martin, pages=431] Book[title=Effective Java, author=Joshua Bloch, pages=412]

Your Code

class Book {
    // Private fields: title (String), author (String), pages (int)


    // Constructor: Book(String title, String author, int pages)


    // @Override toString() — returns "Book[title=..., author=..., pages=...]"

}

public class TestBook {
    public static void main(String[] args) {
        Book b1 = new Book("Clean Code", "Robert Martin", 431);
        Book b2 = new Book("Effective Java", "Joshua Bloch", 412);

        System.out.println(b1);  // calls toString() automatically
        System.out.println(b2);
    }
}

@Override public String toString() { return "Book[title=" + title + ", author=" + author + ", pages=" + pages + "]"; }. Since fields are private, you can access them directly inside the class. System.out.println(b1) automatically calls b1.toString().

7Overriding equals() — Point

Think about it: The default equals() from Object compares references (memory addresses), not content. Two separate Point(1, 2) objects will be "not equal" by default even though they represent the same coordinates. Overriding equals() fixes this by comparing field values.

Create a Point class with fields x and y (int). Add a constructor. Override equals(Object obj): first check if obj instanceof Point, then cast and compare x and y values. Also override toString() to return "Point(x, y)". In main, compare points using both == and .equals().

Expected Outputp1 = Point(2, 3) p2 = Point(2, 3) p1 == p2: false p1.equals(p2): true

Your Code

class Point {
    int x, y;

    // Constructor: Point(int x, int y)


    // @Override toString() — returns "Point(x, y)"


    // @Override equals(Object obj)
    // Step 1: if (obj instanceof Point)
    // Step 2: cast — Point other = (Point) obj;
    // Step 3: return this.x == other.x && this.y == other.y
    // Otherwise: return false

}

public class TestPoint {
    public static void main(String[] args) {
        Point p1 = new Point(2, 3);
        Point p2 = new Point(2, 3);

        System.out.println("p1 = " + p1);
        System.out.println("p2 = " + p2);
        System.out.println("p1 == p2: " + (p1 == p2));
        System.out.println("p1.equals(p2): " + p1.equals(p2));
    }
}

@Override public boolean equals(Object obj) { if (obj instanceof Point) { Point other = (Point) obj; return this.x == other.x && this.y == other.y; } return false; }

. The instanceof check prevents a ClassCastException if a non-Point is passed.

8Override vs. Overload — Calculator

Think about it: Overloading means same name, different parameters — resolved at compile time. Overriding means same name, same parameters in a subclass — resolved at runtime. This exercise puts both side by side so you can see the key difference: overloading stays in one class, overriding spans a parent-child pair.

Create a Calculator class with an overloaded add() method: one takes two ints, another takes three ints, and a third takes two doubles. Also add a multiply(int a, int b) that returns a * b. Create SmartCalc that extends Calculator and overrides multiply(int a, int b) to print a message before returning the result. Test both in main.

Expected Outputadd(2,3) = 5 add(1,2,3) = 6 add(1.5,2.5) = 4.0 multiply(4,5) = 20 [Smart] Multiplying 4 x 5 smartMultiply(4,5) = 20

Your Code

class Calculator {
    // Overloaded add() — 3 versions:
    // add(int a, int b) returns a + b
    // add(int a, int b, int c) returns a + b + c
    // add(double a, double b) returns a + b


    // multiply(int a, int b) returns a * b

}

class SmartCalc extends Calculator {
    // @Override multiply(int a, int b)
    // Print "[Smart] Multiplying a x b" first, then return a * b

}

public class TestCalc {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("add(2,3) = " + calc.add(2, 3));
        System.out.println("add(1,2,3) = " + calc.add(1, 2, 3));
        System.out.println("add(1.5,2.5) = " + calc.add(1.5, 2.5));
        System.out.println("multiply(4,5) = " + calc.multiply(4, 5));

        SmartCalc smart = new SmartCalc();
        System.out.println("[Smart] Multiplying 4 x 5");
        System.out.println("smartMultiply(4,5) = " + smart.multiply(4, 5));
    }
}

Three add methods: int add(int a, int b), int add(int a, int b, int c), double add(double a, double b) — same name, different parameters = overloading. SmartCalc:

@Override public int multiply(int a, int b) { System.out.println("[Smart] Multiplying " + a + " x " + b); return a * b; }

— same signature in subclass = overriding.

9Multi-level Inheritance — Animal → Mammal → Dog

Think about it: Java allows a chain of inheritance: Animal → Mammal → Dog. When you create a Dog, Java first calls Animal(), then Mammal(), then Dog() — building from the top down. At the bottom, Dog has access to everything defined in all three levels.

Create three classes in a chain: Animal (fields: name, alive=true; method: breathe() prints "[name] is breathing"), Mammal extends Animal (adds furColor; method: nurse() prints "[name] is nursing young"), and Dog extends Mammal (adds breed; overrides method makeSound() printing "Woof! I am [name]"). In main, create one Dog and call all three methods.

Expected OutputBuddy is breathing Buddy is nursing young Woof! I am Buddy Breed: Golden Retriever, Fur: Golden, Alive: true

Your Code

class Animal {
    String name;
    boolean alive = true;

    // Constructor: Animal(String name)


    // breathe() — prints "[name] is breathing"

}

class Mammal extends Animal {
    String furColor;

    // Constructor: Mammal(String name, String furColor)
    // Use super(name)


    // nurse() — prints "[name] is nursing young"

}

class Dog extends Mammal {
    String breed;

    // Constructor: Dog(String name, String furColor, String breed)
    // Use super(name, furColor)


    // makeSound() — prints "Woof! I am [name]"

}

public class TestChain {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", "Golden", "Golden Retriever");
        dog.breathe();
        dog.nurse();
        dog.makeSound();
        System.out.println("Breed: " + dog.breed + ", Fur: " + dog.furColor + ", Alive: " + dog.alive);
    }
}

Mammal: Mammal(String name, String furColor) { super(name); this.furColor = furColor; }. Dog: Dog(String name, String furColor, String breed) { super(name, furColor); this.breed = breed; }. Each level passes its relevant args up. Dog inherits breathe() from Animal and nurse() from Mammal — no need to rewrite them.