部分内容来自以下博客：
https://www.cnblogs.com/onetwo/p/8526374.html
https://www.cnblogs.com/xxez-d/p/5989944.html
https://www.cnblogs.com/runningTurtle/p/7092632.html
https://www.cnblogs.com/jiangwz/p/9197238.html
https://www.cnblogs.com/hujingnb/p/10181630.html
1 接口增强
在JDK1.8以前的版本中，定义一个接口时，所有的方法必须是抽象方法，不能有具体实现，这是Java语法规定的。但是在JDK1.8中定义一个接口时，在满足特定的前提下，可以有方法的具体实现。这样一个接口中可以有属性，可以有抽象方法，也可以有具体的方法，这跟JDK1.8以前的接口比，明显接口的功能变得强大了。
1.1 使用接口增强
接口中定义具体的方法实现是有限制的，它不能像我们在一个普通类那样随便定义方法实现，它只能定义default和static类型的方法。
在调用的时候，被default修饰的默认方法需要通过实现了该接口的类去调用，被static修饰的静态方法可以通过接口名直接调用。
default和static不能用来修饰Object中的public方法，但是可以修饰Object中其他访问修饰符修饰的方法。
代码如下：
public class Demo {
public static void main(String[] args) {
NewInterface.testStatic();
new NewInterfaceImpl().testDefault();
}
}
interface NewInterface {
public String name = "";
default void testDefault() {
System.out.println("测试新增的default方法");
}
static void testStatic() {
System.out.println("测试新增的static方法");
}
}
class NewInterfaceImpl implements NewInterface {
@Override
public void testDefault() {
NewInterface.super.testDefault();
System.out.println("测试子类重写的新增的static方法");
}
}运行结果如下：
测试新增的static方法
测试新增的default方法
测试子类重写的新增的static方法1.2 好处
想象这样一中情况，当多个类实现一个接口的某个方法时，方法的具体实现代码相同，这样就会造成代码重复问题。接口增强就相当于把公共的代码抽离出来，放入接口定义中，这样实现类对于该方法就不用重新定义，直接调用即可，这很好的解决了实现该接口的子类代码重复的问题。
2 函数式接口
所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法，这种类型的接口也称为SAM（Single Abstract Method）接口。
下面的代码展示了一个简单的函数式接口：
interface NewInterface {
void test();
}2.1 关于@FunctionalInterface注解
JDK1.8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。
加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。
下面的代码展示了一个加了注解的函数式接口：
@FunctionalInterface
interface NewInterface {
void test();
}2.2 函数式接口里允许定义默认方法
函数式接口里是可以包含默认方法，因为默认方法不是抽象方法，其有一个默认实现，所以是符合函数式接口的定义的。
下面的代码展示了一个带有默认方法的函数式接口：
@FunctionalInterface
interface NewInterface {
void test();
default void defaultRead() {
System.out.println("defaultRead() ...");
}
default void defaultWrite() {
System.out.println("defaultWrite() ...");
}
}2.3 函数式接口里允许定义静态方法
函数式接口里是可以包含静态方法，因为静态方法不能是抽象方法，是一个已经实现了的方法，所以是符合函数式接口的定义的。
下面的代码展示了一个带有静态方法的函数式接口：
@FunctionalInterface
interface NewInterface {
void test();
static void staticRead() {
System.out.println("staticRead() ...");
}
static void staticWrite() {
System.out.println("staticWrite() ...");
}
}2.4 函数式接口里允许定义Object类的public方法
函数式接口里是可以包含Object类的public方法，这些方法对于函数式接口来说，不被当成是抽象方法（虽然它们是抽象方法）。因为此接口的实现类一定是Object的子类，会自动实现这个接口中定义的抽象方法。
但也只能是public方法，其他访问修饰符修饰的方法是不允许在函数式接口里定义的。
下面的代码展示了一个带有Object类的public方法的函数式接口：
@FunctionalInterface
interface NewInterface {
void test();
@Override
public String toString();
@Override
public boolean equals(Object obj);
// @Override
// public Object clone();
}3 JDK1.8新增的函数式接口
JDK1.8内置的函数式接口放在包java.util.function下，默认在JDK安装路径下的src.zip中。
3.1 Supplier接口
Supplier接口没有参数，只有返回值，作用是为了产生对象。
@FunctionalInterface
public interface Supplier<T> {
T get();
}3.2 Consumer接口
Consumer接口有参数，但是没有返回值，作用是为了进行某种操作，比如打印操作。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}3.3 Function接口
Function接口有参数，也有返回值，作用是对参数进行处理并返回。
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}3.4 Predicate接口
Predicate接口有参数，也有返回值，但返回值是Boolean类型的值，作用是对传入的参数进行某种判断。
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}4 Lambda表达式
4.1 什么是Lambda表达式
通过使用表达式来提供一种清晰简洁的方式来表示方法接口。
4.2 语法
参数列表 -> 方法体
如果参数列表有多个值，可以使用小括号包含，如果只有一条，则可以省略小括号。
如果方法体有多条语句，可以使用大括号包含，如果只有一条，则可以省略大括号，如果是return语句，则可以省略return关键字。
4.3 使用举例
在创建一个线程并调用的时候，需要传入一个Runnable接口的实现类。
使用Lambda表达式之前：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Thread1 run() ...");
}
}).start();使用Lambda表达式之后：
new Thread(() -> System.out.println("Thread2 run() ...")).start();4.4 变量作用域
Lambda表达式只能引用标记了final的外层局部变量，这就是说不能在Lambda内部修改定义在域外的局部变量，否则会编译错误。
final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));Lambda表达式的局部变量可以不用声明为final，但是必须不可被后面的代码修改（即隐性的具有final的语义）。
final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));
// num++;在Lambda表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
final int num = 100;
// NewInterface ni = num -> String.valueOf(num);
NewInterface ni = i -> String.valueOf(i);
System.out.println(ni.test(num));5 方法引用
5.1 什么是方法引用
方法引用是JDK1.8中提出的用来简化Lambda表达式的一种手段。它通过类名和方法名来定位到一个静态方法或者实例方法。
5.2 语法
类或对象名::方法名或new
5.3 静态方法引用
如果是静态方法引用，那么语法是“类名::静态方法名”，并且方法调用传入的参数就是方法用到的参数。
代码如下：
public class Demo {
public static void main(String[] args) {
// 使用匿名内部类
// NewInterface ni = new NewInterface() {
// @Override
// public String test(String name) {
// return String.valueOf(name);
// }
// };
// 使用Lambda表达式
// NewInterface ni = name -> String.valueOf(name);
// 使用方法引用
NewInterface ni = String::valueOf;
System.out.println(ni.test("name"));
}
}
@FunctionalInterface
interface NewInterface {
String test(String name);
}运行结果如下：
name5.4 实例方法引用
如果是实例方法引用，那么语法是“对象实例::方法名”，并且方法调用传入的第一个参数是方法的调用者，后面的参数才是方法的参数。
代码如下：
public class Demo {
public static void main(String[] args) {
// 使用匿名内部类
// NewInterface ni = new NewInterface() {
// @Override
// public int test(String str) {
// return str.length();
// }
// };
// 使用Lambda表达式
// NewInterface ni = str -> str.length();
// 使用方法引用
NewInterface ni = String::length;
System.out.println(ni.test("lenth"));
}
}
@FunctionalInterface
interface NewInterface {
int test(String str);
}运行结果如下：
55.5 构造方法引用
如果是构造方法引用，那么语法是“类名::new”，并且方法调用传入的参数就是构造方法的参数。
代码如下：
public class Demo {
public static void main(String[] args) {
// 使用匿名内部类
// NewInterface ni = new NewInterface() {
// @Override
// public String test(String str) {
// return new String(str);
// }
// };
// 使用Lambda表达式
// NewInterface ni = str -> new String(str);
// 使用方法引用
NewInterface ni = String::new;
System.out.println(ni.test("str"));
}
}
@FunctionalInterface
interface NewInterface {
String test(String str);
}运行结果如下：
str
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
