Java基础 第四节 第六课

函数式编程思想概述

在数学中, 函数就是有输入量, 输出量的一套计算方案. 也就是 “拿什么东西做什么事情”. 相对而言, 面向对象过分强调 “必须通过对象的形式来做事情”, 而函数式思想则尽量忽略面向对象的复杂语法–强调什么做什么, 而不是以什么形式做.

面向对象的思想:

做一件事情, 找一个能理解这个事情的对象, 调用对象的方法, 完成事情.

函数式编程思想:

只能获取到结果, 谁去做的, 怎么去做的都不重要, 重要的是结果.

冗余的 Runnable 代码

传统写法

当需要启动一个线程去完成任务时, 通常会通过java.lang.Runnable接口来定义任务内容, 并使用java.lang.Thread类来启动该线程. 代码如下:

public class Test {
    public static void main(String[] args) {
        // 匿名内部类
        Runnable task = new Runnable() {
            @Override
            public void run() {  // 覆盖重写抽象方法
                System.out.println("多线程任务执行!");
            }
        };
        new Thread(task).start();  // 启动线程
    }
}

输出结果:
多线程任务执行!

本着 “一切皆为对象” 的思想, 这种做法是无可厚非的:

首先创建一个 Runnable 接口的匿名内部类对象来指定任务内容, 再将其交给一个线程来启动.

代码分析

对于 Runnable 的匿名内部类用法, 可以分析出几点内容:

• Thread 类需要 Runnable 接口作为参数, 其中的抽象 run 方法是用来指定线程任务内容的核心
• 为了指定 run 的方法体, 不得不需要 Runnable 接口实现类
• 为了省去定义一个 RunnableImpl 实现类的麻烦, 不得不使用匿名内部类
• 必须覆盖重写抽象 run 方法, 所以方法名称, 方法参数, 方法返回值不得不再写一遍, 而且不能写错
• 而实际上, 似乎只有方法体才是关键所在

编程思想转换

做什么, 而不是怎么做

我们真的希望创建一个匿名内部类对象吗? 不, 我们只是为了做这件事情而不得不创建一个对象. 我们真正希望做的事情是: 将 run 方法体内的代码传递给 Thread 类知晓.

传递一段代码, 这才是我们的真正目的. 而创建对象只是受限于面向对象语法而不得不采取的一种手段方式. 那么, 有没有更加简单的办法? 如果我们将关注点从 “怎么做” 回归到 “做什么” 的本质上, 就会发现只要能有更好地到达目的, 过程与形式其实并不重要.

生活举例

当我们需要从北京到上海时, 可以选择高铁, 汽车, 骑行或是徒步, 我们的真正目的是到达上海. 而如何才能到达上海的形式并不重要, 所以我们一直在探索有没有比高铁更好的方式. (搭乘飞机)

而现在这种飞机已经诞生:

2014 年 3 月 Oracle 所发布的 Java 8 (JDK 1.8) 中, 加入了 Lambda 表达式的重量级新特性, 为我们打开了新世界的大门.

体验 Lambda 的更优写法

借助 Java 8 的全新语法, 上述 Runnable 接口匿名内部类写法可以通过更简单的 Lambda 表达式达到等效:

public class Test {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("多线程")).start();  // 启动线程
    }
}

这段代码和刚才的执行效果是完全一样的, 可以在 1.8 或更高的编译级别下通过. 从代码的语义汇总可以看出: 我们启动一个线程, 而线程任务的内容以一种更加简洁的形式被指定.

不再有 “不得不创建接口对象” 的束缚, 不再有 “抽象方法覆盖重写” 的负担, 就是这么简单!

回顾匿名内部类

Lambda 是怎么样击败面向对象的? 在上例中, 核心代码其实只是如下所示的内容:

() -> System.out.println("多线程任务执行！")

为了理解 Lambda 的语义, 我们需要从传统的代码起步.

使用实现类

要启动一个线程, 需要创建一个 Thread 类的对象并调用 start 方法. 而为了指定线程执行的内容, 需要调用 Thread 类的构造方法:

public Thread(Runnable target)

为了获取 Runnable 接口的实现对象, 可以为该接口定义一个实现类 RunnableImpl:

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println("多线程任务执行!");
    }
}

然后创建实现类的对象作为 Thread 类的构造参数:

public class Demo03ThreadInitParam {
    public static void main(String[] args) {
        Runnable task = new RunnableImpl();
        new Thread(task).start();
    }
}

使用匿名内部类

这个 RunnbaleImpl 类只是为了实现 Runnable 接口而存在的, 而且仅被用了唯一一次. 所以使用匿名内部类的语法即可省去该类的单独定义. 即匿名内部类:

public class Test {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程任务执行!");
            }
        }).start();
    }
}

匿名内部类的好处与弊端

一方面, 匿名内部类可以帮助我们省去实现的定义. 另一方面, 匿名内部类的语法, 确实太复杂了.

语义分析

仔细分析该代码中的语义, Runnable 接口只有一个 run 方法的定义:

public abstract void run()

即制定了一种做事情的方案 (其实就是一个函数):

• 无参数: 不需要任何条件即可执行该方案
• 无返回值: 该方案不产生任何结果
• 代码块 (方法体): 该方案的具体执行步骤

同样的语义体现在 Lambda 语法中, 要更加简单:

() -> System.out.println("多线程任务执行！")

• 前面的一对小括号即 run 方法的参数 (无), 代表不需要任何条件
• 中间的一个箭头代表将前面的参数传递给后面的代码
• 后面的输出语句即业务逻辑代码

Lambda 标准格式

Lambda 省去面向对象的条条框框, 格式由 3 个部分组成:

• 一些参数
• 一个箭头
• 一段代码

Lambda 表达式的标准格式为:

(参数类型 参数名称) -> { 代码语句 }

格式说明:

• 小括号内的语法与传统方法参数列表一致. 无参数则留空, 多个参数则用逗号分隔
• -> 是新引入的语法格式, 代表指向动作
• 大括号内的语法与传统方法体要求基本一致