// 基础接口定义
public interface Drawable {
    void draw();  // 隐式 public abstract
    double area(); 
}

public interface Physics {
    double LIGHT_SPEED = 299792458; // 隐式 public static final
}

void save(Data data); // 隐式 public abstract

public interface Logger {
    default void log(String message) {
        System.out.println("[INFO] " + message);
    }
}

public interface MathUtils {
    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

// 调用
MathUtils.max(5, 3); // 无需实现类

public interface DataParser {
    private String cleanData(String raw) {
        return raw.trim().replaceAll("\\s+", " ");
    }
    
    default Data parse(String raw) {
        return new Data(cleanData(raw));
    }
}

interface A { default void run() { System.out.println("A"); } }
interface B { default void run() { System.out.println("B"); } }

class C implements A, B { } // 编译错误：冲突的默认方法

class C implements A, B {
    public void run() {
        A.super.run(); // 选择A的实现
    }
}

class C implements A, B {
    public void run() {
        System.out.println("C"); // 自定义实现
    }
}

interface D extends A {
    default void run() { // 更高优先级
        System.out.println("D");
    }
}

class E implements D, B { } // 使用D的run()

// 回调接口
public interface ClickListener {
    void onClick(Event event);
}

// GUI组件
public class Button {
    private ClickListener listener;
    
    public void setListener(ClickListener listener) {
        this.listener = listener;
    }
    
    public void click() {
        if (listener != null) {
            listener.onClick(new Event());
        }
    }
}

// 使用
Button btn = new Button();
btn.setListener(event -> System.out.println("Clicked!")); // Lambda实现

class User implements Cloneable {
    private String name;
    
    @Override
    public User clone() {
        try {
            return (User) super.clone(); // 浅拷贝
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 深拷贝实现
@Override
public User clone() {
    User cloned = (User) super.clone();
    cloned.name = new String(this.name); // 可变字段深拷贝
    return cloned;
}

class Product implements Comparable<Product> {
    private double price;
    
    @Override
    public int compareTo(Product other) {
        return Double.compare(this.price, other.price);
    }
}

// 使用
Arrays.sort(products); // 自动调用compareTo

// 传统实现
class Task implements Runnable {
    public void run() {
        System.out.println("Running in thread");
    }
}

// Lambda简化
new Thread(() -> System.out.println("Lambda task")).start();

try (FileReader reader = new FileReader("file.txt")) {
    // 自动调用close()
} // try-with-resources

// ❌ 臃肿接口
interface Worker {
    void code();
    void test();
    void deploy();
}

// ✅ 拆分细化
interface Developer {
    void code();
}

interface Tester {
    void test();
}

interface DevOps {
    void deploy();
}

@FunctionalInterface // 确保单一抽象方法
interface StringProcessor {
    String process(String input);
    
    // 可有默认/静态方法
    default StringProcessor andThen(StringProcessor next) {
        return input -> next.process(this.process(input));
    }
}

// 使用
StringProcessor upper = String::toUpperCase;
StringProcessor trim = String::trim;
StringProcessor pipeline = trim.andThen(upper);

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

// 组合接口
interface Duck extends Flyable, Swimmable {}

class MallardDuck implements Duck {
    public void fly() { /*...*/ }
    public void swim() { /*...*/ }
}

interface DiscountStrategy {
    double applyDiscount(double price);
}

class ChristmasDiscount implements DiscountStrategy {
    public double applyDiscount(double price) {
        return price * 0.7;
    }
}

// 动态切换策略
shoppingCart.setDiscountStrategy(new ChristmasDiscount());

// 定义扩展点
interface Plugin {
    void initialize();
    String getName();
}

// 加载插件
ServiceLoader<Plugin> plugins = ServiceLoader.load(Plugin.class);
plugins.forEach(Plugin::initialize);

interface DatabaseService {
    User getUser(int id);
}

// 单元测试中
DatabaseService mockDb = mock(DatabaseService.class);
when(mockDb.getUser(1)).thenReturn(new User("Alice"));

// 传统方式：排序
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

// Lambda 方式
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());

(parameters) -> expression
(parameters) -> { statements; }

@FunctionalInterface
interface StringProcessor {
    String process(String input);
    
    // 允许默认方法
    default StringProcessor andThen(StringProcessor after) {
        return input -> after.process(this.process(input));
    }
}

// 静态方法引用
Function<Double, Double> sqrt = Math::sqrt;

// 实例方法引用
List<String> names = Arrays.asList("Alice", "Bob");
names.forEach(System.out::println);

// 构造器引用
Supplier<List<String>> listSupplier = ArrayList::new;

// 无参构造
Supplier<User> userSupplier = User::new;
User user = userSupplier.get();

// 带参构造
Function<String, User> nameToUser = User::new;
User alice = nameToUser.apply("Alice");

Function<Integer, int[]> arrayCreator = int[]::new;
int[] arr = arrayCreator.apply(10); // 创建长度为10的数组

class ScopeExample {
    private String instanceVar = "Instance";
    private static String staticVar = "Static";
    
    public void test() {
        String localVar = "Local"; // 等效 final
        
        Runnable r = () -> {
            System.out.println(localVar);    // ✅ 允许
            System.out.println(instanceVar);  // ✅ 允许
            System.out.println(staticVar);    // ✅ 允许
            
            // localVar = "modified"; // ❌ 编译错误
            instanceVar = "modified"; // ✅ 允许
        };
        
        new Thread(r).start();
    }
}

public static void processNumbers(List<Integer> numbers, Predicate<Integer> filter) {
    for (int num : numbers) {
        if (filter.test(num)) {
            System.out.println(num);
        }
    }
}

// 使用
processNumbers(list, n -> n % 2 == 0); // 过滤偶数

public static Comparator<String> createComparator(boolean reverse) {
    return reverse 
        ? (s1, s2) -> s2.compareTo(s1)
        : (s1, s2) -> s1.compareTo(s2);
}

Function<String, String> pipeline = ((Function<String, String>) String::toUpperCase)
    .andThen(s -> s.replace(" ", "_"))
    .andThen(s -> "[" + s + "]");
    
System.out.println(pipeline.apply("hello world")); // [HELLO_WORLD]

// 传统方式
Collections.sort(people, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
});

// Lambda 方式
Collections.sort(people, (p1, p2) -> p1.getAge() - p2.getAge());

// 按姓氏排序，再按名字排序
Comparator<Person> comparator = 
    Comparator.comparing(Person::getLastName)
              .thenComparing(Person::getFirstName);
              
people.sort(comparator);

// 空值安全比较
Comparator<Person> nullSafe = Comparator.nullsLast(
    Comparator.comparing(Person::getJoinDate)
);

// 逆序比较
Comparator<Person> reverseAge = 
    Comparator.comparingInt(Person::getAge).reversed();

// ❌ 过于复杂
names.stream().filter(n -> {
    boolean isValid = n != null && n.length() > 3;
    if (isValid) {
        System.out.println("Valid: " + n);
    }
    return isValid;
});

// ✅ 简洁清晰
names.stream()
     .filter(Objects::nonNull)
     .filter(n -> n.length() > 3)
     .peek(n -> System.out.println("Valid: " + n));

// ❌ 冗余Lambda
numbers.stream().map(n -> String.valueOf(n));

// ✅ 方法引用
numbers.stream().map(String::valueOf);

// ❌ 有副作用的Lambda
List<String> result = new ArrayList<>();
names.stream().forEach(n -> result.add(n.toUpperCase())); 

// ✅ 无副作用方式
List<String> result = names.stream()
                           .map(String::toUpperCase)
                           .collect(Collectors.toList());

for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        System.out.println(i); // ❌ 编译错误：i 非最终
    }).start();
}

