10 接口与多态详细介绍

最新推荐文章于 2022-07-06 19:05:01 发布
最新推荐文章于 2022-07-06 19:05:01 发布
阅读量288 收藏
点赞数
分类专栏： Java基础 文章标签： 多态 java 封装 接口 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44781238/article/details/106043792
版权

目录

接口、多态

一、接口

1. 接口概述与生活举例

  • 接口就是一种公共的规范标准。

2. 接口的定义基本格式

  • 接口就是多个类的公共规范。

  • 接口是一种引用数据类型，最重要的内容就是：抽象方法。

  • 定义接口的格式：

    public interface 接口名称{
  //接口内容
}

  • 注意：换成了关键字interface之后，编译生成的字节码文件仍然是：.java —> .class**。

  • 如果是***Java 7***，那么接口中可以包含的内容有：

    • 常量
    • 抽象方法

  • 如果是***Java 8***，还可以额外包含有：

    • 默认方法
    • 静态方法

  • 如果是***Java 9***，还可以额外包含有：

    • 私有方法

3. 接口的抽象方法定义

  • 在任何版本的Java中，接口都能定义抽象方法。

  • 格式：public abstract 返回值类型 方法名称(参数列表);

  • 注意事项：

    • 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract。
    • 这两个关键字修饰符，可以选择性省略。
    • 方法的三要素（方法名、返回值、参数），可以随意定义。
    public interface MyInterfaceAbstract {
    //以下方式定义一个抽象方法均可
    public abstract void method_1();
    abstract void method_2();
    public void method_3();
    void method_4();
}

4. 接口的抽象方法使用

  • 接口不能直接使用，必须有一个“实现类”来“实现”该接口。

    • 格式：

      public class 实现类名称 implements 接口名称{
  //...
}

  • 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

    • 实现：去掉abstract关键字，加上方法体大括号。

  • 创建实现类的对象，进行使用。

  • 注意：如果实现类并没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就必须是抽象类。

//定义接口
public interface MyInterfaceAbstract {
    //以下方式定义一个抽象方法均可
    public abstract void method_1();
    abstract void method_2();
    public void method_3();
    void method_4();
}

//实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{

    @Override
    public void method_1() {
        System.out.println("执行方法一！");
    }

    @Override
    public void method_2() {
        System.out.println("执行方法二！");
    }

    @Override
    public void method_3() {
        System.out.println("执行方法三！");
    }

    @Override
    public void method_4() {
        System.out.println("执行方法四！");
    }
}

public class Test {
    public static void main(String[] args) {
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.method_1();
        impl.method_2();
        impl.method_3();
        impl.method_4();
    }
}

5. 接口的默认方法的定义

  • 从Java 8开始，接口中允许定义默认方法。

    • 格式：

      public default 返回值类型 方法名称(参数列表){
  //方法体
}

  • 接口当中的默认方法，可以解决接口升级的问题。

6. 接口的默认方法的使用

  • 若原接口新添加抽象方法会导致其实现类发生错误，故可使用默认方法解决该问题。

  • 接口的默认方法，可以通过接口实现类对象，直接调用。

  • 接口的默认方法，也可以被接口实现类进行覆盖重写。

    //接口
public interface MyInterfaceDefault {
    //原抽象方法
    public abstract void methodAbs();
    //新添加抽象方法  导致实现类出错
    //public abstract void methodAbs2();
    //故可添加默认方法
    public default void methodDefault(){
        System.out.println("执行默认方法！");
    }
}

//实现类
public class MyInterfaceDefaultImplA implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("A执行抽象方法！");
    }
}

//实现类
public class MyInterfaceDefaultImplB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("B执行抽象方法！");
    }

    //覆盖重写默认方法
    @Override
    public void methodDefault(){
        System.out.println("B覆盖重写默认方法！");
    }
}

public class Test {
    public static void main(String[] args) {

        MyInterfaceDefaultImplA a = new MyInterfaceDefaultImplA();
        a.methodAbs(); // A执行抽象方法！
        a.methodDefault(); // 执行默认方法！

        MyInterfaceDefaultImplB b = new MyInterfaceDefaultImplB();
        b.methodAbs(); // B执行抽象方法！
        b.methodDefault(); // B覆盖重写默认方法！

    }
}

