默认方法的由来
我们都知道在java8新特性中对于接口也加入了一个新的改动，那就是默认方法了，那为什么要加入这个新的变动呢？这是因为在java8的设计中，加入了Lambda表达式和函数式接口，包括stream、parallelStream等这些集合类的方法，这个在java8之前都是不存在的，它实现的Collection<T>接口也没有，这是因为一开始的设计也没考虑这些方法。如果要重写的，那改动将会非常大：因为给接口加入一个新的实现方法，那么所有实现他的类都要提供一个实现，这很难控制。
为了规避上面那么改动带来的问题，于是接口提供了一个默认方法，由他自己来进行默认实现，而不是由实现类来提供。这样做的好处式给设计者提供了一个扩充接口的方式，而不会破坏现有的代码。在java8中实现，使用default关键字来表示默认方法。
默认方法是什么
默认方法就是接口里面可以有实现的方法，并且不需要实现类去实现其方法。并且默认方法允许你添加新的方法到现在的接口中，并且确保与旧版本的兼容性。实现方式就是在接口签名前面加入default关键字的方法就是默认方法了。
实现类可以自动继承接口的默认方法，并且不用实现默认方法，就可以直接调用。同时默认方法也可以重写。
实现实例代码
实例一
// 接口
public interface Test {
default void sout() {
System.out.println("调用Test里面的默认方法！");
}
}
// 实现类自动继承接口的默认方法，并且不用实现默认方法，就可以直接调用
public class TestDefaultMethod{
public static void main(String[] args) {
test1 test1 = new test1();
test1.sout();
}
}
class test1 implements Test{
}
示例二: 可以重写
class test1 implements Test{
@Override
public void sout() {
System.out.println("默认方法也可以继承！");
}
}
示例三实现多个接口的时候，且有相同方法的调用问题的解决
public class TestDefaultMethod {
public static void main(String[] args) {
IntTest test = new test();
test.sout();
}
}
interface IntTest {
default void sout() {
System.out.println("调用Test里面的默认方法！");
}
// 接口可以声明静态方法 并且有实现类。
static void syso() {
System.out.println("调用Test里面的静态方法！");
}
}
interface IntTest2 {
default void sout() {
System.out.println("调用Test2里面的默认方法！");
}
}
class test implements IntTest, IntTest2 {
public void sout() {
IntTest2.super.sout();
IntTest.super.sout();
IntTest.syso();
System.out.println("本方法里面的输出！");
}
}
可以看一下，这里面有两个接口，并且两个接口中都有sout方法，然后test把两个都实现了，但是如果只调用一个方法，会报错，所以想要调用接口里面的默认方法就可以用接口名.super.方法名。用这个方法不会出现冲突。
并且上面还有一个新特性，接口可以声明静态方法 并且有实现类。
默认方法的继承
和其他方法一样，默认方法也可以被继承的，接口默认方法的继承分三种情况（分别对应下面的 InterfaceB 接口、InterfaceC 接口和 InterfaceD 接口）：
不覆写默认方法，直接从父接口中获取方法的默认实现。
覆写默认方法，这跟类与类之间的覆写规则相类似。
覆写默认方法并将它重新声明为抽象方法，这样新接口的子类必须再次覆写并实现这个抽象方法。
interface InterfaceA {
default void foo() {
System.out.println("InterfaceA foo");
}
}
interface InterfaceB extends InterfaceA {
}
interface InterfaceC extends InterfaceA {
@Override
default void foo() {
System.out.println("InterfaceC foo");
}
}
interface InterfaceD extends InterfaceA {
@Override
void foo();
}
public class Test {
public static void main(String[] args) {
new InterfaceB() {}.foo(); // 打印：“InterfaceA foo”
new InterfaceC() {}.foo(); // 打印：“InterfaceC foo”
new InterfaceD() {
@Override
public void foo() {
System.out.println("InterfaceD foo");
}
}.foo(); // 打印：“InterfaceD foo”
// 或者使用 lambda 表达式
((InterfaceD) () -> System.out.println("InterfaceD foo")).foo();
}
}
接口继承行为发生冲突时的解决规则
Java 使用的是单继承、多实现的机制，为的是避免多继承带来的调用歧义的问题。当接口的子类同时拥有具有相同签名的方法时，就需要考虑一种解决冲突的方案。
如下所示：
interface InterfaceA {
default void foo() {
System.out.println("InterfaceA foo");
}
}
interface InterfaceB {
default void bar() {
System.out.println("InterfaceB bar");
}
}
interface InterfaceC {
default void foo() {
System.out.println("InterfaceC foo");
}
default void bar() {
System.out.println("InterfaceC bar");
}
}
class ClassA implements InterfaceA, InterfaceB {
}
// 错误
//class ClassB implements InterfaceB, InterfaceC {
//}
// 正确的解决方式
/**
在 ClassB 类中，它实现的 InterfaceB 接口和 InterfaceC 接口中都存在相同签名的 foo 方法，需要手动解决冲突。覆写存在歧义的方法，并可以使用 InterfaceName.super.methodName(); 的方式手动调用需要的接口默认方法。
*/
class ClassB implements InterfaceB, InterfaceC {
@Override
public void bar() {
InterfaceB.super.bar(); // 调用 InterfaceB 的 bar 方法
InterfaceC.super.bar(); // 调用 InterfaceC 的 bar 方法
System.out.println("ClassB bar"); // 做其他的事
}
}
还有一种冲突注意情况，看下面代码：
interface InterfaceA {
default void foo() {
System.out.println("InterfaceA foo");
}
}
interface InterfaceB extends InterfaceA {
@Override
default void foo() {
System.out.println("InterfaceB foo");
}
}
// 正确
class ClassA implements InterfaceA, InterfaceB {
}
class ClassB implements InterfaceA, InterfaceB {
@Override
public void foo() {
// InterfaceA.super.foo(); // 错误
InterfaceB.super.foo();
}
}
当 ClassB 类覆写 foo 方法时，无法通过 InterfaceA.super.foo(); 调用 InterfaceA 接口的 foo 方法。因为 InterfaceB 接口继承了 InterfaceA 接口，那么 InterfaceB 接口一定包含了所有 InterfaceA 接口中的字段方法，因此一个同时实现了 InterfaceA 接口和 InterfaceB 接口的类与一个只实现了 InterfaceB 接口的类完全等价。
在上面的 ClassA 类中不会出现方法名歧义的原因是所谓“存在歧义”的方法其实都来自于 InterfaceA 接口，InterfaceB 接口中的“同名方法”只是继承自 InterfaceA 接口而来并对其进行了覆写。ClassA 类实现的两个接口不是两个毫不相干的接口，因此不存在同名歧义方法。
而覆写意味着对父类方法的屏蔽，这也是 Override 的设计意图之一。因此在实现了 InterfaceB 接口的类中无法访问已被覆写的 InterfaceA 接口中的 foo 方法。
这是当接口继承行为发生冲突时的规则之一，即 被其它类型所覆盖的方法会被忽略。
如果想要调用 InterfaceA 接口中的 foo 方法，只能通过自定义一个新的接口同样继承 InterfaceA 接口并显示地覆写 foo方法，在方法中使用 InterfaceA.super.foo(); 调用 InterfaceA 接口的 foo 方法，最后让实现类同时实现 InterfaceB接口和自定义的新接口，代码如下：
interface InterfaceA {
default void foo() {
System.out.println("InterfaceA foo");
}
}
interface InterfaceB extends InterfaceA {
@Override
default void foo() {
System.out.println("InterfaceB foo");
}
}
interface InterfaceC extends InterfaceA {
@Override
default void foo() {
InterfaceA.super.foo();
}
}
class ClassA implements InterfaceB, InterfaceC {
@Override
public void foo() {
InterfaceB.super.foo();
InterfaceC.super.foo();
}
}
注意！ 虽然 InterfaceC 接口的 foo 方法只是调用了一下父接口的默认实现方法，但是这个覆写 不能省略，否则 InterfaceC 接口中继承自 InterfaceA 接口的隐式的 foo 方法同样会被认为是被 InterfaceB 接口覆写了而被屏蔽，会导致调用 InterfaceC.super.foo() 时出错。
通过这个例子，应该注意到在使用一个默认方法前，一定要考虑它是否真的需要。因为 默认方法会带给程序歧义，并且在复杂的继承体系中容易产生编译错误。滥用默认方法可能给代码带来意想不到、莫名其妙的错误。
接口与抽象类
接口继承行为发生冲突时的另一个规则是，类的方法声明优先于接口默认方法，无论该方法是具体的还是抽象的。
其他注意点
default 关键字只能在接口中使用（以及用在 switch 语句的 default 分支），不能用在抽象类中。
接口默认方法不能覆写 Object 类的 equals、hashCode 和 toString 方法。
接口中的静态方法必须是 public 的，public 修饰符可以省略，static 修饰符不能省略。
即使使用了 java 8 的环境，一些 IDE 仍然可能在一些代码的实时编译提示时出现异常的提示（例如无法发现 java 8 的语法错误），因此不要过度依赖 IDE。
[]https://www.cnblogs.com/sidesky/p/9287710.html
https://www.cnblogs.com/xdtg/p/11982644.html
《java 8实战
