1
public interface Comparable<T> {
2
    int compareTo(T other);   // 只有签名，没有实现
3
}

1
public class Employee implements Comparable<Employee> {
2
    public int compareTo(Employee other) {
3
        return Double.compare(salary, other.salary);
4
    }
5
}

1
Arrays.sort(Comparable[] a)   // 想进来，得是 Comparable 这个类型

1
public interface Comparable<T> {
2
    int compareTo(T other);   // 等价于 public abstract int compareTo(T other);
3
    double PI = 3.14;         // 等价于 public static final double PI = 3.14;
4
}

1
Comparable<Employee> e = new Employee("张三", 50000);
2
Employee boss = new Employee("李四", 80000);
3

4
e.compareTo(boss);   // ✅ 能调：compareTo 在 Comparable 里
5
e.getName();         // ❌ 编译不过：getName 不在 Comparable 里

1
public class Employee implements Cloneable, Comparable<Employee> { ... }

1
class Employee extends Person { }                // ✅
2
class Employee extends Person, Comparable { }    // ❌ 编译错误

1
class Employee extends Person implements Comparable<Employee>, Cloneable { }

1
public interface Greeting {
2
    static String hello() { return "你好"; }   // 普通静态方法，直接给实现
3
}

1
public interface Greeting {
2
    default void bye() { log(); }                         // 默认方法，6.1.5 讲
3
    private void log() { System.out.println("called"); }  // 只给接口内部用
4
}

1
public interface Named {
2
    String getName();                              // 老规矩：抽象方法，必须实现
3

4
    default void greet() {                         // 新加：给了实现
5
        System.out.println("你好，" + getName());
6
    }
7
}

1
public interface A { default void f() { System.out.println("A"); } }
2
public interface B { default void f() { System.out.println("B"); } }
3

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

1
public class C implements A, B {
2
    @Override
3
    public void f() { A.super.f(); }   // 显式选 A 那一版
4
}

1
public interface ActionListener {
2
    void actionPerformed(ActionEvent event);   // 只有一个方法
3
}

1
class MyListener implements ActionListener {   // ① 先写个实现类
2
    public void actionPerformed(ActionEvent e) {
3
        System.out.println("到点了");
4
    }
5
}
6

7
ActionListener listener = new MyListener();    // ② 接口变量 → 实现类对象
8
var timer = new Timer(1000, listener);         // ③ Timer 是类，能 new
9
timer.start();                                 // 之后每秒它调一次 actionPerformed

1
public interface Comparator<T> {
2
    int compare(T a, T b);
3
}

1
Arrays.sort(people, new LengthComparator());   // 按名字长度排
2

3
class LengthComparator implements Comparator<String> {
4
    public int compare(String a, String b) {
5
        return a.length() - b.length();
6
    }
7
}

1
public class Employee implements Cloneable {
2
    @Override
3
    public Employee clone() throws CloneNotSupportedException {
4
        return (Employee) super.clone();
5
    }
6
}

1
public class Employee implements Cloneable {
2
    private String name;          // 不可变：共享无所谓
3
    private LocalDate hireDay;    // 不可变：共享无所谓
4
    private Date birthDay;        // 可变：共享会出问题，必须深拷贝
5

6
    @Override
7
    public Employee clone() throws CloneNotSupportedException {
8
        Employee cloned = (Employee) super.clone();   // 浅：birthDay 只复制了引用
9
        cloned.birthDay = (Date) birthDay.clone();    // 深：这句才是关键
10
        return cloned;
11
    }
12
}

1
Arrays.sort(words, new Comparator<String>() {
2
    public int compare(String a, String b) {
3
        return a.length() - b.length();
4
    }
5
});

1
Arrays.sort(words, (a, b) -> a.length() - b.length());

1
(参数) -> 表达式
2
(参数) -> { 语句; ... }

1
Comparator<String> c1 = (String a, String b) -> a.length() - b.length();
2
// 完整写法
3
Comparator<String> c2 = (a, b)             -> a.length() - b.length();
4
// 参数类型可省
5
Function<Integer, Integer> f = x -> x + 1;
6
// 单个参数，括号也能省
7
Supplier<Integer> s1 = () -> 42;
8
// 没有参数
9
Supplier<Integer> s2 = () -> {
10
// 多条语句要花括号 + return
11
    System.out.println("go");
12
    return 42;
13
};

1
@FunctionalInterface
2
public interface Comparator<T> {
3
    int compare(T a, T b);                      // ← 唯一的抽象方法，算数
4
    default Comparator<T> reversed() { ... }    // 有实现，不算
5
}

1
x -> System.out.println(x)   // 等价于下面这个
2
System.out::println

1
interface Printer { void print(String s); }
2

3
class ConsolePrinter implements Printer {   // 专门造一个类
4
    public void print(String s) {
5
        System.out.println(s);
6
    }
7
}
8

