4.7 函数式编程

1. 动机：匿名内部类的最后一斤赘肉

4.6 结尾埋的伏笔，现在收网。回头看那段匿名内部类：

Flyable f = new Flyable() {          // 编译器知道：左边是 Flyable
    @Override                        // 编译器知道：要实现接口方法
    public void fly() {              // 编译器知道：方法名就是 fly
        System.out.println("扑棱扑棱");
    }
};

真正有信息量的只有方法体那一行——其余全是编译器早就知道的重复劳动。既然你全知道，为什么不让我直接把那一行交给你？于是：

Flyable f = () -> System.out.println("扑棱扑棱");

五行变一行，效果一模一样。这就是 Lambda 表达式，也是"函数式编程"在 Java 里的入口：行为（一段代码）可以像值一样，赋给变量、当参数传来传去。2.6 学过"方法 = 把一段代码打包"，Lambda 再进一步——把打包好的代码当数据用。

2. 函数式接口：Lambda 的入场券

定义一句话：有且只有一个抽象方法的接口，叫函数式接口（Functional Interface）。

对照 4.3 的规矩推一遍：

• 接口里的抽象方法自动是 public abstract——4.3 学过，不用手写；
• 只要抽象方法恰好是一个，它就是函数式接口，跟叫什么名字无关；
• 接口里的 default 方法、static 方法不占名额（它们有实现，不是抽象方法——会认即可）。

判定练习：

@FunctionalInterface：给编译器装的警报器

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

这个注解不是语法要求——不加它，只要"只有一个抽象方法"，照样是函数式接口。它的作用是请编译器帮你看门：谁往接口里加了第二个抽象方法，立刻编译报错。建议自定义函数式接口时都加上，防手滑。

3. Lambda 三段式语法

(参数列表) -> { 方法体 }

三段拆解：

1. 参数列表：照抄那个抽象方法的参数——类型可省，变量名不能省；
2. ->：箭头，固定写法，读作"传入……执行……"；
3. 方法体：就是普通方法体，该干嘛干嘛。

演化三步（对着 4.6 的代码看）

// 第 0 步：匿名内部类（4.6 的写法）
Flyable f = new Flyable() {
    @Override
    public void fly() {
        System.out.println("扑棱扑棱");
    }
};

// 第 1 步：换成 Lambda —— new、方法名、@Override 全部蒸发
Flyable f = () -> {
    System.out.println("扑棱扑棱");
};

// 第 2 步：单语句，大括号也省了
Flyable f = () -> System.out.println("扑棱扑棱");

带参数的例子（本节主角场景）

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

public class TestLambda {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;    // 一行实现"加法"
        Calculator mul = (a, b) -> a * b;    // 一行实现"乘法"

        System.out.println(add.calc(3, 4));  // 7
        System.out.println(mul.calc(3, 4));  // 12
    }
}

同一个接口，Lambda 一换，calc 就换了一种行为——行为像值一样被赋给了变量，这就是"函数式"的味道。多态的老底子还在：Calculator add 左边接口右边实现，4.4 的"编译看左运行看右"原样适用。

三条省略规则

1. 参数类型可省：编译器从左边接口的方法签名里推出来（又是"编译看左"）；
2. 只有一个参数时，小括号可省：s -> s.length()；
3. 方法体只有一句时，大括号、return、分号可省——注意是仨一起省：省了 {} 就不能写 return 和 ;；要写 return 就仨都留着。

Calculator add  = (int a, int b) -> { return a + b; };  // 全写：合法但啰嗦
Calculator add2 = (a, b) -> a + b;                      // 全省：推荐

4. Lambda vs 匿名内部类：什么时候用哪个

Lambda 的两大实战主场（现在混脸熟，后面章节天天用）：

// ① 开线程：Runnable 正好只有一个 run()
new Thread(() -> System.out.println("子线程在干活")).start();

// ② 排序：按字符串长度排，Comparator 正好只有一个 compare()
String[] names = {"波仔", "墨池", "Java", "AI"};
Arrays.sort(names, (s1, s2) -> s1.length() - s2.length());

5. 动手：三种 Lambda

在 IDEA04 里新建 TestLambda（Calculator 照第 3 节抄，Flyable 用 4.3/4.6 的）：

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

public class TestLambda {
    public static void main(String[] args) {
        // ① 自定义函数式接口 + Lambda
        Calculator add = (a, b) -> a + b;
        System.out.println(add.calc(3, 4));      // 7

        // ② 给 4.6 的匿名 Flyable 换装
        Flyable plane = () -> System.out.println("飞机起飞");
        plane.fly();

        // ③ 实战主场：开线程
        new Thread(() -> System.out.println("子线程在干活")).start();
    }
}

成功标准：三段各出对应输出；把 add 换成 mul 输出跟着变——体会"同一个接口变量，行为随 Lambda 而变"。

三个 30 秒实验

1. 警报器生效：给 Calculator 加上 @FunctionalInterface，再塞第二个抽象方法 int calc2(int a);——立刻编译报错"multiple non-overriding abstract methods"。
2. 类型省一半不行：把 (a, b) 改成 (int a, b)——编译报错。类型要省全省、要写全写。
3. 多语句不能省花括号：方法体写成两条语句但去掉大括号——报错；补回 {} 和分号就好了。

6. 常见误区

7. 自测题（先自己答，再展开）

Flyable f = () -> System.out.println("扑棱扑棱");

8. 下一步学什么

• ☑ 4.8 本章小结 ✅ —— 七节串线、概念速查 14 条、代码模板 4 段、七大名坑、三大特性收官、毕业大题。第四章完结。点此复习

相关笔记

• 4.6 内部类 ← 上一篇：Lambda 是匿名内部类的瘦身版，伏笔在此收网
• 4.3 抽象类和接口 ← 函数式接口 = 只有一项条款的合同
• 4.4 多态 ← 接口变量 = Lambda 对象，编译看左运行看右照旧
• 2.6 方法 ← Lambda 的参数与返回值规则全从方法定义推
• 📇 Java基础 · 索引
• 🏠 返回主页