InterfaceMethods.java

package Phase2_MethodsArraysStrings.Methods;

/**
 * Interface Methods - default, static, private (Java 8 / 9)
 * ---------------------------------------------------------
 * Before Java 8, every method declared in an interface was implicitly PUBLIC
 * ABSTRACT - no body allowed. To evolve an interface (e.g. add a new method),
 * you had to break every existing implementor. Java 8 fixed this with
 * `default` methods, and Java 9 finished the story with `private` methods.
 * <p>
 *
 * The Four Method Flavours Allowed in an Interface (since Java 9)
 * ---------------------------------------------------------------
 * <p>
 *
 *      1. ABSTRACT  - no body, must be implemented by every concrete class.
 *                     `void doStuff();`
 * <p>
 *
 *      2. DEFAULT   - has a body, inherited by implementors unless overridden.
 *                     `default void greet() { ... }`
 * <p>
 *
 *      3. STATIC    - utility belonging to the interface itself.
 *                     `static Comparator<...> byLength() { ... }`
 * <p>
 *
 *      4. PRIVATE   - helper for the interface's own default/static methods.
 *                     `private boolean isValid(String s) { ... }`
 *                     (Java 9+)
 * <p>
 *
 * Why `default` Was Added
 * -----------------------
 * Interfaces could not evolve without breaking implementors. Adding
 * `default forEach(Consumer)` to java.lang.Iterable in Java 8 was the
 * motivating example - every existing collection class got it for free.
 * <p>
 *
 * Why `private` Was Added (Java 9)
 * --------------------------------
 * To avoid duplicating helper code between default/static methods of the same
 * interface. Without `private`, you would have to expose the helper or copy it.
 * <p>
 *
 * Multiple Inheritance and the "Diamond" Problem
 * ----------------------------------------------
 * A class may implement multiple interfaces. If two of them provide CONFLICTING
 * default methods with the same signature, the compiler forces you to override
 * the method in your class to disambiguate (you can call
 * `Interface.super.method()` to pick one).
 * <p>
 *
 * Modifier Quick Recap
 * --------------------
 *  - Abstract methods           : implicitly public abstract.
 *  - Default / static methods   : may be public (default) - no modifier needed.
 *  - Private methods            : private only; cannot be public/protected.
 *  - Fields in interfaces       : implicitly public static final (constants).
 */

public class InterfaceMethods {

    // ============ A simple interface using all four method flavours ============

    interface Greeter {

        /** Implementors must provide this. */
        String getName();

        /** Java 8 default - the standard greeting; can be overridden. */
        default String greet() {
            // Calls a private helper to keep this method tidy.
            return "Hello, " + capitalize(getName()) + "!";
        }

        /** Java 8 default - a louder greeting that reuses greet(). */
        default String shout() {
            return greet().toUpperCase();
        }

        /** Java 8 static - utility tied to the interface, not to instances. */
        static Greeter anonymous() {
            return () -> "stranger";
        }

        /** Java 9 private - helper used by greet(); not part of the public API. */
        private String capitalize(String s) {
            if (s == null || s.isEmpty()) return s;
            return Character.toUpperCase(s.charAt(0)) + s.substring(1);
        }
    }

    // ============ An implementation that uses the defaults ============

    static class Customer implements Greeter {
        private final String name;
        Customer(String name) { this.name = name; }

        @Override public String getName() { return name; }
        // Inherits greet() and shout() from the interface.
    }

    // ============ An implementation that overrides a default ============

    static class Robot implements Greeter {
        @Override public String getName() { return "unit-9"; }
        @Override public String greet() {
            return "BEEP BOOP. I am " + getName() + ".";
        }
    }

    // ============ Diamond conflict - two interfaces with the same default ============

    interface English { default String hello() { return "Hello"; } }
    interface French  { default String hello() { return "Bonjour"; } }

    static class Polyglot implements English, French {
        // Required to disambiguate - compile error if omitted.
        @Override public String hello() {
            return English.super.hello() + " / " + French.super.hello();
        }
    }

    public static void main(String[] args) {

        Greeter g1 = new Customer("deepak");
        System.out.println(g1.greet());     // uses inherited default
        System.out.println(g1.shout());     // default that calls another default

        Greeter g2 = new Robot();
        System.out.println(g2.greet());     // overridden version

        // Static method on the interface
        Greeter g3 = Greeter.anonymous();
        System.out.println(g3.greet());

        // Diamond resolution
        Polyglot p = new Polyglot();
        System.out.println(p.hello());

        // OUTPUT
        // Hello, Deepak!
        // HELLO, DEEPAK!
        // BEEP BOOP. I am unit-9.
        // Hello, Stranger!
        // Hello / Bonjour
    }
}