什么是默认方法

Java 8引入了新的语言特性------默认方法(Default Methods)

默认方法允许您添加新的功能到现有的库的接口中,并能确保与采用旧版本的接口编写的代码的二进制兼容性.
默认方法是在接口中的方法签名前加上 default 关键字的实现方法.
默认方法就是可以在接口中定义一个已实现方法,且该接口的实现类不需要实现该方法;

    interface GreetingService  
    {
        void sayMessage(String message);
        
        //可以在接口中定义默认方法
        default void sayHello(){
            System.out.println("Hello");
        }
    }
    
    //实现类不需要实现接口中的默认方法
    class GreetingServiceImpl implements GreetingService{
        @Override
        public void sayMessage(String message)
        {

        }
    }

为什么使用默认方法

主要目的是方便扩展已有接口:如果没有默认方法,给某个接口添加一个新的抽象方法,那么实现了该接口的所有类都要修改,影响非常大.
使用默认方法,可以给已有的接口添加新方法,而不用修改接口的实现类.当然,接口中新添加的默认方法,所有的实现类也会继承该方法.
简单示例:

    interface InterfaceA {
        default void foo() {
            System.out.println("InterfaceA foo");
        }
    }
     
    class ClassA implements InterfaceA {
    }
     
    public class Test {
        public static void main(String[] args) {
            new ClassA().foo(); // 打印：“InterfaceA foo”
        }
    }

ClassA 类没有实现IngerfaceA接口中的 foo 方法,但是InterfaceA 接口中提供了foo方法的默认实现,因此可以直接调用.

默认方法的继承

和其他方法一样,接口默认方法也可以被继承.

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();
    }
}

接口默认方法的继承有上边三种情况:

不覆写默认方法,直接从父接口中获取方法的默认实现.
覆写默认方法,这和类与类之间的覆写类似.
覆写默认方法,并将它重新声明为抽象方法,新接口的子类必须再次覆写并实现这个抽象方法.

接口继承行为发生冲突时的解决规则

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();
    }
}

当 ClassA 类多实现 InterfaceA 接口和 InterfaceB 接口时，不会出现方法名歧义的错误。当 ClassB 类覆写 foo 方法时，无法通过 InterfaceA.super.foo(); 调用 InterfaceA 接口的 foo方法。

因为 InterfaceB 接口继承了 InterfaceA 接口，那么 InterfaceB 接口一定包含了所有 InterfaceA 接口中的字段方法，因此一个同时实现了 InterfaceA 接口和 InterfaceB 接口的类与一个只实现了 InterfaceB 接口的类完全等价。

这很好理解，就相当于 class SimpleDateFormat extends DateFormat 与 class SimpleDateFormat extends DateFormat, Object 等价（如果允许多继承）。

换种方式理解:

class ClassC {
    public void foo() {
        System.out.println("ClassC foo");
    }
}
 
class ClassD extends ClassC {
    @Override
    public void foo() {
        System.out.println("ClassD foo");
    }
}
 
public class Test {
    public static void main(String[] args) {
        ClassC classC = new ClassD();
        classC.foo(); // 打印：“ClassD foo”
    }
}

这里的 classC.foo(); 同样调用的是 ClassD 类中的 foo 方法，打印结果为“ClassD foo”，因为 ClassC 类中的 foo 方法在 ClassD 类中被覆写了。

在上面的 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();
    }
}

接口与抽象类

当接口继承行为发生冲突时另一个规则是,类的方法声明优先于接口默认方法，无论该方法是具体的还是抽象的。

interface InterfaceA {
    default void foo() {
        System.out.println("InterfaceA foo");
    }
 
    default void bar() {
        System.out.println("InterfaceA bar");
    }
}
 
abstract class AbstractClassA {
    public abstract void foo();
 
    public void bar() {
        System.out.println("AbstractClassA bar");
    }
}
 
class ClassA extends AbstractClassA implements InterfaceA {
    @Override
    public void foo() {
        InterfaceA.super.foo();
    }
}
 
public class Test {
    public static void main(String[] args) {
        ClassA classA = new ClassA();
        classA.foo(); // 打印：“InterfaceA foo”
        classA.bar(); // 打印：“AbstractClassA bar”
    }
}

ClassA 类中并不需要手动覆写 bar 方法，因为优先考虑到 ClassA 类继承了的 AbstractClassA抽象类中存在对 bar 方法的实现，同样的因为 AbstractClassA 抽象类中的 foo 方法是抽象的，所以在 ClassA 类中必须实现 foo 方法。

接口静态方法

interface InterfaceA {
    default void foo() {
        printHelloWorld();
    }
    
    static void printHelloWorld() {
        System.out.println("hello, world");
    }
}
 
public class Test {
    public static void main(String[] args) {
        InterfaceA.printHelloWorld(); // 打印：“hello, world”
    }
}

转:https://blog.csdn.net/u010003835/article/details/76850242

java 8新特性学习系列(2):默认方法