JDK8-新特性
这里写自定义目录标题
- JDK8主要的新特性有一下几种：
- Lambda表达式
- lambda表达式的一般语法
- Lambda表达式眼中的外部变量
- Lambda眼中的this
- 函数式接口
- Stream API
- Stream的创建
- 转换stream
- 汇聚（Reduce）Stream
- 接口的新增 默认方法和静态方法
- 解决默认方法冲突的规则
- 新的日期时间 API
JDK8主要的新特性有一下几种：
- Lambda表达式
- 函数式接口
- Stream API
- 接口的新增 默认方法和静态方法
- 新时间日期API
Lambda表达式
Lambda表达式实际上就是匿名函数的一种简化版，主要是结合函数式接口，简化代码复杂度;
Java8的lambda表达式给我们提供了创建SAM（Single Abstract Method）接口更加简单的语法糖。
lambda表达式的一般语法
(Type1 param1, Type2 param2, ..., TypeN paramN) -> {
statment1;
statment2;
//.............
return statmentM;
}
从lambda表达式的一般语法可以看出来，还是挺符合上面给出的非精确版本的定义–“一段带有输入参数的可执行语句块”。
上面的lambda表达式语法可以认为是最全的版本，写起来还是稍稍有些繁琐。别着急，下面陆续介绍一下lambda表达式的各种简化版
1. 参数类型省略–绝大多数情况，编译器都可以从上下文环境中推断出lambda表达式的参数类型。
这样lambda表达式就变成了：
(param1, param2, ..., paramN) -> {
statment1;
statment2;
//.............
return statmentM;
}
2. 当lambda表达式的参数个数只有一个，可以省略小括号。
lambda表达式简写为：
param1 -> {
statment1;
statment2;
//.............
return statmentM;
}
**3. 当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号。**lambda表达式简化为：
param1 -> statment1
4. 使用Method Reference和Construct Reference(具体语法后面介绍)
- 类名::静态方法
- 类名::实例方法
- 类实例名::实例方法
- 类构造方法 类名::new
Lambda表达式眼中的外部变量
我们知道匿名内部类可以访问它传递的参数，也能自己内部定义变量，也能访问final 修饰的外部变量（引用）。外部变量，java8以前需要显示的用final修饰，java以后，编译器隐式当成final来处理。
public class ATest extends TestCase {
@Test
public void testFunctionInterface(){
Student student = new Student("James");
student.setName("mark");
int i = 2;
//i=3;
//使用匿名类
print(new A(){
@Override
public void sayHello() {
//如果上面给i重新赋值 i=3 将报错Variable 'i' is accessed from within inner class, needs to be final or effectively final
System.out.println(i);
System.out.println(student.getName());//这里不会报错
System.out.println("use anonymous class invoke Method！");
}
});
}
class Student {
public Student(String name) {
this.name = name;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
Lambda表达式既然本质上也是匿名内部类，那么它访问外部变量，是否也同上面讷
public class ATest extends TestCase {
@Test
public void testFunctionInterface(){
Student student = new Student("James");
student.setName("mark");
Integer i = 2;
//i=3;
//使用Lambda表达式
print(()-> {
//同匿名内部类一样，如果上面给i重新赋值 i=3 将报错Variable used in lambda expression should be final or effectively final
System.out.println(i);
});
@Test
public void testLambda(){
String[] array = {"a", "b", "c"};
for(Integer i : Arrays.asList(1,2,3)){
//这里调用外部变量Integer i 不报错
Stream.of(array).map(item -> item+i+'@').forEach(System.out::println);
}
for(Integer i = 1; i<4; i++){
//这里调用外部变量Integer i 报编译错误Variable used in lambda expression should be final or effectively final
Stream.of(array).map(item -> item+i+'@').forEach(System.out::println);
}
}
}
ps：大家可以想象为什么用foreach格式的不报错，而原生for循环报错
这里要结合foreach的实现原理来看：
我们知道，Java 中的 foreach 语法是 iterator（迭代器）的变形用法（可以看看反编译之后的代码），也就是说上面的 foreach 与下面的代码等价:
//上面的for(Integer i : Arrays.asList(1,2,3))相当于下面的这个语句，每次返回的都是一个新的((Integer)iterator.next()).intValue()值，所以不会报错
for (Iterator i = Arrays.asList(1,2,3).iterator(); i.hasNext();) {
Stream.of(array).map(item -> item+((Integer)iterator.next()).intValue()+'@').forEach(System.out::println);
}
lsit.iterator() 返回的迭代器对象是什么呢？查看JDK源码知道，ArrayList 类继承于 AbstractList 类，AbstracList 对 iterator 方法实现如下（ArrayList 类并没有重写该方法）：
public Iterator iterator() {
return new Itr();
}
方法直接创建一个 Itr 对象并将其返回，Itr 类其实是 AbstractList 类的一个内部类，Itr 类实现了 Iterator 接口
lambda表达式的三个重要组成部分：
- 输入参数
- 可执行语句
- 存放外部变量的空间
Lambda眼中的this
在lambda中，this不是指向lambda表达式产生的那个SAM对象(接口实现类），而是声明它的外部对象。如下面的输出结果。
public class ATest extends TestCase {
@Test
public void testLambdaThis() {
testThis("bb",(x)-> x.equals("bb"));
}
public boolean testThis(String a, Predicate<String> p) {
//输出 testLambdaThis(functioninterface.ATest)
System.out.println(this);
return p.test(a);
}
}
//1.8以前，对于接口的使用，要么使用其实现类；要么通过匿名类调用其方法
//1.8以后，可以使用lambda表达式
public class ATest extends TestCase {
@Test
public void testFunctionInterface(){
A a=()-> System.out.println("hello B");
//实现类
SubA subA = new SubA();
print(subA);
//使用匿名类
print(new A(){
@Override
public void sayHello() {
System.out.println("use anonymous class invoke Method！");
}
});
//使用Lambda表达式
print(()-> System.out.println("use lambda invoke Method！"));
}
class SubA implements A {
@Override
public void sayHello() {
System.out.println("use implement class invoke Method！");
}
}
public void print(A a){
a.sayHello();
}
public interface A {
void sayHello();
}
}
Lmabda表达式的语法总结： () -> ();
| 前置 | 语法 |
|---|---|
| 无参数无返回值 | () -> System.out.println(“Hello WOrld”) |
| 有一个参数无返回值 | (x) -> System.out.println(x) |
| 有且只有一个参数无返回值 | x -> System.out.println(x) |
| 有多个参数，有返回值，有多条lambda体语句 | (x，y) -> {System.out.println(“xxx”);return xxxx;}； |
| 有多个参数，有返回值，只有一条lambda体语句 | (x，y) -> xxxx |
口 诀 ： 左 右 遇 一 省 括 号 ， 左 侧 推 断 类 型 省 \color{red}{口诀：左右遇一省括号，左侧推断类型省} 口诀：左右遇一省括号，左侧推断类型省
注 ： 当 一 个 接 口 中 存 在 多 个 抽 象 方 法 时 ， 如 果 使 用 l a m b d a 表 达 式 ， 并 不 能 智 能 匹 配 对 应 的 抽 象 方 法 ， 编 译 时 报 错 ， 因 此 引 入 了 函 数 式 接 口 的 概 念 \color{red}{注：当一个接口中存在多个抽象方法时，如果使用lambda表达式，并不能智能匹配对应的抽象方法，编译时报错，因此引入了函数式接口的概念} 注：当一个接口中存在多个抽象方法时，如果使用lambda表达式，并不能智能匹配对应的抽象方法，编译时报错，因此引入了函数式接口的概念
函数式接口
简单来说就是有且只定义了一个抽象方法的接口（Object类的public方法、默认方法和静态方法除外），就是函数式接口（不管是否用@FunctionInterface注解）
并且还提供了@FunctionalInterface 注解
JDB8中提供了四种函数式接口：
- Consumer 《T》：消费型接口，有参无返回值
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
//示例
public class ATest extends TestCase {
@Test
public void testConsumer() {
//输出 aa
changeStr("aa",(x)-> System.out.println(x));
}
public void changeStr(String s, Consumer<String> c) {
c.accept(s);
}
}
- Supplier 《T》：供给型接口，无参有返回值
@FunctionalInterface
public interface Supplier<T> {
T get();
}
//示例
public class ATest extends TestCase {
@Test
public void testSupplier() {
//输出 test Supplier
System.out.println(changeStr(()->"test Supplier"));
}
public String changeStr(Supplier<String> s) {
return s.get();
}
}
- Function 《T,R》：:函数式接口，有参有返回值
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
//示例
public class ATest extends TestCase {
@Test
public void testFunction() {
//输出 cc-test
System.out.println(changeStr("cc",(a)-> a+"-test"));
}
public String changeStr(String a, Function<String,String> concat) {
return concat.apply(a);
}
}
//可以自己定义多 参数的函数式接口，这里两个，相当于API提供的BiFunction
@Test
public void testFunctionInterface(){
System.out.println(print("cc","dd",(x,y)->x+"-"+y));
}
public String print(String c,String d,B b) {
return (String)b.mutliArgs(c,d);
}
public interface B<T,R> {
R mutliArgs(T t1,T t2);
}
- Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
//示例
public class ATest extends TestCase {
@Test
public void testPredicate() {
//输出 false
System.out.println(change("cc",(x)-> x.equals("pp")));
}
public boolean change(String a, Predicate<String> p) {
return p.test(a);
}
}
在四大核心函数式接口基础上，还提供了诸如BiFunction、BinaryOperator、toIntFunction等扩展的函数式接口,具体查看API，funtion包下面。
总 结 ： 函 数 式 接 口 的 提 出 是 为 了 让 我 们 更 加 方 便 的 使 用 l a m b d a 表 达 式 ， 不 需 要 自 己 再 手 动 创 建 一 个 函 数 式 接 口 ， 直 接 拿 来 用 就 好 了 \color{red}{总结：函数式接口的提出是为了让我们更加方便的使用lambda表达式，不需要自己再手动创建一个函数式接口，直接拿来用就好了} 总结：函数式接口的提出是为了让我们更加方便的使用lambda表达式，不需要自己再手动创建一个函数式接口，直接拿来用就好了
Stream API
参考： 并发编程网 - ifeve.com
我们来解读一下java8对Stream的定义：
- Stream是元素的集合，这点让Stream看起来用些类似Iterator；
- 可以支持顺序和并行的对原Stream进行汇聚的操作；
Stream的基本步骤： - 创建Stream；
- 转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换）；
- 对Stream进行聚合（Reduce）操作，获取想要的结果；
Stream的创建
public class ATest extends TestCase {
@Test
public void testCreateStreamAPI() {
// 1.通过Collection 系列集合（子类）提供的stream()或者paralleStream()
/**
接口Collection 中提供了默认的创建流的方法
public interface Collection extends Iterable {
//其他方法省略
default Spliterator spliterator() {
return Spliterators.spliterator(this, 0);
}
default Stream stream() {
return StreamSupport.stream(spliterator(), false);
}
default Stream parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
*/
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
// 2.通过Arrays的静态方法stream()获取数组流
String[] str = new String[10];
Stream<String> stream2 = Arrays.stream(str);
// 3.通过Stream类中的静态方法of
Stream<String> stream3 = Stream.of("aa","bb","cc");
// 4.生成无限长度的Stream，和generate不同的是，其元素的生成是重复对给定的种子值(seed)调用用户指定函数来生成的 其中包含的元素可以认为是：seed，f(seed),f(f(seed))无限循环
//todo **千万记住使用limit方法，不然会无限打印下去
// 迭代 [0, 2, 4, 6, 8]
Stream<Integer> stream4 = Stream.iterate(0,(x) -> x+2).limit(5);
System.out.println(stream4.collect(Collectors.toList()));
Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);
//5.生成无限流 配合limit使用，否则会无限的循环下去
//生成一个无限长度的Stream，其元素的生成是通过给定的Supplier（这个接口可以看成一个对象的工厂，每次调用返回一个给定类型的对象）
//[0.844569815040083, 0.5762564341489728, 0.8560375271269798, 0.7784646353142339, 0.9721212121201329]
Stream<Double> stream5 = Stream.generate(new Supplier<Double>() {
@Override
public Double get() {
return Math.random();
}
}).limit(5);
Stream<Double> stream5 = Stream.generate(() -> Math.random()).limit(5);
Stream<Double> stream5 = Stream.generate(Math::random).limit(5);
System.out.println(stream5.collect(Collectors.toList()));
}
}
转换stream
链接： 并发编程网 - ifeve.com
转换Stream其实就是把一个Stream通过某些行为转换成一个新的Stream。Stream接口中定义了几个常用的转换方法，下面我们挑选几个常用的转换:
转换Stream其实就是把一个Stream通过某些行为转换成一个新的Stream。Stream接口中定义了几个常用的转换方法，下面我们挑选几个常用的转换方法来解释。
-
distinct: 对于Stream中包含的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有重复的元素；
-
filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素；
filter方法示意图：
-
map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。这个方法有三个对于原始类型的变种方法，分别是：mapToInt，mapToLong和mapToDouble。这三个方法也比较好理解，比如mapToInt就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗；
map方法示意图：
-
flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；
flatMap方法示意图：
-
peek: 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；
peek方法示意图：
-
limit: 对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；
limit方法示意图：
-
skip: 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；
skip方法示意图：
-
在一起,在一起！
public class ATest extends TestCase {
@Test
public void testOperateStreamAPI(){
List<Integer> nums = Arrays.asList(1,1,null,2,3,4,null,5,6,7,8,9,10);
int sum = nums.stream() //创建流
.filter(num -> num != null) //过滤掉为null 的数据 1 1 2 3 4 5 6 7 8 9 10
.distinct() //去重 1 2 3 4 5 6 7 8 9 10
.peek(System.out::print)
.mapToInt(num -> num * 2) //按照 num*2 处理后的数据，形成一个新的Stream 2 4 6 8 10 12 14 16 18 20
.peek(System.out::println) //调用消费函数 2 4 6 8 10 12 流中数据按照顺序一个一个的消费打印
.skip(2) //跳过两个数 6 8 10 12 14 16 18 20
.limit(4) //只取前4个数据 6 8 10 12
.sum(); //聚合函数求和结束流操作 36
System.out.println("sum is:"+sum);
}
}
这段代码演示了上面介绍的所有转换方法（除了flatMap），简单解释一下这段代码的含义：给定一个Integer类型的List，获取其对应的Stream对象，然后进行过滤掉null，再去重，再每个元素乘以2，再每个元素被消费的时候打印自身，在跳过前两个元素，最后取前四个元素进行加和运算(解释一大堆，很像废话，因为基本看了方法名就知道要做什么了。这个就是声明式编程的一大好处！)。大家可以参考上面对于每个方法的解释，看看最终的输出是什么。
-
性能问题
有些细心的同学可能会有这样的疑问：在对于一个Stream进行多次转换操作，每次都对Stream的每个元素进行转换，而且是执行多次，这样时间复杂度就是一个for循环里把所有操作都做掉的N（转换的次数）倍啊。其实不是这样的，转换操作都是lazy的，多个转换操作只会在汇聚操作（见下节）的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在汇聚操作的时候循环Stream对应的集合，然后对每个元素执行所有的函数。
汇聚（Reduce）Stream
- 可变汇聚
可变汇聚对应的只有一个方法：collect，正如其名字显示的，它可以把Stream中的要有元素收集到一个结果容器中（比如Collection）。先看一下最通用的collect方法的定义（还有其他override方法）：
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
先来看看这三个参数的含义：
Supplier supplier是一个工厂函数，用来生成一个新的容器；
BiConsumer accumulator也是一个函数，用来把Stream中的元素添加到结果容器中；BiConsumer combiner还是一个函数，用来把中间状态的多个结果容器合并成为一个（并发的时候会用到）。
List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null).
collect(() -> new ArrayList<Integer>(),
(list, item) -> list.add(item),
(list1, list2) -> list1.addAll(list2));
上面这段代码就是对一个元素是Integer类型的List，先过滤掉全部的null，然后把剩下的元素收集到一个新的List中。进一步看一下collect方法的三个参数，都是lambda形式的函数（上面的代码可以使用方法引用来简化，留给读者自己去思考）。
- 第一个函数生成一个新的ArrayList实例；
- 第二个函数接受两个参数，第一个是前面生成的ArrayList对象，二个是stream中包含的元素，函数体就是把stream中的元素加入ArrayList对象中。第二个函数被反复调用直到原stream的元素被消费完毕；
- 第三个函数也是接受两个参数，这两个都是ArrayList类型的，函数体就是把第二个ArrayList全部加入到第一个中；
collect方法另外一个override的版本，其依赖[Collector]，简洁版
<R, A> R collect(Collector<? super T, A, R> collector);
这样清爽多了！少年，还有好消息，Java8还给我们提供了Collector的工具类–Collectors，其中已经定义了一些静态工厂方法，比如：Collectors.toCollection()收集到Collection中, Collectors.toList()收集到List中和Collectors.toSet()收集到Set中。这样的静态方法还有很多，这里就不一一介绍了，大家可以直接去看JavaDoc。下面看看使用Collectors对于代码的简化：
List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null).
collect(Collectors.toList());
- 其他汇聚
– reduce方法：reduce方法非常的通用，后面介绍的count，sum等都可以使用其实现。reduce方法有三个override的方法，本文介绍两个最常用的，最后一个留给读者自己学习。先来看reduce方法的第一种形式，其方法定义如下：
Optional<T> reduce(BinaryOperator<T> accumulator);
接受一个BinaryOperator类型的参数，在使用的时候我们可以用lambda表达式来。
List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println("ints sum is:" + ints.stream().reduce((sum, item)->sum + item).get());
可以看到reduce方法接受一个函数，这个函数有两个参数，第一个参数是上次函数执行的返回值（也称为中间结果），第二个参数是stream中的元素，这个函数把这两个值相加，得到的和会被赋值给下次执行这个函数的第一个参数。要注意的是：第一次执行的时候第一个参数的值是Stream的第一个元素，第二个参数是Stream的第二个元素。这个方法返回值类型是Optional，这是Java8防止出现NPE的一种可行方法，后面的文章会详细介绍，这里就简单的认为是一个容器，其中可能会包含0个或者1个对象。
这个过程可视化的结果如图：
reduce方法还有一个很常用的变种：
T reduce(T identity, BinaryOperator<T> accumulator);
这个定义上上面已经介绍过的基本一致，不同的是：它允许用户提供一个循环计算的初始值，如果Stream为空，就直接返回该值。而且这个方法不会返回Optional，因为其不会出现null值。下面直接给出例子，就不再做说明了。
List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println("ints sum is:" + ints.stream().reduce(0, (sum, item) -> sum + item));
– count方法：获取Stream中元素的个数。比较简单，这里就直接给出例子，不做解释了。
List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println("ints sum is:" + ints.stream().count());
– 搜索相关
– allMatch：是不是Stream中的所有元素都满足给定的匹配条件
– anyMatch：Stream中是否存在任何一个元素满足匹配条件
– findFirst: 返回Stream中的第一个元素，如果Stream为空，返回空Optional
– noneMatch：是不是Stream中的所有元素都不满足给定的匹配条件
– max和min：使用给定的比较器（Comparator），返回Stream中的最大|最小值,返回Optional
下面给出allMatch和max的例子，剩下的方法读者当成练习。
List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println(ints.stream().allMatch(item -> item < 100));
ints.stream().max((o1, o2) -> o1.compareTo(o2)).ifPresent(System.out::println);
接口的新增 默认方法和静态方法
public interface NewInterface {
//变量 默认是 pubic static final修饰
String variable = "常量";
//默认方法，所有实现该接口的类，默认都继承该方法
default void hello() {
System.out.println("hello");
}
//静态方法，只能通过接口名访问 interfaceName.staticMethod()
static void staticMethod(){
System.out.println("static method");
}
//有时候，接口定义了很多方法，但是有些方法是大多数实现类都不会用到，如果没有默认方法，那么所有实现类都需要去重写这个方法，有了默认方法后，就可以只在接口中写一个默认方法，在需要该方法的实现类中重写这个方法就可以了。 比如：Iterator接口的remove方法
default void remove() {
throw new UnsupportedOperationException();
}
}
解决默认方法冲突的规则
Java语言中一个类只能继承一个父类，但是一个类可以实现多个接口。随着默认方法在Java 8中引入，有可能出现一个类继承了多个方法而它们使用的却是同样的函数签名。这种情况下，类会选择使用哪一个函数？在实际情况中，像这样的冲突可能极少发生，但是一旦发生这样的状况，必须要有一套规则来确定按照什么样的约定处理这些冲突。
解决问题的三条规则
如果一个类使用相同的函数签名从多个地方（比如另一个类或接口）继承了方法，通过三条规则可以进行判断。
- 首先，类或父类中显式声明的方法，其优先级高于所有的默认方法。
- 如果用第一条无法判断，方法签名又没有区别，那么选择提供最具体实现的默认方法的接口。
- 最后，如果冲突依旧无法解决，你就只能在你的类中覆盖该默认方法，显式地指定在你的类中使用哪一个接口中的方法。
public interface A {
default void hello() {
System.out.println("hello A");
}
}
public interface B extends A {
default void hello() {
System.out.println("hello B");
}
}
public class D implements A {
default void hello() {
System.out.println("hello D");
}
}
public class C extends D implements A , B {
public static void main(String[] args) {
//按照上面的第一条规则，如果D 重写了接口A的默认方法打印 hello D
//如果D不重写接口A的默认方法，第一条不满足，按照第二条，因为B继承A，故B比A更具体，所以打印 hello B
new C().hello();
}
}
- 如果B 不继承A
public interface B {
default void hello() {
System.out.println("hello B");
}
}
//从编译器的角度看没有哪一个接口的实现更加具体，两个都差不多。A接口和B接口的hello方法都是有效的选项。所以，Java编译器这时就会抛出一个编译错误，因为它无法判断哪一个方法更合适：“ Error: class C inherits unrelated defaults for hello() from types B and A.”。 这个时候就必须要重写 默认的方法。
//解决这种两个可能的有效方法之间的冲突，没有太多方案；你只能显式地决定你希望在C中使用哪一个方法。为了达到这个这个目的，你可以覆盖类C中的hello方法，在它的方法体内显式地调用你希望调用的方法。Java 8中引入了一种新的语法X.super.m(…)，其中X是你希望调用的m方法所在的父接口。举例来说，如果你希望C使用来自于B的默认方法，它的调用方式看起来就如下所示：
public class C implements B, A {
void hello(){
B.super.hello(); //显式地选择调用接口B中的方法
}
}
新的日期时间 API
具体参考：PostTruth-java8----新的日期时间API
更详细信息请前往：Java 8 特性 – 终极手册