Java接口 #

public interface Flyable {
    // 常量
    int MAX_HEIGHT = 10000;
    
    // 抽象方法
    void fly();
}

public interface Animal {
    // 抽象方法
    void eat();
    void sleep();
}

public interface MyInterface {
    // 常量：public static final
    int CONSTANT = 100;
    
    // 抽象方法：public abstract
    void abstractMethod();
    
    // 默认方法（Java 8+）：public default
    default void defaultMethod() {
        System.out.println("默认方法");
    }
    
    // 静态方法（Java 8+）：public static
    static void staticMethod() {
        System.out.println("静态方法");
    }
    
    // 私有方法（Java 9+）
    private void privateMethod() {
        System.out.println("私有方法");
    }
}

public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟在飞");
    }
}

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子在飞");
    }
    
    @Override
    public void swim() {
        System.out.println("鸭子在游泳");
    }
}

public class Animal {
    protected String name;
}

public interface Flyable {
    void fly();
}

public class Bird extends Animal implements Flyable {
    @Override
    public void fly() {
        System.out.println(name + "在飞");
    }
}

public interface A {
    void methodA();
}

public interface B {
    void methodB();
}

// 接口多继承
public interface C extends A, B {
    void methodC();
}

// 实现C需要实现所有方法
public class Impl implements C {
    @Override
    public void methodA() { }
    
    @Override
    public void methodB() { }
    
    @Override
    public void methodC() { }
}

public interface MyInterface {
    default void defaultMethod() {
        System.out.println("默认方法实现");
    }
}

public class MyClass implements MyInterface {
    // 可以不重写，使用默认实现
}

// 使用
MyClass obj = new MyClass();
obj.defaultMethod();  // 默认方法实现

public class MyClass implements MyInterface {
    @Override
    public void defaultMethod() {
        System.out.println("重写的默认方法");
    }
}

public interface A {
    default void method() {
        System.out.println("A的默认方法");
    }
}

public interface B {
    default void method() {
        System.out.println("B的默认方法");
    }
}

// 必须重写冲突的默认方法
public class C implements A, B {
    @Override
    public void method() {
        A.super.method();  // 调用A的默认方法
        // 或 B.super.method();
        // 或自定义实现
    }
}

public interface MathUtils {
    static int add(int a, int b) {
        return a + b;
    }
    
    static int multiply(int a, int b) {
        return a * b;
    }
}

// 使用
int sum = MathUtils.add(10, 20);
int product = MathUtils.multiply(5, 6);

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

// 使用Lambda表达式
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;

System.out.println(add.calculate(10, 20));      // 30
System.out.println(multiply.calculate(5, 6));   // 30

// Predicate<T>：判断
Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println(isEven.test(4));  // true

// Function<T, R>：转换
Function<String, Integer> toLength = s -> s.length();
System.out.println(toLength.apply("Hello"));  // 5

// Consumer<T>：消费
Consumer<String> print = s -> System.out.println(s);
print.accept("Hello");

// Supplier<T>：供给
Supplier<Double> random = () -> Math.random();
System.out.println(random.get());

public interface SortStrategy {
    void sort(int[] arr);
}

public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // 冒泡排序实现
    }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // 快速排序实现
    }
}

public class Sorter {
    private SortStrategy strategy;
    
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void sort(int[] arr) {
        strategy.sort(arr);
    }
}

public interface Callback {
    void onSuccess(String result);
    void onError(String error);
}

public class Task {
    public void execute(Callback callback) {
        try {
            // 执行任务
            String result = doWork();
            callback.onSuccess(result);
        } catch (Exception e) {
            callback.onError(e.getMessage());
        }
    }
    
    private String doWork() {
        return "任务完成";
    }
}

// 使用
Task task = new Task();
task.execute(new Callback() {
    @Override
    public void onSuccess(String result) {
        System.out.println("成功: " + result);
    }
    
    @Override
    public void onError(String error) {
        System.out.println("错误: " + error);
    }
});