7. 接口的静态方法的定义

  • 从Java 8开始，接口当中允许定义静态方法。

  • 格式：

    public static 返回值类型 方法名称(参数列表){
  //方法体
}
    • 就是将adstarct或default换成static，再带上方法体即可。

8. 接口的静态方法的使用

  • 通过接口名称，直接调用其中的静态方法。

    • 格式：接口名.静态方法名(参数);

  • **注意：**不能通过接口实现类的对象来调用接口当中的静态方法。

    //接口
public interface MyInterfaceStatic {
    public static void method(){
        System.out.println("执行静态方法！");
    }
}
//实现类
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}

public class Test {
    public static void main(String[] args) {
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        //错误
        //impl.method();
        //正确
        MyInterfaceStatic.method(); // 执行静态方法！
    }
}

9. 接口的私有方法的定义

  • 问题描述：若需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但这个共有方法不应该让实现类使用，应该是私有化的。

  • 解决方案：

    • 从Java 9开始，接口当中允许定义私有方法。

    • **普通私有方法：**解决多个默认方法之间重复代码的问题。

      • 格式：

        private 返回值类型 方法名称(参数列表){
  //方法体
}

    • **静态私有方法：**解决多个静态方法之间重复代码的问题。

      • 格式：

        private static 返回值类型 方法名称(参数列表){
  //方法体
}

10. 接口的私有方法的使用

//普通私有方法的使用
public interface MyInterfacePrivateA {
  //默认方法
    public default void methodA(){
        System.out.println("默认方法A");
        methodCommon();
    }
  //默认方法
    public default void methodB(){
        System.out.println("默认方法B");
        methodCommon();
    }
  //普通私有方法
    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

//静态私有方法的使用
public interface MyInterfacePrivateB {
  //静态方法
    public static void methodA(){
        System.out.println("静态方法A");
        methodCommon();
    }
  //静态方法
    public static void methodB(){
        System.out.println("静态方法B");
        methodCommon();
    }
  //静态私有方法
    private static void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

11. 接口的常量定义与使用

  • 接口中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，其实就是接口的常量。
  • 格式：public static final 数据类型 常量名称 = 数据值;
  • 一旦使用final关键字进行修饰，说明不可改变。
  • 注意：
    • 接口当中的常量，可以省略public、static、final，但是不写依然是由这三个关键字进行修饰的。
    • 接口当中的常量，必须进行赋值。
    • 推荐命名规则：使用完全大写的字母，用下划线进行分隔。
//接口
public interface MyInterfaceConst {
    public static final int NUM_OF_MY_CLASS = 10;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

12. 接口的内容小结

  • 成员变量其实是常量
    • 格式：[public] [static] [final] 数据类型 数据名称 = 数值;
    • 注意：
      • 常量必须进行赋值，而且一旦赋值不能改变。
      • 常量名称完全大写，用下划线进行分隔。
  • 接口中最重要的就是抽象方法
    • 格式：[public] [abstract] 返回值类型 方法名称(参数列表);
    • 注意：实现类必须覆盖重写接口里的所有抽象方法，除非实现类是抽象类。
  • 从Java 8开始，接口里允许定义默认方法
    • 格式：[public] default 返回值类型 方法名称(参数列表) {方法体}
    • 注意：默认方法也可以被覆盖重写。
  • 从Java 8开始，接口里允许定义静态方法
    • 格式：[public] static 返回值类型 方法名称(参数列表) {方法体}
    • 注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。
  • 从Java 9开始，接口里允许定义私有方法
    • 格式：
      • 普通私有方法：private 返回值类型 方法名称(参数列表) {方法体}
      • 静态私有方法：private static 返回值类型 方法名称(参数列表) {方法体}
    • 注意：私有方法只有接口自己才能调用，不能被实现类或别人使用。

13. 继承父类并实现多个接口

  • 接口是没有静态代码块或者构造方法的。

  • 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

