如何在Java中实现接口 Java接口定义与实现示例

// 定义一个接口
interface Drivable {
    void start(); // 抽象方法
    void stop();  // 抽象方法

    // Java 8 以后可以有默认方法
    default void honk() {
        System.out.println("Beep beep!");
    }

    // Java 8 以后可以有静态方法
    static void showLicenseRequirement() {
        System.out.println("Driver's license required to drive.");
    }
}

// 实现 Drivable 接口的类
class Car implements Drivable {
    @Override
    public void start() {
        System.out.println("Car started. Ready to roll!");
    }

    @Override
    public void stop() {
        System.out.println("Car stopped. Engine off.");
    }

    // 可以选择性地重写默认方法
    @Override
    public void honk() {
        System.out.println("Loud car horn!");
    }
}

// 另一个实现类
class Bicycle implements Drivable {
    @Override
    public void start() {
        System.out.println("Bicycle started pedaling.");
    }

    @Override
    public void stop() {
        System.out.println("Bicycle stopped. Feet on ground.");
    }
    // Bicycle 没有重写 honk()，所以会使用接口的默认实现
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.start();
        myCar.honk(); // 调用重写后的方法
        myCar.stop();

        System.out.println("---");

        Bicycle myBike = new Bicycle();
        myBike.start();
        myBike.honk(); // 调用接口的默认方法
        myBike.stop();

        // 调用接口的静态方法
        Drivable.showLicenseRequirement();
    }
}

interface Vehicle {
    void drive();
    default void repair() {
        System.out.println("Performing standard vehicle repair.");
    }
}

class Truck implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Truck is driving heavy loads.");
    }
    // Truck 可以不实现 repair()，直接使用默认的
}

class SportsCar implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Sports car is speeding!");
    }
    @Override
    public void repair() {
        System.out.println("Performing specialized sports car repair."); // 重写默认方法
    }
}

interface Calculator {
    int add(int a, int b);
    static int multiply(int a, int b) {
        return a * b;
    }
}

// 调用静态方法
// int product = Calculator.multiply(5, 4); // 直接通过接口名调用

interface Loggable {
    default void logInfo(String message) {
        log("INFO", message);
    }

    default void logError(String message) {
        log("ERROR", message);
    }

    private void log(String level, String message) { // 私有实例方法
        System.out.println("[" + level + "] " + message);
    }

    private static void validate(String data) { // 私有静态方法
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("Data cannot be empty.");
        }
    }
}

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

// 一个类同时实现 Flyable 和 Swimmable 两个接口
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying high!");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming gracefully.");
    }

    public void quack() {
        System.out.println("Quack quack!");
    }
}

public class MultiInterfaceDemo {
    public static void main(String[] args) {
        Duck myDuck = new Duck();
        myDuck.fly();
        myDuck.swim();
        myDuck.quack();

        // 也可以将 Duck 对象向上转型为任一接口类型
        Flyable aFlyingCreature = myDuck;
        aFlyingCreature.fly();

        Swimmable aSwimmingCreature = myDuck;
        aSwimmingCreature.swim();
    }
}