Inheritance

Inheritance with extends

Inheritance allows a class to inherit fields and methods from another class.

Basic Inheritance

// Parent class (superclass)
public class Animal {
    String name;
    int age;
    
    public void eat() {
        System.out.println(name + " is eating");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class (subclass)
public class Dog extends Animal {
    String breed;
    
    public void bark() {
        System.out.println(name + " is barking");
    }
}

// Usage
Dog dog = new Dog();
dog.name = "Rex";  // Inherited from Animal
dog.breed = "Labrador";
dog.eat();    // Inherited method
dog.bark();   // Dog's own method

What is Inherited?

public class Parent {
    public int x = 10;       // Inherited
    protected int y = 20;    // Inherited
    int z = 30;              // Inherited (if same package)
    private int w = 40;      // NOT inherited
    
    public void publicMethod() { }     // Inherited
    protected void protectedMethod() { } // Inherited
    void defaultMethod() { }           // Inherited
    private void privateMethod() { }   // NOT inherited
}

public class Child extends Parent {
    public void test() {
        System.out.println(x);  // OK
        System.out.println(y);  // OK
        System.out.println(z);  // OK
        // System.out.println(w); // ERROR!
        publicMethod();         // OK
        // privateMethod();      // ERROR!
    }
}

IS-A Relationship

// Dog IS-A Animal (inheritance)
// Cat IS-A Animal (inheritance)

Dog dog = new Dog();
Animal animal = dog;  // OK - Dog IS-A Animal

// Animal animal = new Animal();
// Dog dog = animal;  // ERROR - Animal is NOT necessarily a Dog

The super Keyword

super refers to the parent class.

Accessing Parent Methods

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        super.eat();  // Call parent's eat()
        System.out.println("Dog is eating");
    }
}

Dog dog = new Dog();
dog.eat();
// Output:
// Animal is eating
// Dog is eating

Accessing Parent Fields

public class Parent {
    int x = 10;
}

public class Child extends Parent {
    int x = 20;  // Shadows parent's x
    
    public void printX() {
        System.out.println(x);      // 20 (child's)
        System.out.println(super.x); // 10 (parent's)
    }
}

Calling Parent Constructor

public class Animal {
    String name;
    
    public Animal(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Must be first statement
        this.breed = breed;
    }
}

super() vs this()

public class Example {
    public Example() {
        this(10);  // Call another constructor in THIS class
        // super();  // ERROR - can't have both!
    }
    
    public Example(int x) {
        super();  // Call parent constructor
        // this();  // ERROR - can't have both!
    }
}

Constructor Chaining

When creating a child object, parent constructor runs first.

Constructor Execution Order

public class Grandparent {
    public Grandparent() {
        System.out.println("Grandparent constructor");
    }
}

public class Parent extends Grandparent {
    public Parent() {
        System.out.println("Parent constructor");
    }
}

public class Child extends Parent {
    public Child() {
        System.out.println("Child constructor");
    }
}

// When: new Child()
// Output:
// Grandparent constructor
// Parent constructor
// Child constructor

With super()

public class Animal {
    String name;
    
    public Animal(String name) {
        this.name = name;
        System.out.println("Animal: " + name);
    }
}

public class Dog extends Animal {
    String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Must be first!
        this.breed = breed;
        System.out.println("Dog: " + breed);
    }
}

// new Dog("Rex", "Labrador")
// Output:
// Animal: Rex
// Dog: Labrador

Complete Chain

public class A {
    public A() { System.out.println("A"); }
}
public class B extends A {
    public B() { System.out.println("B"); }
}
public class C extends B {
    public C() { System.out.println("C"); }
}

// new C() prints: A, B, C

With Parameters

public class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Employee extends Person {
    String company;
    
    public Employee(String name, int age, String company) {
        super(name, age);
        this.company = company;
    }
}

Inheritance Types

Single Inheritance

// A -> B
public class Animal { }
public class Dog extends Animal { }

Multilevel Inheritance

// A -> B -> C
public class Animal { }
public class Dog extends Animal { }
public class Puppy extends Dog { }

Hierarchical Inheritance

// A -> B, A -> C
public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }

Java Does NOT Support

// Multiple inheritance with classes (NOT allowed)
// class C extends A, B { }  // COMPILE ERROR!

// But interfaces allow it:
// class C implements InterfaceA, InterfaceB { }  // OK

When to Use Inheritance

// USE inheritance when:
// - Clear IS-A relationship
// - Child truly is a type of parent
// - Sharing common behavior

// Don't use when:
// - Just for code reuse
// - No clear IS-A relationship
// - Using HAS-A would be better

// Example:
// Dog IS-A Animal ✓
// Car IS-A Engine ✗ (Car HAS-A Engine)