Interfaces (default and static methods)

interface Printable {
    String print();
}

class Invoice implements Printable {
    @Override
    public String print() { return "Invoice INV-77: Rs 2360"; }
}

class MarkSheet implements Printable {
    @Override
    public String print() { return "Mark sheet: Riya, 86%"; }
}

public class Main {
    public static void main(String[] args) {
        Printable[] queue = { new Invoice(), new MarkSheet() };
        for (Printable p : queue) {
            System.out.println(p.print());
        }
    }
}

interface Camera {
    String click();
}

interface Phone {
    String call(String number);
}

class SmartPhone implements Camera, Phone {
    @Override
    public String click() { return "Photo saved"; }

    @Override
    public String call(String number) { return "Calling " + number; }
}

public class Main {
    public static void main(String[] args) {
        SmartPhone s = new SmartPhone();
        Phone p = s;
        Camera c = s;
        System.out.println(p.call("98200 11111"));
        System.out.println(c.click());
        System.out.println("Same object? " + (p == c));
    }
}

interface ShopRules {
    double GST = 0.05;
    int FREE_DELIVERY_ABOVE = 499;
    int DELIVERY_FEE = 40;
}

public class Main {
    public static void main(String[] args) {
        double order = 450;
        double gst = order * ShopRules.GST;
        int delivery = order >= ShopRules.FREE_DELIVERY_ABOVE ? 0 : ShopRules.DELIVERY_FEE;
        System.out.println("Order: " + order);
        System.out.println("GST: " + gst);
        System.out.println("Delivery: " + delivery);
        System.out.println("Total: " + (order + gst + delivery));
    }
}

interface Rateable {
    int[] ratings();

    default double average() {
        int[] r = ratings();
        if (r.length == 0) return 0;
        int sum = 0;
        for (int x : r) sum += x;
        return (double) sum / r.length;
    }
}

class Restaurant implements Rateable {
    @Override
    public int[] ratings() { return new int[]{5, 4, 4, 3, 5}; }
}

public class Main {
    public static void main(String[] args) {
        Rateable r = new Restaurant();
        System.out.println("Average rating: " + r.average());
    }
}

interface AddressCheck {
    static boolean isValidPin(String pin) {
        if (pin.length() != 6 || pin.charAt(0) == '0') return false;
        for (char c : pin.toCharArray()) {
            if (!Character.isDigit(c)) return false;
        }
        return true;
    }
}

public class Main {
    public static void main(String[] args) {
        String[] pins = {"411001", "041001", "4110"};
        for (String p : pins) {
            System.out.println(p + " valid? " + AddressCheck.isValidPin(p));
        }
    }
}

interface Wifi {
    default String connect() { return "Wi-Fi connected"; }
}

interface Bluetooth {
    default String connect() { return "Bluetooth paired"; }
}

class Laptop implements Wifi, Bluetooth {
    @Override
    public String connect() {
        return Wifi.super.connect() + ", " + Bluetooth.super.connect();
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Laptop().connect());
    }
}

@FunctionalInterface
interface TaxRule {
    double tax(double amount);
}

public class Main {
    public static void main(String[] args) {
        TaxRule food = amt -> amt * 0.05;
        TaxRule electronics = amt -> amt * 0.18;
        TaxRule export = amt -> 0;
        TaxRule[] rules = { food, electronics, export };
        String[] names = { "food", "electronics", "export" };
        for (int i = 0; i < rules.length; i++) {
            System.out.println(names[i] + ": Rs " + rules[i].tax(2000));
        }
    }
}

interface PaymentGateway {
    boolean charge(double amount);

    default String name() {
        return getClass().getSimpleName();
    }
}

class RazorLikeGateway implements PaymentGateway {
    @Override
    public boolean charge(double amount) {
        return amount <= 100000;
    }
}

class BankGateway implements PaymentGateway {
    @Override
    public boolean charge(double amount) {
        return true;
    }
}

public class Main {
    static PaymentGateway route(double amount) {
        return amount > 50000 ? new BankGateway() : new RazorLikeGateway();
    }

    public static void main(String[] args) {
        double[] orders = {1499, 75000};
        for (double amt : orders) {
            PaymentGateway g = route(amt);
            System.out.println("Rs " + amt + " via " + g.name() + ": " + (g.charge(amt) ? "paid" : "failed"));
        }
    }
}

interface Trackable {
    String status();
    int etaMinutes();

    default String summary() {
        int m = etaMinutes();
        String eta = m >= 1440 ? (m / 1440) + " day(s)" : m >= 60 ? (m / 60) + " hour(s)" : m + " min";
        return String.format("%-10s %-18s ETA %s", getClass().getSimpleName(), status(), eta);
    }
}

class Parcel implements Trackable {
    public String status() { return "In transit"; }
    public int etaMinutes() { return 180; }
}

class Container implements Trackable {
    public String status() { return "At port, Nhava Sheva"; }
    public int etaMinutes() { return 4320; }
}

class FoodOrder implements Trackable {
    public String status() { return "Out for delivery"; }
    public int etaMinutes() { return 12; }
}

public class Main {
    public static void main(String[] args) {
        Trackable[] items = { new Parcel(), new Container(), new FoodOrder() };
        for (Trackable t : items) {
            System.out.println(t.summary());
        }
    }
}

interface Insured {
    double premiumCover();
}

interface FuelEligible {
    double fuelAllowance();
}

abstract class Employee {
    final String name;
    Employee(String name) { this.name = name; }
}

class SalesManager extends Employee implements Insured, FuelEligible {
    SalesManager(String name) { super(name); }
    public double premiumCover() { return 500000; }
    public double fuelAllowance() { return 6000; }
}

class Developer extends Employee implements Insured {
    Developer(String name) { super(name); }
    public double premiumCover() { return 300000; }
}

public class Main {
    public static void main(String[] args) {
        Employee[] staff = { new SalesManager("Kiran"), new Developer("Neha") };
        for (Employee e : staff) {
            StringBuilder sb = new StringBuilder(e.name + ":");
            if (e instanceof Insured i) sb.append(" insurance Rs ").append(i.premiumCover());
            if (e instanceof FuelEligible f) sb.append(", fuel Rs ").append(f.fuelAllowance()).append("/month");
            System.out.println(sb);
        }
    }
}