java8接口中的默认方法

java8接口中的默认方法

概述默认方法

java8中可以在接口中定义一个default修饰的方法,例如:

public interface Sized{
    int size();
    default boolean isEmpty(){
        return size() == 0;
    }
}

这样任何一个实现了Sized接口的类都会自动继承isEmpty的实现

java 8中的抽象类和抽象接口
一个类智能继承一个抽象类,但是一个类可以实现多个接口
一个抽象类可以通过实例变量保存一个通用状态,而接口是不能有实例变量的

默认方法的使用模式

可选方法

很有可能有一种情况就是,类实现了接口,不过却刻意地将一些方法的实现留白.例如Iterator接口定义了hasNext.next,还定义了remove方法.java8之前,由于用户通常不会使用该方法,remove方法常被忽略.因此,实现Interator接口的类通常会为remove方法方之一个空的实现

在java8中,Iterator接口就为remove方法提供了一个默认实现,如下所示:

interface Iterator<T>{
    boolean hasNext();
    T next();
    default void remove(){
        throw new UnsupportedOerationException();
    }
}

行为的多继承

这是一种让类从多个来源重用代码的能力

interface Rotatable{
    void setRotationAngel(int angleInDegrees);

    int getRotationAngle();

    default void rotateBy(int angleInDegrees) {
        setRotationAngel((getRotationAngle() + angleInDegrees) % 360);
    }
}

interface Resizable {
    int getWidth();

    int getHeight();

    void setWidth(int width);

    void setHeight(int height);

    void setAbsoluteSize(int width, int height);

    default void setRelativeSize(int wFactor, int hFactor) {
        setAbsoluteSize(getWidth() / wFactor, getHeight() / hFactor);
    }
}


interface Moveable {
    int getX();

    int getY();

    void setX(int x);

    void setY(int y);

    default void moveHorizontally(int distance) {
        setX(getX() + distance);
    }

    default void moveVertically(int distance) {
        setY(getY() + distance);
    }
}

class Monster implements Rotatable, Moveable, Resizable {
    .....
}

 public static void main(String[] args) {
        //现在可以直接调用不同的方法:
        Monster m = new Monster();
        m.rotateBy(180);
        m.moveHorizontally(10);

 }

解决冲突的原则

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

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

class C  implements B, A {
    public static void main(String[] args) {
        new C().hello();//打印B
    }
}

三条原则:

1.类中的方法优先级最高

2.如果无法一句第一条进行判断,那么子接口的优先级更高:函数签名相同时,优先选择拥有最具体实现的默认方法的接口,即如果B继承了A,那么B就比A更加具体

3.最后,如果还是无法判断,继承了多个接口的类必须通过显示覆盖和调用期望的方法,显示地选择使用哪一个默认方法的实现