// 解决方案：使用临时final变量
for (int i = 0; i < 10; i++) {
    final int index = i;
    new Thread(() -> System.out.println(index)).start();
}

interface Adder {
    int add(int a, int b);
}

interface SmartAdder {
    int add(double a, double b);
}

void calculate(Adder adder) { /*...*/ }
void calculate(SmartAdder adder) { /*...*/ }

// 调用歧义
calculate((a, b) -> a + b); // ❌ 编译错误

// 统计长单词数量
long count = words.stream()
                 .filter(w -> w.length() > 10)
                 .count();

button.addActionListener(event -> 
    System.out.println("Button clicked"));

CompletableFuture.supplyAsync(() -> fetchData())
                .thenApply(data -> process(data))
                .thenAccept(result -> save(result));

Optional.ofNullable(input)
        .map(String::trim)
        .filter(s -> !s.isEmpty())
        .orElseThrow(() -> new IllegalArgumentException("Invalid input"));

class OuterClass {
    // 实例内部类
    class InnerClass { /*...*/ }
    
    // 静态内部类
    static class StaticNestedClass { /*...*/ }
    
    void method() {
        // 局部内部类
        class LocalClass { /*...*/ }
        
        // 匿名内部类
        Runnable r = new Runnable() { /*...*/ };
    }
}

class Outer {
    private int x = 10;
    
    class Inner {
        void access() {
            System.out.println("Outer x: " + Outer.this.x);
            // 等价于直接写 x
        }
    }
}

// 编译后的内部类（近似）
class Outer$Inner {
    private final Outer this$0; // 编译器添加的隐藏引用
    
    Outer$Inner(Outer outer) {
        this$0 = outer;
    }
    
    void access() {
        System.out.println("Outer x: " + this$0.x);
    }
}

class Outer {
    private static int staticY = 20;
    private int instanceX = 10;
    
    static class StaticInner {
        void tryAccess() {
            System.out.println(staticY); // ✅ 允许
            // System.out.println(instanceX); // ❌ 编译错误
        }
    }
}

class Outer {
    void createInner() {
        Inner inner = new Inner(); // 直接实例化
        inner.access();
    }
    
    class Inner { /*...*/ }
}

public class Database {
    private class ConnectionPool { // 隐藏实现细节
        private void manageConnections() { ... }
    }
    
    public void query(String sql) {
        ConnectionPool pool = new ConnectionPool();
        // ...
    }
}

public class Validator {
    public void validate(final int maxLength) {
        class LengthRule {
            boolean check(String input) {
                // 访问方法参数（需final）
                return input.length() <= maxLength; 
            }
        }
        
        new LengthRule().check("test");
    }
}