导语
可以了解一下Java8的新特性，但是这些东西一般是不会使用的。
主要内容
- 使用default与static定义接口方法
- Lamda表达式
- 方法引用
- 内建函数式接口
具体内容
使用default与static定义接口方法
从Java发展之初到今天已经经过20年的时间了，在这20年的时间里面所有的开发者都知道，Java的接口由全局常量和抽象方法所组成。但是从JDK1.8的时代，这一组成改变了。
如果说现在有某一个接口，这个接口随着时间的发展已经产生了2W个子类。突然有一天发现，这个接口里的方法不足，应该再增加一个方法，而针对于所有不同的子类，这个方法的功能实现是完全一样的。按照最初的做法是在每一个子类上都覆写这个新的方法。那么就要修改2W个子类。
所以为了解决这样的问题，允许在接口里面定义普通方法了。但是如果要定义普通方法就必须明确的使用default来进行定义。
范例：定义default方法
public interface Message { // 定义接口
public void print(); // 这是一个接口里原本定义的方法
default void fun() { // 在接口里定义了一个普通的方法
System.out.println("毁三观的方法出现了！");
}
}
public class MessageImpl implements Messagee {
@Override
public void print() {
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String args[]) {
Message msg = new MessageImpl();
msg.fun(); // 此方法是在接口里面定义的
}
}
输出结果
毁三观的方法出现了！
除了使用default定义方法之外，还可以使用static定义方法，一旦使用了static定义方法意味着这个方法可以直接由类名称调用。
范例：定义static方法
public interface Message { // 定义接口
public void print(); // 这是一个接口里原本定义的方法
static void get() {
System.out.println("直接由接口调用！");
}
}
public class TestDemo {
public static void main(String args[]) {
Message.get();
}
}
输出结果
直接由接口调用！
在JDK1.8里面有一个最重要的概念：内部类访问方法参数的时候可以不加final关键字。
所有出现的这些新特性，完全打破了Java已有的代码组成形式。
Lamda表达式
- 分析函数式编程的产生原因。
- 掌握函数式编程的语法。
Lamda属于函数式编程的概念，为什么需要函数式的编程呢？
如果想要清楚函数式编程的产生目的，那么必须通过匿名内部类来分析。
范例：匿名内部类
public interface Message {
public void print();
}
public class TestDemo {
public static void main(String args[]) {
fun(new Message() {
public void print() {
System.out.println("Hello World !");
}
});
}
public static void fun(Message msg) {
msg.print();
}
}
实际上整个代码之中，如果是fun()方法，最终需要的只是一个输出而已，但是由于Java的开发结构性完整要求，所以不得不在这个核心的语句上嵌套更多的内容。
以上的做法要求的实在是过于严谨了，氢在JDK1.8时代引入了函数式的编程，可以简化代码。
范例：使用Lamda表达式
public interface Message {
public void print(String str);
}
public class TestDemo {
public static void main(String args[]) {
// 首先定义此处表达里面需要接收的变量，单行语句直接进行输出
fun((s) -> System.out.println(s));
}
public static void fun(Message msg) {
msg.print("Hello World !"); // 设置参数内容
}
}
输出结果
Hello World !
整个操作里面匿名内部类只是进行一行语句的输出，所以此时使用了Lamda表达式可以非常轻松的完成代码要求。
对于Lamda语法有三种形式：
- (参数) -> 单行语句。
- (参数) -> {多行语句}。
- (参数) -> 表达式。
范例：编写一个表达式
public interface Message {
public int add(int x, int y);
}
public class TestDemo {
public static void main(String args[]) {
fun((s1, s2) -> s1 + s2);
}
public static void fun(Message msg) {
System.out.println(msg.add(10, 20));
}
}
输出结果
30
方法引用
一直以来都只是在对象上能够发现引用的应用，而对象引用的特点：不同的对象可以操作同一块内容。而所谓的方法引用指为一个方法设置别名，相当于一个方法定义了不同的名字。
方法引用在Java8之中一共定义了四种形式：
- 引用静态方法：类名称 :: static 方法名字。
- 引用某个对象的方法：实例化对象 :: 普通方法。
- 引用特定类型的方法：特定类 :: 普通方法。
- 引用构造方法：类名称 :: new。
引用静态方法
范例：引用静态方法
在String类里面有一个valueOf方法：public static String valueOf(int x);
public interface Message<P,R> {
public R zhuanhuan(P p);
}
public class TestDemo {
public static void main(String args[]) {
// 即：将String.valueOf()方法变为了Message接口里的zhuanhuan()方法
Message<Integer, String> msg = String :: valueOf();
String str = msg.zhuanhuan(1000);
Systemout.println(str.replaceAll("0", "9"));
}
}
输出结果
1999
普通方法引用
范例：普通方法引用
public interface Message<R> {
public R upper();
}
public class TestDemo {
public static void main(String args[]) {
// String类的toUpperCase()定义：public String toUpperCase()
// 这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的情况下才可以调用
// "hello"字符串是String类的实例化对象，所以可以直接调用toUpperCase()方法
// 将toUpperCase()函数的应用交给了Message接口
Message<String> msg = "hello" :: toUpperCase;
String str = msg.upper(); // 相当于“"hello".toUpperCase()”
Systemout.println(str);
}
}
输出结果
HELLO
通过两个代码演示发现，如果要实现函数的引用，那么必须要有接口，而且最为关心的是，接口里面需要只存在一个方法（如果出现多个方法是无法引用的）。
所以为了保证被引用接口里面只能够有一个方法，那么就需要一个注解的声明@FunctionalInterface。表示此为函数式接口，只能够定义一个方法。
引用特定类的方法
在进行方法引用的过程里面还有另外一种形式的引用（它需要特定类的对象支持），正常情况下如果使用了“类 :: 方法”，引用的一定是类中的静态方法，但是这种形式也可以引用普通方法。
例如：在String类里面有一个方法public int compareTo(String anotherString)。
如果要进行比较的话，比较的形式：字符串1对象.compareTo(字符串2对象)，也就是说如果真要引用这个方法就需要准备出两个参数。
范例：引用特定类的方法
@FunctionalInterface
public interface Message<P> {
public int compare(P p1, P p2);
}
public class TestDemo {
public static void main(String args[]) {
Message<String> msg = String :: compareTo;
System.out.println(msg.compare("A", "B"));
}
}
输出结果
-1
与之前相比，方法引用前不再需要定义对象，而是可以理解为将对象定义在了参数上。
引用构造方法
范例：引用构造方法
@FunctionalInterface
public interface Message<C> {
public C create(String t, double p);
}
public class Book {
private String title;
private double price;
public Book(String title, double price) {
this.title = title;
this.price = price;
}
@Override
public String toString() {
return "书名：" + this.title + "，价格：" + this.price + "。";
}
}
public class TestDemo {
public static void main(String args[]) {
Message<String> msg = Book :: new; // 引用构造方法
// 调用的虽然是create()，但是这个方法引用的是Book类的构造
Book book = msg.create("Java开发", 20.2);
System.out.println(book);
}
}
输出结果
书名：Java开发，价格：20.2)。
对象的引用是使用不同的名字，而方法引用是需要一个函数式的接口，并且要设置好参数。
内建函数式接口
观察在JDK1.8中提供的新的函数式接口包以及提供的四个函数式接口。
对于方法的引用，严格来讲都需要定义一个接口，可是不管如何操作，实际有可能操作的接口只有四种，在JDK1.8里面提供了一个包：java.util.function，提供有以下四个核心接口：
- 功能性接口（Funcation）：此接口需要接收一个参数，并且返回一个处理结果。
public interface Function<T, R> {
public R apply(T t);
}
- 消费型接口（Consumer）： 此接口只是负责接收数据（引用数据是不需要返回），并且不返回处理结果。
public interface Consumer<T> {
public void accept(T t);
}
- 供给型接口（Suppliers）： 此接口不接收参数，但是可以返回结果。
public interface Suppliers<T> {
public T get();
}
- 断言型接口（Predicate）：进行判断操作使用。
public interface Predicate<T> {
public boolean test(T t);
}
所有在JDK1.8之中由于存在有以上的四个功能型接口，所以一般很少会由用户去定义新的函数式接口。
范例：观察函数式接口——接收参数并且返回一个处理结果
String类有一个方法：public boolean startsWith(String str)。
public class TestDemo {
public static void main(String args[]) {
Function<String, Boolean> fun = "##hello" :: startsWith;
System.out.println(fun.apply("##"));
}
}
输出结果
true
范例：消费型接口
public class TestDemo {
public static void main(String args[]) {
Consumer<String> cons = System.out :: println;
cons.accept("Hello World !");
}
}
输出结果
Hello World !
范例：供给型接口
引用String类的toUpperCase()方法：public String toUpperCase()。
public class TestDemo {
public static void main(String args[]) {
Supplier<String> sup = "hello" :: toUpperCase;
System.out.println(sup.get());
}
}
输出结果
HELLO
范例：断言型接口
引用String类的equalsIgnoreCase()方法。
public class TestDemo {
public static void main(String args[]) {
Predicate<String> pre = "hello" :: equalsIgnoreCase;
System.out.println(sup.test("hello"));
}
}
输出结果
true
这几个接口包含了所有可能出现的方法引用，也是函数式接口的代表，但是有许多的接口与它类似。
总结
- 接口里面使用default或static定义方法的意义是避免子类重复实现同样的代码。接口的使用还应该以抽象方法为主。
- 利用Lamda表达式最终解决的问题：避免了匿名内部类过多无用的操作。
- 四种方法引用基本的形式如上，现在不般不去使用。
- 有了这几个函数式接口，那么开发中就不再需要了。这些东西为最后的数据流准备。