    • 格式：

      public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
  // 覆盖重写所有抽象方法
}

  • 如果实现类没有覆盖重写所有接口中的所有抽象方法，那么实现类就必须是抽象类。

  • 如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

  • 如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

  • 一个类的直接父类中的方法和接口中的默认方法产生了冲突，优先使用父类当中的方法。

//接口A
public interface MyInterfaceA {
    //抽象方法
    public abstract void methodA();
    //多个接口重复的抽象方法
    public abstract void method();
    //多个接口重复的默认方法
    public default void methodDefault() {
        System.out.println("接口A的默认方法！");
    }
    //与父类重复的方法
    public default void methodFuAndA(){
        System.out.println("接口A中的默认方法！");
    }
}
//接口B
public interface MyInterfaceB {
    //抽象方法
    public abstract void methodB();
    //多个接口重复的抽象方法
    public abstract void method();
    //多个接口重复的默认方法
    public default void methodDefault() {
        System.out.println("接口B的默认方法！");
    }
}
//抽象类
public abstract class MyInterfaceAbs implements MyInterfaceA, MyInterfaceB {
    @Override
    //实现A接口的methodA方法
    public void methodA(){
        System.out.println("抽象类实现A接口的methodA方法！");
    }

    @Override
    //实现B接口的methodB方法
    public void methodB(){
        System.out.println("抽象类实现B接口的methodB方法！");
    }

    @Override
    //覆盖重写多个接口相同的默认方法
    public void methodDefault(){
        System.out.println("抽象类覆盖重写多个接口相同的默认方法！");
    }
}
//实现类
public class MyInterfaceImpl extends Fu implements MyInterfaceA, MyInterfaceB {

    @Override
    public void methodA() {
        System.out.println("实现类实现接口A的methodA方法！");
    }

    @Override
    public void methodB() {
        System.out.println("实现类实现接口B的methodB方法！");
    }

    //只需实现一次多个接口重复的抽象方法
    @Override
    public void method() {
        System.out.println("实现类实现接口AB的method方法！");
    }

    @Override
    //实现类必须实现多个接口重复的默认方法
    public void methodDefault(){
        System.out.println("实现类实现多个接口重复的默认方法！");
    }
}
//父类
public class Fu {
    //与接口A重复的方法
    public void methodFuAndA(){
        System.out.println("父类中的方法！");
    }
}

public class Test {
    public static void main(String[] args) {
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.methodA(); // 实现类实现接口A的methodA方法！
        impl.methodB(); // 实现类实现接口B的methodB方法！
        impl.method();  // 实现类实现接口AB的method方法！
        impl.methodDefault(); // 实现类实现多个接口重复的默认方法！
        //调用父类和接口A重复的方法，优先使用父类的方法
        impl.methodFuAndA(); // 父类中的方法！
    }
}

14. 接口之间的多继承

  • 类与类之间是单继承的，直接父类只有一个。
  • 类与接口之间是多实现的，一个类可以实现多个接口。
  • 接口与接口之间是多继承的。
  • 注意：
    • 多个父接口当中的抽象方法如果重复，没关系。
    • 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且必须带上default关键字。
//父接口A
public interface MyInterfaceA {
    //抽象方法
    public abstract void methodA();
    //多个父类重复的抽象方法
    public abstract void method();
    //多个父类重复的默认方法
    public default void methodDefault(){
        System.out.println("父接口A的默认方法！");
    }
}
//父接口B
public interface MyInterfaceB {
    //抽象方法
    public abstract void methodB();
    //多个父类重复的抽象方法
    public abstract void method();
    //多个父类重复的默认方法
    public default void methodDefault(){
        System.out.println("父接口B的默认方法！");
    }
}
//子类
public interface MyInterface extends MyInterfaceA, MyInterfaceB {
    //子类自己的抽象方法
    public abstract void method();
    @Override
    //子接口必须覆盖重写多个父接口中重复的默认方法
    public default void methodDefault(){
        System.out.println("子接口覆盖重写父接口AB中重复的默认方法!");
    }
}

二、多态

1. 多态的概述

