Interfaces

interface Drivable {
    // Interface methods are public + abstract by default — just a signature, no body.
    String drive();
    String stop();
    int getSpeed();
}

// "implements" = this class promises to provide EVERY method in the contract.
class Car implements Drivable {
    private int speed = 0;
    public String drive() { speed = 60; return "Car driving at " + speed + " mph"; }
    public String stop()  { speed = 0;  return "Car stopped"; }
    public int getSpeed() { return speed; }   // must be public — matches the contract
}

class Bicycle implements Drivable {
    private int speed = 0;
    public String drive() { speed = 15; return "Bicycle pedalling at " + speed + " mph"; }
    public String stop()  { speed = 0;  return "Bicycle stopped"; }
    public int getSpeed() { return speed; }
}

public class Main {
    // This method works with ANY Drivable — that is the whole point of an interface.
    static void testDrive(Drivable vehicle) {
        System.out.println(vehicle.drive());
        System.out.println("  Speed: " + vehicle.getSpeed() + " mph");
        System.out.println("  " + vehicle.stop());
    }

    public static void main(String[] args) {
        testDrive(new Car());        // pass a Car
        testDrive(new Bicycle());    // ...or a Bicycle — same method, no changes
    }
}

Car driving at 60 mph
  Speed: 60 mph
  Car stopped
Bicycle pedalling at 15 mph
  Speed: 15 mph
  Bicycle stopped

interface Shape {
    double area();          // 👉 you must give Square a body for this
    String name();
}

class Square implements Shape {
    private double side;
    Square(double side) { this.side = side; }

    // 🎯 YOUR TURN — finish the two methods this contract requires

    // 1) Return the area of the square (side * side)
    public double area() { return ___; }      // 👉 replace ___ with side * side

    // 2) Return the text "Square"
    public String name() { return ___; }      // 👉 replace ___ with "Square" in double quotes
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Square(4);
        System.out.println(s.name() + " area = " + s.area());

        // ✅ Expected output: Square area = 16.0
    }
}

interface Flyable {
    // CONSTANT: interface fields are implicitly public static final.
    int MAX_ALTITUDE = 10000;

    String fly();   // abstract — every Flyable must say how it flies

    // DEFAULT method: has a body, so implementers get it for free (Java 8+).
    default String land() { return "Landing safely below " + MAX_ALTITUDE + " ft"; }

    // STATIC method: belongs to the interface itself, called as Flyable.info().
    static String info() { return "Flyable: anything with wings or rotors"; }
}

interface Swimmable {
    String swim();
    default String dive() { return "Diving deep"; }
}

// A class can implement MANY interfaces (Java's answer to multiple inheritance).
class Duck implements Flyable, Swimmable {
    public String fly()  { return "Duck flapping its wings"; }
    public String swim() { return "Duck paddling along"; }
    // Inherits default land() and dive() for free — no need to write them.
}

public class Main {
    public static void main(String[] args) {
        Duck d = new Duck();
        System.out.println(d.fly());     // its own implementation
        System.out.println(d.land());    // default from Flyable
        System.out.println(d.swim());    // its own implementation
        System.out.println(d.dive());    // default from Swimmable
        System.out.println(Flyable.info());          // static, called on the interface
        System.out.println("Limit: " + Flyable.MAX_ALTITUDE);  // the constant
    }
}

Duck flapping its wings
Landing safely below 10000 ft
Duck paddling along
Diving deep
Flyable: anything with wings or rotors
Limit: 10000

interface Printable {
    String content();
    // A default method — you DON'T rewrite this, you just call it.
    default String preview() { return "Preview: " + content(); }
}

interface Saveable {
    String save();
}

// 🎯 YOUR TURN — a Document is both Printable AND Saveable

class Document implements ___, ___ {   // 👉 list both interfaces, separated by a comma
    private String text;
    Document(String text) { this.text = text; }

    // 1) Return the stored text
    public String content() { return text; }

    // 2) Return a save message
    public String save() { return ___; }   // 👉 replace ___ with "Saved!" in double quotes
}

public class Main {
    public static void main(String[] args) {
        Document doc = new Document("Hello");
        System.out.println(doc.preview());  // uses the default method for free
        System.out.println(doc.save());

        // ✅ Expected output:
        // Preview: Hello
        // Saved!
    }
}

// Interfaces can extend OTHER interfaces (and even several at once).
interface Animal {
    String name();
}

interface Pet extends Animal {     // Pet inherits name() and adds owner()
    String owner();
}

class Dog implements Pet {
    // Must implement BOTH name() (inherited) and owner() (added) — the full chain.
    public String name()  { return "Rex"; }
    public String owner() { return "Sam"; }
}

// A FUNCTIONAL interface has exactly one abstract method, so a lambda can fill it.
@FunctionalInterface
interface Greeter {
    String greet(String who);      // the single abstract method
}

public class Main {
    public static void main(String[] args) {
        Pet p = new Dog();
        System.out.println(p.name() + " is owned by " + p.owner());

        // A lambda IS the implementation of the single method.
        Greeter g = who -> "Hello, " + who + "!";
        System.out.println(g.greet("Ada"));
    }
}

Rex is owned by Sam
Hello, Ada!

public class Main {
    // 🎯 MINI-CHALLENGE: a notifier contract
    //
    // 1. Declare an interface "Notifier" with one method: String send(String message)
    // 2. Make a class "EmailNotifier" that implements Notifier
    //      - send() returns: "Email: " + message
    // 3. Make a class "SmsNotifier" that implements Notifier
    //      - send() returns: "SMS: " + message
    // 4. In main, make a Notifier[] holding one of each, loop over it,
    //    and print send("Hi") for each.
    //
    // ✅ Expected output:
    // Email: Hi
    // SMS: Hi

    public static void main(String[] args) {
        // your code here
    }
}