Interface in Java – Contracts, Default Methods and Multiple Inheritance

[public] interface InterfaceName [extends Interface1, Interface2] {
    // constants           (public static final)
    // abstract methods    (public abstract)
    // default methods     (Java 8)
    // static methods      (Java 8)
    // private methods     (Java 9)
}

class ClassName [extends Parent] implements InterfaceName, OtherInterface { ... }

public class InterfaceBasics {
    interface Shape {
        double PI_APPROX = 3.14;          // implicitly public static final
        double area();                    // implicitly public abstract
        String name();
    }

    static class Square implements Shape {
        private final double side;
        Square(double side) { this.side = side; }
        public double area() { return side * side; }   // must be public
        public String name() { return "Square"; }
    }

    static class Circle implements Shape {
        private final double r;
        Circle(double r) { this.r = r; }
        public double area() { return PI_APPROX * r * r; }
        public String name() { return "Circle"; }
    }

    public static void main(String[] args) {
        Shape[] shapes = { new Square(3), new Circle(2) };   // interface as a type
        for (Shape s : shapes) System.out.println(s.name() + " area = " + s.area());
        System.out.println("Constant via interface: " + Shape.PI_APPROX);
    }
}

public class MultipleInterfaces {
    interface Flyable  { void fly(); }
    interface Swimmable { void swim(); }

    static class Animal {
        final String name;
        Animal(String name) { this.name = name; }
    }

    // One superclass, many interfaces
    static class Duck extends Animal implements Flyable, Swimmable {
        Duck() { super("Duck"); }
        public void fly()  { System.out.println(name + " flies over the lake"); }
        public void swim() { System.out.println(name + " paddles on the water"); }
    }

    static void takeOff(Flyable f) { f.fly(); }
    static void dive(Swimmable s)  { s.swim(); }

    public static void main(String[] args) {
        Duck d = new Duck();
        takeOff(d);          // a Duck is a Flyable
        dive(d);             // ... and a Swimmable
        System.out.println("instanceof Flyable? " + (d instanceof Flyable));
    }
}

import java.util.List;

public class ModernInterface {
    interface Discount {
        double apply(double price);                         // abstract

        default Discount then(Discount next) {              // default method (Java 8)
            return price -> next.apply(apply(price));
        }

        static Discount percent(double p) {                 // static method (Java 8)
            check(p);
            return price -> price * (1 - p / 100);
        }

        static Discount flat(double amount) {
            return price -> Math.max(0, price - amount);
        }

        private static void check(double p) {              // private method (Java 9)
            if (p < 0 || p > 100) throw new IllegalArgumentException("percent out of range: " + p);
        }
    }

    public static void main(String[] args) {
        Discount festive = Discount.percent(10).then(Discount.flat(200));
        System.out.println("Price after discounts: " + festive.apply(5_000));

        List<Discount> options = List.of(Discount.percent(25), Discount.flat(1_000), festive);
        double best = options.stream().mapToDouble(d -> d.apply(5_000)).min().orElseThrow();
        System.out.println("Best price: " + best);
    }
}

public class InterfaceExtends {
    interface Readable  { String read(); }
    interface Writable  { void write(String data); }
    interface ReadWrite extends Readable, Writable { }   // an interface can extend many

    static class MemoryFile implements ReadWrite {
        private final StringBuilder content = new StringBuilder();
        public String read() { return content.toString(); }
        public void write(String data) { content.append(data); }
    }

    public static void main(String[] args) {
        ReadWrite f = new MemoryFile();
        f.write("Hello, ");
        f.write("interfaces!");
        Readable r = f;                       // view it through a narrower interface
        System.out.println(r.read());
    }
}