一块儿来学Java8（五）——接口默认方法

Java8新加入一个特性，容许在接口方法中给定一个默认实现。前提是在方法前面加一个default关键字。

public interface InterfaceMethod {
	default void say() {
		System.out.println("hello");
	}
	
	default int getAge() {
		return 1;
	}
}

这种设计看起来是有点违背接口设计原则的，由于当初规定接口中的全部方法都是抽象方法，须要子类去实现它。

可是在Java8中不得不打破这种规则，Java设计者们也有苦衷，考虑到这样一种状况，若是要在接口中新增一个方法，那么以前已经实现它的那些类必然要实现新增的方法。若是接口实现类比较多的话那改起来会很是痛苦，这种牵一发而动全身的行为显然是不可取的。

因而Java8就有了接口默认方法这个特性，如此一来在接口中新增一个默认方法，对于其下面的实现类是无感知的。

Java系统中的接口默认方法很是多，好比一些函数式接口和集合接口就有定义它的默认方法，常见的有如下几个

• java.util.function.Predicate.and(Predicate<? super T>)
• java.util.function.Function.compose(Function<? super V, ? extends T>)
• java.util.Collection.stream()

接口实现

接口中已经有默认方法后，其实现类不用实现这个默认方法

interface MyInterface {
	default void say() {
		System.out.println("hello");
	}
}

public class MyClass implements MyInterface {

}

固然也能够覆盖重写这个默认方法

public class MyClass implements MyInterface {
	@Override
	public void say() {
		System.out.println("goodbye");
	}
}

若是要在覆盖的方法中调用原来的默认方法，格式以下：

接口名字.super.方法名

如：MyInterface.super.say();

public class MyClass implements MyInterface {
	@Override
	public void say() {
		System.out.println("goodbye");
		// 调用默认方法
		MyInterface.super.say();
	}
	
	public static void main(String[] args) {
		new MyClass().say();
	}
}

多重继承问题

并列多继承

有了接口默认方法这个新特性后，会带来一些新的问题，假如两个接口A,B都有一个统一的默认方法 void say()，若是一个类同时实现这两个接口会发生什么状况呢。

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	default void say() {
		System.out.println("B");
	}
}

static class MyClass implements A,B {
    
}

很显然这种状况是不容许的，编译会报错。

若是把接口B的方法改成抽象方法，会发生什么状况呢

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	void say();
}

static class MyClass implements A, B {

}

这个编译也是会报错的，提示须要实现接口B中的方法

static class MyClass implements A, B {
    // 实现B
	@Override
	public void say() {
		System.out.println("myclass");
	}
}

这个时候若是调用say方法会调用MyClass中的实现方法

new MyClass().say(); 输出myclass，若是想要调用接口A中默认方法，则能够这样写：

static class MyClass implements A, B {
	@Override
	public void say() {
		// 调用A接口中的默认方法
		A.super.say();
		System.out.println("myclass");
	}
	
	public static void main(String[] args) {
		new MyClass().say();
	}
}

间接多继承

在上面的例子中，若是把接口B改为继承接口A，而后调用say方法会打印什么内容呢？

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B extends A {
	default void say() {
		System.out.println("B");
	}
}

static class MyClass implements A, B {
	public static void main(String[] args) {
		new MyClass().say();
	}
}

输出B

为何是B而不是A呢，这里Java列出三条规则，在遇到这种方法冲突的状况下，可参考这三条规则

1. 类中的方法优先级最高
2. 子接口的优先级最高，优先选择有具体实现的默认方法接口。
3. 显示覆盖并调用指定接口的默认方法。

在上面的例子中，经过规则2能够看到，B继承了A，那么B中的方法优先级最高，所以打印B。

那么第三条规则是什么意思呢，回到一开始提到的例子，并列继承

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	default void say() {
		System.out.println("B");
	}
}

static class MyClass implements A, B {

}

这里编译报错，解决方式为重写say方法，并指定调用哪一个接口中的默认方法：

static class MyClass implements A, B {
	@Override
	public void say() {
		A.super.say();
	}
}

菱形继承

菱形继承是C++中遇到的一个问题，C++支持多重继承，可是会存在一个问题。

有一个类A，A中有个say方法，B继承A，C继承A，而后MyClass继承了B和C，以下表示

A
 ╱    ╲   
B       C
 ╲    ╱
 MyClass

继承图很像一个菱形，此时在若是调用myClass.say()在C++下会报request for member 'say' is ambiguous错误。

那么在Java8下会是怎样的状况呢？一块儿来看下面的代码：

public class RhombusTest {

    interface A {
        default void say() {
            System.out.println("A");
        }
    }

    interface B extends A {}
    interface C extends A {}

    static class MyClass implements B,C {}

    public static void main(String[] args) {
        new MyClass().say();
    }
}

上面的代码会编译经过并打印A。

根据规则2:子接口的优先级最高，优先选择有具体实现的默认方法接口。B和C都拥有A的默认方法，有具体实现的默认方法在A当中，最终仍是会选择A。此时若是在B中添加一个一样的方法

interface B extends A {
    default void say() {
        System.out.println("B");
    }
}

那么根据就近原则，优先选择B。若是把B中的方法改为抽象方法，那么会编译报错，提示须要实现B中的方法，由于选择了B，可是没有具体实现。

interface B extends A {
    void say();
}

总结

本篇主要介绍了Java8中的接口默认方法，以及在多重继承的状况下Java系统的判断规则。

按期分享技术干货，一块儿学习，一块儿进步！