Java面向对象之函数式编程
1 函数式编程
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“用什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式来做。
1.1 做什么，而不是怎么做
- 例如：
new Thread(new Runnable(){
@Override
public void run(){
//TODO things
}
}).start();对于 Runnable 的匿名内部类用法，可以分析出几点内容：
-
Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心； - 为了指定 run 的方法体，我们必须要创建
Runnable 接口的实现类； - 为了省去定义一个
Runnable 实现类的麻烦，我们必须要使用匿名内部类； - 在匿名内部类中，我们必须覆盖重写抽象的 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能有错；
- 而实际上，大概仅有 run() 方法体才是程序中最需要的关键所在。
- 我们真正希望做的事情是，将 run 方法体内的代码传递给 Thread 类并去执行。
思考：
我们真的希望创建一个匿名内部类对象吗？不！
我们只是为了做这件事情而不得不创建一个对象。
1.2 函数式编程的本质是什么？
传递一段代码——这才是我们真正目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那么，有没有更加简单的方法呢？
如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。
匿名内部类存在的一个问题是，即使匿名内部类的实现非常简单，例如只包含一个抽象方法的接口，那么匿名内部类的语法仍然显得比较冗余。
解决方法：可以使用JDK8开始支持的 lambda 表达式，这种表达式只针对有一个抽象方法的接口实现，以简洁的表达式形式实现接口功能来作为方法参数。
new Thread(() -> System.out.println("多线程任务执行!")).start();这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。
不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！
1.3 Lambda表达式
lambda 表达式的基本语法格式
语句中通过箭头来区分开参数列表和方法体
2 函数式接口
2.1 是否可以使用 lambda 代替所有匿名内部类？
接口中有且只有一个抽象方法时，才能使用 lambda 表达式代替匿名内部类。这是因为 lambda 表达式是基于函数式接口实现的。
所谓函数式接口是指有且只有一个抽象方法的接口，lambda 表达式就是java中函数式编程的体现，只有确保接口中有且只有一个抽象方法，lambda 表达式才能顺利地推导出所实现的这个接口中的方法。
2.2 定义
在JDK8中，接口上标注有 @FunctionalInterface 注解的即为函数式接口，在函数式接口内部有且只有一个抽象方法。
来看下 Runnable 接口中的源码：
说明：@FunctionalInterface 注解只是显式的标注了接口是一个函数式接口，并强制编辑器进行更严格的检查，确保该接口是函数式接口。
JDK8之前已有的部分函数式接口：
- java.lang.Runnable
- java.util.Comparater
- java.io.FileFilter
- java.lang.Reflect.InvocationHandler
JDK8 增加的函数式接口
java.util.function 包下包含了很多类，用来支持java的函数式编程。
2.3 Lambda 表达式的简化
lambda 表达式的省略写法（进一步在lambda表达式的基础上继续简化）
1、如果lambda表达式的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！
2、如果lambda表达式的方法体代码只有一行代码，如果这行代码是return 语句，必须省略return 不写，同时省略分号。
3、参数类型可以省略不写。
4、如果只有一个参数，参数外的()也可以省略。
除了以上简化规则，还可以使用“方法引用”进一步简化 lambda 表达式。
public class TestOutter {
public static void main(String[] args) {
//匿名函数写法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程1启动了！");
}
}).start();
//lambda写法
new Thread(() -> {System.out.println("线程2启动了！");}).start();
}
}
3 方法引用
说明：lambda 表达式的主体只有一条语句时，程序不仅可以省略包含主体的大括号，还可以通过英文双冒号“::”的语法格式来引用方法和构造器（即构造方法）。
作用：可以进一步简化lambda表达式的书写，其本质都是对 lambda 表达式的主体部分已存在的方法进行直接引用，主要区别就是对普通方法与构造方法的引用而已。
3.1 类名引用静态方法
定义：类名引用静态方法也就是通过类名对静态方法的引用，该类可以是java自带的特殊类，也可以是自定义的普通类。
引用示例如下：
//定义函数式接口
@FunctionalInterface
interface Calcable{
int calc(int num);
}
//定义一个类，类中定义一个静态方法
class Math{
public static int abs(int num){
return num > 0 ? num : -num;
}
}
public class Example {
private static void printAbs(int num, Calcable calcable){
System.out.println(calcable.calc(num));
}
public static void main(String[] args) {
//1、使用匿名内部类
printAbs(-8, new Calcable() {
@Override
public int calc(int num) {
return Math.abs(num);
}
});
//2、使用 lambda 表达式
printAbs(-8, (num) -> {return Math.abs(num);});
//3、简化 lambda 表达式
printAbs(-9, num -> Math.abs(num));
//4、使用方法引用，简化 lambda 表达式
printAbs(-7, Math::abs);
}
}
3.2 对象名引用方法
定义：对象名引用方法是指通过实例化对象的名称，来对其方法进行的引用。
引用示例如下：
//定义函数式接口
@FunctionalInterface
interface Utils{
String calc(String str);
}
//定义一个类，类中定义一个普通方法
class UpperUtil{
public String toUpper(String str){
return str.toUpperCase();
}
}
public class Example2 {
private static void printUpper(String ori, Utils u){
System.out.println(u.calc(ori));
}
public static void main(String[] args) {
UpperUtil upper = new UpperUtil();
//1、使用匿名内部类
printUpper("abc", new Utils() {
@Override
public String calc(String ori) {
return upper.toUpper(ori);
}
});
//2、使用 lambda 表达式
printUpper("bcd", (ori) -> {return upper.toUpper(ori);});
//3、简化 lambda 表达式
printUpper("cde", ori -> upper.toUpper(ori));
//4、使用方法引用，简化 lambda 表达式
printUpper("def", upper::toUpper);
}
}3.3 构造器引用方法
定义：是指对类自带的构造器的引用。
引用示例如下：
//定义函数式接口
@FunctionalInterface
interface PersonBuilder{
Person buildPerson(String name);
}
//定义一个类，类中定义一个构造器及普通方法
class Person{
private String name;
public Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
public class Example3 {
private static void printName(String name, PersonBuilder buildPerson){
System.out.println(buildPerson.buildPerson(name).getName());
}
public static void main(String[] args) {
//1、使用 lambda 表达式
printName("李四", (String name) -> {return new Person(name);});
//2、使用构造器引用的方式
printName("张三", Person::new);
}
}3.4 类名引用普通方法
定义：是指通过一个普通类的类名，来对其普通方法进行的引用。
引用示例如下：
//定义函数式接口
@FunctionalInterface
interface Printable{
void print(StringUtils su, String str);
}
//定义一个类及方法
class StringUtils{
public void printUppercase(String str){
System.out.println(str.toUpperCase());
}
}
public class Example4 {
private static void printUpper(StringUtils su, String str, Printable printable){
printable.print(su, str);
}
public static void main(String[] args) {
//1、使用匿名内部类
printUpper(new StringUtils(), "abc", new Printable() {
@Override
public void print(StringUtils su, String str) {
su.printUppercase(str);
}
});
//2、使用 lambda 表达式
printUpper(new StringUtils(), "bcd", (Object, t) -> Object.printUppercase(t));
//3、使用方法引用的方式
printUpper(new StringUtils(), "def", StringUtils::printUppercase);
}
}