Inheritance in Java – Types, Rules and Examples

class SubClass extends SuperClass {
    // inherits SuperClass's accessible fields and methods
    // can add new members and override inherited methods
}

public class InheritanceBasics {
    static class Employee {                         // superclass (parent)
        protected final String name;
        protected final double salary;

        Employee(String name, double salary) {
            this.name = name;
            this.salary = salary;
        }
        double annualPay() { return salary * 12; }
        String describe() { return name + " earns " + annualPay() + " per year"; }
    }

    static class Manager extends Employee {         // subclass (child) IS-A Employee
        private final double bonus;

        Manager(String name, double salary, double bonus) {
            super(name, salary);                    // initialise the inherited part first
            this.bonus = bonus;
        }
        @Override double annualPay() { return super.annualPay() + bonus; }   // specialise
        void approveLeave(String who) { System.out.println(name + " approved leave for " + who); }  // add
    }

    public static void main(String[] args) {
        Employee dev = new Employee("Ravi", 80_000);
        Manager mgr = new Manager("Asha", 120_000, 200_000);

        System.out.println(dev.describe());
        System.out.println(mgr.describe());   // describe() inherited, annualPay() overridden
        mgr.approveLeave("Ravi");
        System.out.println("Manager is an Employee? " + (mgr instanceof Employee));
    }
}

public class WhatIsInherited {
    static class Parent {
        public    String pub  = "public";
        protected String prot = "protected";
                  String pkg  = "package-private";
        private   String priv = "private";
        String getPriv() { return priv; }   // private data reachable via inherited method
        static String util() { return "static method"; }
    }
    static class Child extends Parent {
        void show() {
            System.out.println(pub + ", " + prot + ", " + pkg);
            // System.out.println(priv);      // compile error: priv has private access
            System.out.println("via getter: " + getPriv());
            System.out.println("static: " + util());
        }
    }

    public static void main(String[] args) {
        new Child().show();
        System.out.println("Every class extends Object: " + new Child().getClass().getSuperclass().getSuperclass().getSimpleName());
    }
}

public class InheritanceTypes {
    // Single: B extends A
    static class Vehicle { String move() { return "moves"; } }
    static class Car extends Vehicle { String honk() { return "honks"; } }

    // Multilevel: C extends B extends A
    static class SportsCar extends Car { String turbo() { return "uses turbo"; } }

    // Hierarchical: several classes extend the same parent
    static class Truck extends Vehicle { String load() { return "carries cargo"; } }

    // "Multiple" via interfaces: one class, many interfaces
    interface Electric { default String charge() { return "charges"; } }
    interface Autonomous { default String drive() { return "drives itself"; } }
    static class RoboTaxi extends Car implements Electric, Autonomous { }

    public static void main(String[] args) {
        SportsCar s = new SportsCar();
        System.out.println("SportsCar " + s.move() + ", " + s.honk() + ", " + s.turbo());
        System.out.println("Truck " + new Truck().move() + " and " + new Truck().load());
        RoboTaxi r = new RoboTaxi();
        System.out.println("RoboTaxi " + r.move() + ", " + r.charge() + ", " + r.drive());
    }
}

public class ConstructorOrder {
    static class A { A() { System.out.println("1. A constructor"); } }
    static class B extends A { B() { System.out.println("2. B constructor"); } }
    static class C extends B { C() { System.out.println("3. C constructor"); } }

    public static void main(String[] args) {
        new C();   // parent constructors always run first, top-down
    }
}

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

public class CompositionInstead {
    // Inheritance misuse: a Stack IS-NOT-A ArrayList, but it would inherit add(index), remove(index)...
    // Composition: a Stack HAS-A list and exposes only stack operations
    static class Stack<T> {
        private final List<T> items = new ArrayList<>();
        void push(T item) { items.add(item); }
        T pop() { return items.remove(items.size() - 1); }
        T peek() { return items.get(items.size() - 1); }
        boolean isEmpty() { return items.isEmpty(); }
    }

    public static void main(String[] args) {
        Stack<String> pages = new Stack<>();
        pages.push("home"); pages.push("java"); pages.push("inheritance");
        System.out.println("Back from: " + pages.pop());
        System.out.println("Now on:    " + pages.peek());
    }
}