extends / super / @Override

// Define a subclass that inherits from a parent class.
class SubClass extends SuperClass {
    // Inherits the fields and methods of the parent class.
}

// Call the parent class constructor (must be the first line of the constructor).
super(args);

// Call a method of the parent class.
super.methodName(args);

// Override a method from the parent class.
@Override
returnType methodName(args) {
    // Subclass-specific implementation
}

// Define the parent class.
class Animal {
    String name;

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

    String speak() {
        return name + " is making a sound.";
    }
}

// Define a Dog class that extends Animal.
class Dog extends Animal {

    Dog(String name) {
        super(name); // Call the parent class constructor.
    }

    // Override speak().
    @Override
    String speak() {
        return name + " says Woof!";
    }

    // Reuse the parent class method.
    String speakTwice() {
        return super.speak() + " / " + this.speak();
    }
}

Animal a = new Animal("Animal");
Dog d = new Dog("Pochi");

System.out.println(a.speak());      // Prints "Animal is making a sound."
System.out.println(d.speak());      // Prints "Pochi says Woof!"
System.out.println(d.speakTwice()); // Prints "Animal is making a sound. / Pochi says Woof!"

// Polymorphism: a parent class variable can hold a subclass instance.
Animal a2 = new Dog("Taro");
System.out.println(a2.speak()); // Prints "Taro says Woof!"

Inheritance makes code reuse straightforward. A subclass can use the public and protected members of its parent class as-is, and can override them as needed to change their behavior.

The @Override annotation is optional, but it is strongly recommended — it lets the compiler catch method name typos and parameter type mismatches at compile time. All classes implicitly extend the Object class, so methods such as toString() and equals() are also defined in Object.

For interfaces and abstract classes, see interface / implements / abstract. For access modifiers, see public / private / protected / static / final.