  • 面向对象三大特征：封装性、继承性、多态性。
  • 继承性是多态性的前提，即extends继承或implements实现，是多态性的前提。

2. 多态的的格式与使用

  • 代码中体现多态性：父类引用指向子类对象。

  • 格式：父类名称 对象名 = new 子类名称();或接口名称 对象名 = new 实现类名称();

    //父类
public class Fu {
    //与子类方法同名的父类方法
    public void method() {
        System.out.println("父类方法");
    }
    //父类特有的方法
    public void methodFu() {
        System.out.println("父类特有的方法!");
    }
}
//子类
public class Zi extends Fu{
    //与父类方法同名的子类方法
    public void method() {
        System.out.println("子类方法！");
    }
}

public class Test {
    public static void main(String[] args) {
        //使用多态的写法
        //左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();
        obj.method();  // 子类方法！
        obj.methodFu();  // 父类特有的方法!
    }
}

3. 多态中成员变量的使用特点

  • 访问成员变量的两种方法
    • **直接通过对象名称访问成员变量：**看等号左边是谁，优先用谁，没有则向上找。
    • **间接通过成员方法访问成员变量：**看该方法属于谁，优先用谁，没有则向上找。
//父类
public class Fu {
    int num = 10;
    public void show(){
        System.out.println(num);
    }
}
//子类
public class Zi extends Fu{
    int num = 20;
    @Override
    public void show() {
        System.out.println(num);
    }
}

public class Test {
    public static void main(String[] args) {
        Fu obj = new Zi();
        System.out.println(obj.num); // 父类的10

        //子类没有覆盖重写，就是父：10
        //子类如果覆盖重写，就是子：20
        obj.show(); // 20
    }
}

4. 多态中成员方法的使用特点

  • 在多态的代码中，成员方法的访问规则是：看new的是谁，就优先用谁，没有则向上找。
  • 口诀：编译看左，运行看右
  • 对比：
    • 成员变量：编译看左，运行看左
    • 成员方法：编译看左，运行看右
//父类
public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}
//子类
public class Zi extends Fu {
    @Override
    public void method(){
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Fu obj = new Zi();
        obj.method(); //父子都有，优先用子
        obj.methodFu(); //子无父有，向上找到父类

        //编译看左，左为父，父中没有methodZi方法，所以编译报错
        //obj.methodZi();
    }
}

5. 使用多态的好处

  • 无论右边new的时候换成哪个子类对象，等号左边调用的方法都不会变化。

6. 对象的向上、向下转型

  • 对象的向上转型，其实就是多态写法。

    • 格式：父类名称 对象名 = new 子类名称();
    • 含义：右侧创建一个子类对象，把它当做父类来看待使用。
    • 注意：向上转型一定是安全的。
    //抽象父类
public abstract class Animal {
    public abstract void eat();
}
//子类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat(); // 猫吃鱼
    }
}

  • 对象的向下转型，其实是一个还原的动作。

    • 格式：子类名称 对象名 = (子类名称) 父类名称;

    • 含义：将父类对象还原成为本来的子类对象。

    • 注意：向下转型时，必须保证将对象向下转型为本来创建时的类型才能成功。

    //抽象父类
public abstract class Animal {
    public abstract void eat();
}
//子类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
//子类
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
  	public void watchHouse(){
        System.out.println("狗看家");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat(); // 猫吃鱼

        //编译错误
        //animal.catchMouse();
        //向下转型
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        Animal animal1 = new Dog();
        //运行错误 必须转为原本创建时的类型
        //Cat cat1 = (Cat) animal1;
        Dog dog = (Dog) animal1;
        dog.eat(); // 狗吃骨头
        dog.watchHouse(); // 狗看家
    }
}

