Java Method Overriding: Runtime Polymorphism and @Override

// Shows which signatures the compiler accepts as overrides,
// which it silently treats as overloads, and the methods it refuses.
public class MethodOverridingDemo {
    private static final String MESSAGE = "order shipped";
    private static final String TITLE = "report";
    private static final int X = 3;
    private static final int Y = 4;
    private static final String BUILT = "built: ";
    // THE PARENT, ITS CONTRACT IS WHAT EVERY CHILD MUST HONOUR
    public static class Notification {
        public String channel() {
            return "standard";
        } public void send(String message) {
            System.out.println("standard send: " + message);
        } public void send(String message, boolean urgent) {
            System.out.println("standard urgent send: " + message);
        } private void hidden() {
            System.out.println("parent private");
        } public static void announce() {
            System.out.println("parent static");
        } public final void locked() {
            System.out.println("parent final");
        }
    } // A GENUINE OVERRIDE, IDENTICAL SIGNATURE PLUS A COVARIANT RETURN
    public static class EmailNotification extends Notification {
        @Override public String channel() {
            return "email";
        } @Override public void send(String message) {
            System.out.println("email send: " + message);
        } // NOT AN OVERRIDE, THE PARAMETER LIST CHANGED, SO IT OVERLOADS
        public void send(String message, boolean urgent) {
            super.send(message, urgent);
            System.out.println("email urgent send");
        } // NOT AN OVERRIDE EITHER, A StringBuilder IS NOT A String
        public void send(StringBuilder message) {
            System.out.println("built " + message);
        } // A SAME-NAMED PRIVATE METHOD IS A NEW METHOD, NOT AN OVERRIDE
        private void hidden() {
            System.out.println("child private, unrelated to the parent one");
        } // A STATIC METHOD WITH THE SAME NAME IS HIDDEN, NOT OVERRIDDEN
        public static void announce() {
            System.out.println("email static");
        }
    } // ACCESS MAY WIDEN, AND THIS CHILD USES super TO REUSE THE PARENT BODY
    public static class PremiumNotification extends EmailNotification {
        @Override public void send(String message) {
            super.send(message);
            System.out.println("premium add-on applied");
        }
    } // OVERRIDES CHAIN, AND ONLY super REACHES THE LEVELS ABOVE
    public static class LevelOne extends Notification {
        @Override public void send(String message) {
            System.out.println("level one");
        }
    } public static class LevelTwo extends LevelOne {
        @Override public void send(String message) {
            super.send(message);
            System.out.println("level two");
        }
    } // OVERRIDING THE THREE Object METHODS, AND PAIRING equals WITH hashCode
    public static class Point {
        private final int x;
        private final int y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        } public int getX() {
            return x;
        } public int getY() {
            return y;
        } @Override public String toString() {
            return "Point(" + x + ", " + y + ")";
        } @Override public boolean equals(Object other) {
            if (this == other) {
                return true;
            } if (!(other instanceof Point)) {
                return false;
            } Point that =(Point) other;
            return this.x == that.x && this.y == that.y;
        } @Override public int hashCode() {
            return java.util.Objects.hash(x, y);
        }
    } public static void main(String[] args) {
        // THE JVM PICKS THE OVERRIDE FROM THE ACTUAL OBJECT
        Notification reference = new EmailNotification();
        System.out.println("channel: " + reference.channel());
        reference.send(MESSAGE);
        // A GRANDCHILD OVERRIDE STILL DISPATCHES, AND super REACHES UP
        Notification premium = new PremiumNotification();
        premium.send(MESSAGE);
        System.out.println();
        System.out.println("overrides chain:");
        Notification deep = new LevelTwo();
        deep.send(MESSAGE);
        // AN OVERLOAD IS CHOSEN BY THE COMPILER FROM DECLARED TYPES
        System.out.println();
        System.out.println("overloads:");
        EmailNotification email = new EmailNotification();
        email.send(MESSAGE, true);
        email.send(new StringBuilder(BUILT + MESSAGE));
        // STATIC METHODS BIND TO THE REFERENCE TYPE, SO NO DISPATCH
        System.out.println();
        System.out.println("statics:");
        Notification.announce();
        // parent, chosen by the declared type
        EmailNotification.announce();
        // child, called explicitly by name
        // equals AND hashCode MUST AGREE, OR SETS KEEP DUPLICATES
        System.out.println();
        System.out.println("equals and hashCode:");
        System.out.println("title: " + TITLE);
        Point first = new Point(X, Y);
        Point second = new Point(X, Y);
        System.out.println("first:   " + first);
        System.out.println("second:  " + second);
        System.out.println("equal:   " + first.equals(second));
        System.out.println("hashes:  " +(first.hashCode() == second.hashCode()));
        java.util.Set<Point> unique = new java.util.HashSet<>();
        unique.add(first);
        unique.add(second);
        System.out.println("set size: " + unique.size());
        /*
            ACTUAL OUTPUT:

                channel: email
                email send: order shipped

            overrides chain:
                level one
                level two

            overloads:
                standard urgent send: order shipped
                email urgent send
                built built: order shipped

            statics:
                parent static
                email static

            equals and hashCode:
                title: report
                first:   Point(3, 4)
                second:  Point(3, 4)
                equal:   true
                hashes:  true
                set size: 1

            THE SEVEN RULES THAT MATTER MOST
            1) AN OVERRIDE KEEPS THE PARAMETER LIST EXACTLY. Change a
               parameter type or reorder them and the compiler sees a
               new overload, leaving the inherited method reachable.
            2) THE RETURN TYPE MAY NARROW BUT NEVER WIDEN. A covariant
               subtype is allowed, which tightens the contract for the
               child without changing what earlier callers see.
            3) ACCESS MAY WIDEN AND NEVER NARROW. A public parent
               method cannot become protected, because code holding
               a supertype reference must still reach it.
            4) CHECKED EXCEPTIONS MAY NARROW AND NEVER WIDEN. Callers
               of the parent never agreed to handle anything extra.
            5) STATIC, PRIVATE, AND FINAL METHODS ARE EXCLUDED. Static
               ones are hidden, private ones are invisible, and final
               ones are locked by the parent.
            6) ALWAYS WRITE @Override. It does nothing at runtime, but
               it turns a silent mismatch into a compile error, which
               is the entire point of it.
            7) equals AND hashCode TRAVEL TOGETHER. Overriding equals
               alone leaves equal objects in different hash buckets,
               so the set above holds two copies of one value.
        */
    }
}