接口的多继承和多态的实现

接口的多继承

• 接口是没有静态代码块或者构造方法的。
• 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

格式：
public class MyInterfaceImple implement MyInterfaceA,MyInterfaceB {
//覆盖抽象方法
}

• 如果实现类所实现的多个接口中存在重复的抽象方法，只需要覆盖一次就行，他们的要求是一样的、
• 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
• 多个接口当中的默认方法如果重复。那么实现类和子接口必须进行默认方法的覆盖重写，并带着default关键字。
• 一个类直接父类中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口MyInterfaceA

public interface MyinterfaceA {
    //错误写法，接口不能有静态代码块
//    static {
//
//    }
    //接口不能有构造方法
    public abstract  void methodA();
    public abstract  void method();

    public default  void methodDefault() {
        System.out.println("默认方法AAA");
    }
}

接口MyInterfaceB

public interface MyinterfaceB {

    public abstract  void methodB();

    public abstract  void method();

    public default void methodDefault() {
        System.out.println("默认方法BBB");
    }
}

接口的实现类MyInterfaceImple

public class MyInterfaceImple implements  MyinterfaceA ,MyinterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

    //对继承的多个接口的冲突方法只需要覆盖重写一次。
    @Override
    public void method() {
        System.out.println("覆盖重写A,B相同的方法。");
    }

    //对多个接口中的重名的默认方法进行覆盖重写
    @Override
    public void methodDefault() {

    }
}

子接口MyInterface,继承了接口MyInterfaceA和接口MyInterfaceB

public interface MyInterface extends MyInterfaceA,MyInterfaceB {

    @Override
    default void methodDefault() {

    }
}

抽象类MyAbstractImple,实现了接口MyInterfaceA和接口MyInterfaceB

//如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
public abstract MyAbstractImple implements MyInterfaceA,MyInterfaceB {

    @Override
    default void methodDefault() {

    }
}

多态性

代码中体现多态性，就一句话。父类引用指向子类对象。
父类名称 对象名 = new 子类名称（）；
或者：
接口名称 对象名 = new 实现类名称（）；

父类

public class Father {
    int num = 20;
    public void method() {

        System.out.println("父类方法");
    }
    public  void methodFather() {

        System.out.println("父类特有方法！");
    }
}

子类

public class Son extends  Father{

    int num = 10;
    int age =10;
    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodSon() {

        System.out.println("子类特有方法");
    }
}

    public static void main(String[] args) {
        //使用多态的写法
        //左侧父类引用，指向右侧子类的对象
        Father father = new Son();
        father.method();//优先使用子类中覆盖的方法。
        father.methodFather();
        System.out.println("---------我是分割线-------");
        Son son = new Son();
        son.methodFather();
    }
}

结果：
子类方法
父类特有方法！
---------我是分割线-------
父类特有方法！

多态性注意事项

访问成员变量的两种方式：

• 直接通过对象名称访问,看等号左边是谁，优先用谁，没有向上找，不会向下查找。
• 间接通过成员方法访问,看该方法属于谁，优先用谁，没有向上找,不会向下查找。

口诀：编译看左边，运行看右边

成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

public class Father {
    int num = 10;

    public  void showNum() {
        System.out.println(num);
    }   
}

public class Son extends Father{
    int num = 20;

    int age =16;

    @Override
    public void showNum() {
        System.out.println(num);
    }
}

    public static void main(String[] args) {
        //使用多态写法，父类引用指向子类对象
        Father father = new Son();
        System.out.println(father.num);
//        System.out.println(father.age);//错误写法

        System.out.println("---------我是分割线--------");
        father.showNum();
        //子类没有覆盖重写，就是父类的方法，10
        //子类如果覆盖重写，就是子类的方法，20

    }
}