7. 用instanceof关键字进行类型判断

  • 格式：对象 instanceof 类名称

  • 会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

    public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat(); // 猫吃鱼

        //编译错误
        //animal.catchMouse();
        //向下转型
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        Animal animal1 = new Dog();
        //运行错误 必须转为原本创建时的类型
        //Cat cat1 = (Cat) animal1;
        Dog dog = (Dog) animal1;
        dog.eat(); // 狗吃骨头
        dog.watchHouse(); // 狗看家

        //使用instanceof关键字
        animalAction(animal); // 猫
        animalAction(animal1); // 狗
    }

    public static void animalAction(Animal animal){
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.eat();
            cat.catchMouse();
        }else if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.eat();
            dog.watchHouse();
        }
    }

}
朱古力...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习Java，你需要知道这些——接口与多态
12-20
文章目录接口接口的作用接口的语法实现接口实现多个接口的语法接口的扩展类型转换类型转换的概念类型转换规则隐式类型转换显式类型转换类型转换的主要应用场合类型转换的主要应用场合多态多态的概念多态的目的 接口 ...
多态、接口
诺一的博客
06-30 231
多态、接口
JavaSE进阶笔记-接口和多态
SUIT THUG!的博客
07-07 169
1.接口 1.1信息管理系统集合改进 (应用) 使用数组容器的弊端 容器长度是固定的，不能根据添加功能自动增长 没有提供用于赠删改查的方法 优化步骤 创建新的StudentDao类，OtherStudentDao 创建ArrayList集合容器对象 OtherStudentDao中的方法声明，需要跟StudentDao保持一致 注意：如果不一致，StudentService中的代码就需要进行修改 完善方法（添加、删除、修改、查看） 替换StudentService中的Dao对
接口 多态
weixin_42943720的博客
08-30 143
接口 接口；是Java语言的一种引用类型，是方法的集合。接口的内部主要就是封转了方 法。抽象方法1.7jdk。 静态方法和默认方法1.8jdk。私有方法1.9jkd。接口，用inerface来进行修饰，他会产生class 文件，但主要的它不是一个类，只不过是一个引用类型的方法。 引用数据类型；数据， 类，接口。 接口的使用；他不能够被用来创建对象，他可以用被实现 用implemen...
接口与多态
03-13
接口与多态 PPT
day10【接口、多态】.pdf
09-05
java中接口多态讲解，写的不错的pdf
Java程序设计课程实验10-接口和多态
最新发布
12-14
Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态...
接口，多态总结
01-20
——被static final修饰的变量–>常量 int i =10 ——被abstract修饰的抽象方法–>不写abstract，也有 jdk8：默认方法，静态方法 jdk9：私有方法 关于抽象方法的定义以及使用： 定义：修饰符 abstract 返回值类型 ...
接口的多态
blog
01-17 417
public Iterator elements(  ) {return new LinkedListIterator(this); }这里的Iterator  是接口，但是突然很疑惑，接口怎么能声明方法呢。后面查询发现：这个接口(Iterator )的实现类有很多，如果返回的类型是LinkedListIterater,的话就只能返回这一个类型，这样的话太局限了. 返回的类型(Iterator)
接口、 多态
m0_48960643的博客
07-06 1087
接口、 多态
接口、多态
NotPerfect的博客
06-13 120
接口、多态 接口 接口就是多个类的公共规范。 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。 如何定义一个接口的格式： public interface 接口名称 { // 接口内容 } 备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。 如果是Java 7，那么接口中可以包含的内容有： 常量 抽象方法 如果是Java 8...
Java基础：接口
david2000999的博客
09-26 96
Java接口基础接口接口概述标准格式接口的实现接口的多实现接口的多继承总结 接口 接口概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。 接口的定义： 它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。 引用数据类型：数组，类，接口。
多态与接口
sssyjl的博客
05-17 288
多态 一.什么是多态 多态是指两个或多个属于不同类的对象，对于同一个消息（方法调用）作出不同响应的方式。 二.编译时与运行时 编译时：在编写代码期间，没有run as 时，都属于编译时。 运行时：在run as 时，系统处于运行状态时，都属于运行时。 Questions question = new Answer1(); 编译时对象类型：Questions 运行时对象类...
Java接口与多态代码
04-18
在Java中，多态可以通过抽象类和接口实现。 下面是Java接口和多态的示例代码： // Java接口示例代码 interface Animal { public void sound(); // 声明一个抽象方法 } class Dog implements Animal { public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值