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

最新推荐文章于 2025-07-13 12:06:41 发布

小青蛙哎呀

最新推荐文章于 2025-07-13 12:06:41 发布

阅读量1.7k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： java java基础入门文章标签： java 继承多态性

本文链接：https://blog.youkuaiyun.com/green703338130/article/details/81028819

java 同时被 2 个专栏收录

24 篇文章

订阅专栏

java基础入门

17 篇文章

订阅专栏

本文探讨了Java接口的多实现特性，强调一个类可以同时实现多个接口，而接口之间可以多继承。此外，文章还详细介绍了多态性的概念，包括如何在代码中体现多态性以及多态性注意事项，如访问成员变量的规则：编译看左边，运行看右边。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

接口的多实现

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

格式：

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 class Demo01Multi {

    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 class Demo01Multi {

    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



    }

}