A subclass extends a superclass to inherit its fields and methods, adding or overriding behaviour — an IS-A relationship.

Basic syntax

Java

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        d.eat();          // inherited from Animal
        d.bark();         // Dog's own
        System.out.println(d.name + " is an Animal? " + (d instanceof Animal));
        System.out.println(d.getClass().getSuperclass().getSimpleName());
        System.out.println(Animal.class.getSuperclass().getName());
    }
}

class Animal {
    protected String name;
    Animal(String name) { this.name = name; }
    void eat() { System.out.println(name + " eats"); }
}

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

Output

Rex eats
Rex barks
Rex is an Animal? true
Animal
java.lang.Object

What is (and isn't) inherited

Member	Inherited?
`public` / `protected` fields and methods	Yes
Package-private members	Only if the subclass is in the same package
`private` members	No (they exist inside the object, but the subclass can't access them)
Constructors	No — they are called via `super(...)`
Static members	Accessible through the subclass, but hidden rather than overridden

Types of inheritance

Type	Shape	In Java?
Single	`B extends A`	Yes
Multilevel	`C extends B`, `B extends A`	Yes
Hierarchical	`B extends A`, `C extends A`	Yes
Multiple (classes)	`C extends A, B`	No — ambiguity (diamond problem)
Multiple (interfaces)	`C implements X, Y`	Yes — interfaces carry no instance state
Hybrid	mix of the above	Only via interfaces

Constructor chaining up the hierarchy

Java

public class Main {
    public static void main(String[] args) {
        new Puppy();
    }
}

class Animal { Animal() { System.out.println("Animal()"); } }
class Dog extends Animal { Dog() { System.out.println("Dog()"); } }
class Puppy extends Dog { Puppy() { System.out.println("Puppy()"); } }

Output

Animal()
Dog()
Puppy()

No multiple inheritance of classes

Java

class A { }
class B { }
class C extends A, B { }

javac

Main.java:3: error: '{' expected
class C extends A, B { }
                 ^

IS-A vs HAS-A: prefer composition

Java

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        CountingBag viaInheritance = new CountingBag();
        viaInheritance.addAll(List.of("a", "b", "c"));
        System.out.println("inheritance count = " + viaInheritance.added);

        CountingWrapper viaComposition = new CountingWrapper();
        viaComposition.addAll(List.of("a", "b", "c"));
        System.out.println("composition count = " + viaComposition.added);
    }
}

class Bag {                                   // a parent you don't control
    private final List<String> items = new ArrayList<>();
    void add(String s) { items.add(s); }
    void addAll(List<String> c) { for (String s : c) add(s); }   // self-use: calls add()
}

class CountingBag extends Bag {               // IS-A: counts every item twice
    int added;
    @Override void add(String s) { added++; super.add(s); }
    @Override void addAll(List<String> c) { added += c.size(); super.addAll(c); }
}

class CountingWrapper {                       // HAS-A: forwards to a private Bag
    private final Bag bag = new Bag();
    int added;
    void add(String s) { added++; bag.add(s); }
    void addAll(List<String> c) { added += c.size(); bag.addAll(c); }
}

Output

inheritance count = 6
composition count = 3

Why doesn't Java support multiple inheritance of classes?

Are private members inherited?

What is the superclass of every class?