9
public class Demo1 {
10
    public static void main(String[] args) {
11
        Printer p = new ConsolePrinter();
12
        p.print("hello");                    // hello
13
    }
14
}

1
interface Printer { void print(String s); }
2

3
public class Demo2 {
4
    public static void main(String[] args) {
5
        Printer p = s -> System.out.println(s);   // 只剩参数 + 方法体
6
        p.print("hello");                         // hello
7
    }
8
}

1
interface Printer { void print(String s); }
2

3
public class Demo3 {
4
    public static void main(String[] args) {
5
        Printer p = System.out::println;   // 连参数名都不用写
6
        p.print("hello");                  // hello
7
    }
8
}

1
int count = 10;
2
Runnable r = () -> System.out.println(count);   // ✅ 读，合法

1
int count = 0;
2
Runnable r = () -> count++;   // ❌ 编译错误：count 必须是事实最终

1
public class Demo {
2
    static void repeat(int times, Runnable task) {   // 参数是函数式接口
3
        for (int i = 0; i < times; i++) task.run();
4
    }
5

6
    public static void main(String[] args) {
7
        repeat(3, () -> System.out.println("hi"));   // 传 lambda 进去：输出 3 行 hi
8
    }
9
}

1
Arrays.sort(people, Comparator.comparing(Employee::getName));   // 按名字排

1
people.sort(Comparator.comparing(Employee::getName)      // 先按名字
2
                     .reversed()                         // 倒序
3
                     .thenComparing(Employee::getSalary)); // 再按薪水

1
public class TalkingClock {
2
    private int interval;
3

4
    private class TimePrinter implements ActionListener {
5
        public void actionPerformed(ActionEvent e) {
6
            System.out.println(interval);   // 直接读外围类的 private 字段
7
        }
8
    }
9
}

1
public class Outer {
2
    private int interval = 1000;
3

4
    class Inner {
5
        void demo() {
6
            Outer outer = Outer.this;   // ① 外围对象：就是个 Outer 对象，能存进变量
7
            System.out.println(outer.interval);
8
        }
9
    }
10
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        Outer outer = new Outer();
4
        Outer.Inner inner = outer.new Inner();
5
        // ② 外部造内部类；③ 类型名要从外面写全
6
        inner.demo();
7
    }
8
}

1
public void start() {
2
    class TimePrinter implements ActionListener {   // 只在本方法内可见
3
        public void actionPerformed(ActionEvent e) { ... }
4
    }
5
    var t = new TimePrinter();
6
}

1
public void start(int interval) {       // 方法参数也是「外层局部变量」
2
    class TimePrinter implements ActionListener {
3
        public void actionPerformed(ActionEvent e) {
4
            System.out.println(interval);   // ✅ 读，合法
5
        }
6
    }
7
}

1
var t = new ActionListener() {              // 不写类名，直接给实现
2
    public void actionPerformed(ActionEvent e) {
3
        System.out.println("到点了");
4
    }
5
};

1
public class Outer {
2
    private static int counter;
3

4
    private static class Helper {        // 没有外围对象引用
5
        void bump() { counter++; }       // 只能碰 static 成员
6
    }
7
}

1
public class Outer {
2
    class A { }          // 非静态内部类
3
    static class B { }   // 静态内部类
4
}
5

6
Outer.B b = new Outer.B();   // 静态：直接 new，不需要外围对象
7

8
Outer o = new Outer();       // 非静态：必须先有一个 Outer 对象
9
Outer.A a = o.new A();

1
public class Top {
2
    static class Mid {          // 静态：new 它不需要 Top 实例
3
        class Inner { }         // 非静态：仍然需要 Mid 实例
4
    }
5
}
6

7
Top.Mid m = new Top.Mid();          // 直接 new，到此为止
8
Top.Mid.Inner i = m.new Inner();    // Inner 不是静态的，还得要 m

1
interface Greeter {
2
    String greet(String name);
3
}
4

5
class RealGreeter implements Greeter {
6
    public String greet(String name) { return "你好，" + name; }
7
}

1
class LogHandler implements InvocationHandler {
2
    private final Greeter target;                 // 包着真实现
3
    LogHandler(Greeter target) { this.target = target; }
4
  //构造器
5
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
6
        System.out.println("调用：" + method.getName());
7
    // ① 截住，先干自己的活
8
        return method.invoke(target, args);
9
    // ② 再转给真实现
10
    }
11
}

1
Greeter real  = new RealGreeter();
2
Greeter proxy = (Greeter) Proxy.newProxyInstance(
3
    Greeter.class.getClassLoader(),   // 固定写法
4
    new Class[]{ Greeter.class },     // 代理要实现的接口
5
    new LogHandler(real)              // 方法被调到时跑它
6
);
7

8
System.out.println(proxy.greet("张三"));

1
调用：greet
2
你好，张三