Method Overriding in Java – Rules and Examples

public class OverridingBasics {
    static class Notification {
        String channel() { return "generic"; }
        void send(String msg) { System.out.println("[" + channel() + "] " + msg); }
    }

    static class EmailNotification extends Notification {
        @Override String channel() { return "email"; }        // overrides
    }

    static class SmsNotification extends Notification {
        @Override String channel() { return "sms"; }
        @Override void send(String msg) {                       // overrides and extends
            String shortMsg = msg.length() > 20 ? msg.substring(0, 20) + "..." : msg;
            super.send(shortMsg);                               // reuse the parent version
        }
    }

    public static void main(String[] args) {
        Notification[] all = { new Notification(), new EmailNotification(), new SmsNotification() };
        for (Notification n : all) n.send("Your order #1042 has been shipped today");
    }
}

public class OverrideAnnotation {
    static class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }

        // Mistake: parameter type is Point, not Object -> this OVERLOADS equals, it does not override it.
        // Adding @Override here would make the compiler report the mistake.
        public boolean equals(Point other) { return x == other.x && y == other.y; }
    }

    static class FixedPoint {
        final int x, y;
        FixedPoint(int x, int y) { this.x = x; this.y = y; }

        @Override
        public boolean equals(Object o) {
            return o instanceof FixedPoint p && x == p.x && y == p.y;
        }
        @Override
        public int hashCode() { return 31 * x + y; }
    }

    public static void main(String[] args) {
        Object a = new Point(1, 2), b = new Point(1, 2);
        System.out.println("Point equals (wrong overload):  " + a.equals(b));

        Object c = new FixedPoint(1, 2), d = new FixedPoint(1, 2);
        System.out.println("FixedPoint equals (overridden): " + c.equals(d));
    }
}

import java.io.*;

public class OverridingRules {
    static class Animal {
        protected Animal reproduce() { return new Animal(); }
        void load(String file) throws IOException { }
        public String toString() { return "Animal"; }
    }

    static class Cat extends Animal {
        // Covariant return type (Cat is a subtype of Animal) and wider access (protected -> public)
        @Override public Cat reproduce() { return new Cat(); }

        // May throw fewer or narrower checked exceptions (FileNotFoundException extends IOException)
        @Override void load(String file) throws FileNotFoundException {
            throw new FileNotFoundException(file + " not found");
        }
        public String toString() { return "Cat"; }
    }

    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println("reproduce() returned: " + a.reproduce());
        try { a.load("cat.json"); }
        catch (IOException e) { System.out.println("Caught: " + e); }
    }
}

public class StaticHiding {
    static class Parent {
        static String info() { return "Parent.info (static)"; }
        private String secret() { return "Parent.secret (private)"; }
        String callSecret() { return secret(); }
    }
    static class Child extends Parent {
        static String info() { return "Child.info (static)"; }      // hides, not overrides
        private String secret() { return "Child.secret (private)"; } // new method, not an override
    }

    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(Parent.info());   // static: resolved by type at compile time
        System.out.println(Child.info());
        System.out.println(p.callSecret());  // private: parent's version, no dynamic dispatch
    }
}