Inheritance

Before we start

Why this matters

Outline · Lectures 9–10

Topics in this chapter

Select a topic to jump to the slide that explains it.

1. Inheritance basics and UML
2. Using super
3. Multilevel hierarchy and constructor order
4. The Object class

Concept 1 of 6

Inheritance: the is-a relationship

Inheritance: the is-a relationship

class Person {
    protected String name;
    protected int age;
    String introduce() { return "I am " + name; }
}
class Student extends Person {
    private double cgpa;              // added
    void study() { System.out.println(name + " studies"); }
}

• class Student extends Person: a Student is a Person.
• The subclass inherits all accessible fields and methods and can add its own.
• Test with “is-a”: a Car is a Vehicle ✓, a Car is an Engine ✗ (a Car has an Engine).

Concept 2 of 6

Types of inheritance

Concept 2 of 6

Types of inheritance (cont.)

• A Java class extends exactly one superclass (by default Object).
• Multiple inheritance of classes is banned to avoid the diamond problem (two inherited versions of the same method).
• A class can implement many interfaces — that is how Java gets the benefits of multiple inheritance (topic 9).

Concept 3 of 6

What a subclass can and cannot use

Concept 4 of 6

The super keyword

class Person {
    private String name;
    Person(String name) { this.name = name; }
    String getName() { return name; }
    String introduce() { return "I am " + name; }
}
class Student extends Person {
    private int id;
    Student(String name, int id) {
        super(name);                 // 1. superclass constructor
        this.id = id;
    }
    @Override

Concept 4 of 6

The super keyword (cont.)

    String introduce() {
        return super.introduce()     // 2. superclass version
               + ", ID " + id;
    }
}

• super(args) calls the superclass constructor; it must be the first statement.
• If you do not write it, the compiler inserts super(); — which fails if the superclass has no no-arg constructor.
• super.method() calls the superclass version of an overridden method.
• super.field reaches a superclass field hidden by a subclass field with the same name.

Code example

super in action

I am Mitu, ID 221
I am Dr. Karim from CSE

Step through the code

Trace: super(…) and super.introduce()

Follow one object through two constructors, then see an override call the superclass version with super.

Step through the code

Trace: super(…) and super.introduce() (cont.)

Concept 5 of 6

Multilevel hierarchies and constructor order

Concept 5 of 6

Multilevel hierarchies and constructor order (cont.)

class Vehicle {
    Vehicle() { System.out.println("Vehicle"); }
}
class Car extends Vehicle {
    Car() { System.out.println("Car"); }
}
class ElectricCar extends Car {
    ElectricCar() { System.out.println("ElectricCar"); }
}
new ElectricCar();

Vehicle
Car
ElectricCar

Constructors run from the top of the hierarchy down: a superclass part must be ready before the subclass part is built.

Step through the code

Trace: constructor chaining

Each constructor first calls super(). Watch the frames stack up to A, then print on the way back down.

Step through the code

Trace: constructor chaining (cont.)

Concept 6 of 6

The Object class

The Object class

Design

Inheritance vs composition (is-a vs has-a)

class Engine {
    int hp;
    Engine(int hp) { this.hp = hp; }
    void start() { System.out.println(hp + " hp engine started"); }
}
class Car extends Vehicle {       // is-a: inheritance
    private Engine engine;        // has-a: composition
    Car(int hp) { engine = new Engine(hp); }
    void drive() {
        engine.start();           // delegate
        System.out.println("driving");
    }
}

Worked example 1 of 3

Worked example 1

Worked example 2 of 3

Worked example 2

Worked example 3 of 3

Worked example 3

class Shape {
    protected String color;
    Shape(String color) { this.color = color; }
}
class Circle extends Shape {
    private double radius;
    Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
}

Practice

Practice (1 of 2)

Try each one on paper first, then check your answer.

class Manager extends Employee {
    private double bonus;
    Manager(String n, double base, double bonus) { super(n, base); this.bonus = bonus; }
    @Override double salary() { return super.salary() + bonus; }
}

Practice

Practice (2 of 2)

Try each one on paper first, then check your answer.

Check yourself

Quiz

Summary

Summary

• extends creates an is-a relationship; the subclass inherits accessible members and adds its own.
• Java classes have exactly one superclass; multiple inheritance comes through interfaces.
• super(...) calls the superclass constructor (first statement); super.m() calls the superclass version of m.
• Constructors run from the top of the hierarchy down.
• Every class inherits toString, equals and hashCode from Object.