2022-02-19 15:50 已编辑江西中医药大学 Python

关注

Java基础|1-05-接口与多态 @面向对象篇

写在前面：
此系列文是笔者在学习Java系列课程的过程中，参考相关课件、视频讲解、课程代码，并结合一些文档、思维导图及个人理解，对所学内容做的阶段性梳理与总结。

写于：2021年1月27日、29日
内容：Java后端系列笔记005（Java基础-接口与多态）
全文：10989字；读完需要：20分钟

一、接口

1. 1 概述

生活中的接口

接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

1. 2 接口的定义与实现

定义接口的格式

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

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class

接口中的内容

如果是Java 7，那么接口中可以包含的内容有：
- ① 常量
- ② 抽象方法
如果是Java 8，还可以额外包含有：
- ③ 默认方法
- ④ 静态方法
如果是Java 9，还可以额外包含有：
- ⑤ 私有方法

实现接口的格式

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类

class 类名 implements 接口名 {
   
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

接口的抽象方法

定义：

在任何版本的Java中，接口都能定义抽象方法
格式：public abstract 返回值类型方法名称(参数列表);
注意事项：
- 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
- 这两个关键字修饰符，可以选择性地省略（对于初学者，不推荐）
- 方法的三要素，可以随意定义

//接口
public interface MyInterfaceAbstract {
   
    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();
}

使用：

接口不能直接使用，必须有一个“实现类”来“实现”该接口
★ 格式：public class 实现类名称 implements 接口名称 { /*...*/ }
接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
★ 实现：去掉abstract关键字，加上方法体大括号

//实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
   
//把鼠标放在红线处：快捷键Alt+Enter → implement methods → 默认选中所有抽象方法 
// → OK 即可生成覆盖重写的代码 → 自己填写里面的方法体
    @Override
    public void methodAbs1() {
   
        System.out.println("这是第一个方法！");
    }

    @Override
    public void methodAbs2() {
   
        System.out.println("这是第二个方法！");
    }

    @Override
    public void methodAbs3() {
   
        System.out.println("这是第三个方法！");
    }

    @Override
    public void methodAbs4() {
   
        System.out.println("这是第四个方法！");
    }
}

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

//测试类
public class Demo01Interface {
   
    public static void main(String[] args) {
   
        // 错误写法！不能直接new接口对象使用
// MyInterfaceAbstract inter = new MyInterfaceAbstract();

        // 创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }

}

/* 输出结果： 这是第一个方法！ 这是第二个方法！ */

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

接口的默认方法

定义：

从Java 8开始，接口里允许定义默认方法
格式：public default 返回值类型方法名称(参数列表) { 方法体 }
备注：接口当中的默认方法，可以解决接口升级的问题

使用：（两种方式）

接口的默认方法，可以通过接口实现类对象，直接调用（继承）
接口的默认方法，也可以被接口实现类进行覆盖重写（重写）

代码演示：

定义接口

public interface MyInterfaceDefault {
   

    // 抽象方法
    public abstract void methodAbs();

    // 新添加了一个抽象方法
// public abstract void methodAbs2(); //接口的实现类必须覆盖重写所有抽象方法，新添加抽象方***影响实现类

    // 新添加的方法，改成默认方法
    public default void methodDefault() {
   
        System.out.println("这是新添加的默认方法");
    }

}

定义实现类

public class MyInterfaceDefaultA implements MyInterfaceDefault {
   
    @Override
    public void methodAbs() {
   
        System.out.println("实现了抽象方法，AAA");
    }
	// 继承默认方法(什么都不写，直接调用)
}

public class MyInterfaceDefaultB implements MyInterfaceDefault {
   
    @Override
    public void methodAbs() {
   
        System.out.println("实现了抽象方法，BBB");
    }

    @Override  //重写默认方法
    public void methodDefault() {
   
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

定义测试类

public class Demo02Interface {
   
    public static void main(String[] args) {
   
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类

        // 调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault(); // 这是新添加的默认方法
        System.out.println("==========");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }
}
/* 执行结果： 实现了抽象方法，AAA 这是新添加的默认方法 ========== 实现了抽象方法，BBB 实现类B覆盖重写了接口的默认方法 */

接口的静态方法

定义：

从Java 8开始，接口当中允许定义静态方法
格式：public static 返回值类型方法名称(参数列表) { 方法体 }
提示：就是将abstract或者default换成static即可，带上方法体

使用：

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名称，直接调用其中的静态方法
格式：接口名称.静态方法名(参数);

代码演示：

定义接口

public interface MyInterfaceStatic {
   

    public static void methodStatic() {
   
        System.out.println("这是接口的静态方法！");
    }
    
}

定义实现类

public class MyInterfaceStaticImpl implements MyInterfaceStatic {
   
	// 无法重写静态方法
}

定义测试类

public class Demo03Interface {
   
    public static void main(String[] args) {
   
        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        // 错误写法！（无法继承方法,也无法调用）
// impl.methodStatic();

        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}
/* 执行结果： 这是接口的静态方法！ */

接口的私有方法

问题描述：

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

解决方案：从Java 9开始，接口当中允许定义私有方法

普通私有方法，解决多个默认方法之间重复代码问题
★ 格式：private 返回值类型方法名称(参数列表) { 方法体 }
静态私有方法，解决多个静态方法之间重复代码问题
★ 格式：private static 返回值类型方法名称(参数列表) { 方法体 }

小提示：

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用
- 普通私有方法：只有默认方法可以调用
- 静态私有方法：默认方法和静态方法可以调用
从设计的角度讲，私有的方法是对默认方法和静态方法的辅助

代码演示：

定义接口

// 默认方法
public interface MyInterfacePrivateA {
   
    public default void methodDefault1() {
   
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2() {
   
        System.out.println("默认方法2");
        methodCommon();
    }

    private void methodCommon() {
   
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

// 静态方法
public interface MyInterfacePrivateB {
   
    public static void methodStatic1() {
   
        System.out.println("静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
   
        System.out.println("静态方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {
   
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

定义测试类（使用）

public class Demo04Interface {
   

    public static void main(String[] args) {
   
     	MyInterfacePrivateB.methodStatic1();//直接调用
        MyInterfacePrivateB.methodStatic2();
        // 错误写法！不可调用里面的私有方法
// MyInterfacePrivateB.methodStaticCommon();
    }

}

接口的常量

定义：

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰
- 从效果上看，这其实就是接口的【常量】
格式：public static final 数据类型常量名称 = 数据值;
备注：一旦使用final关键字进行修饰，说明不可改变

注意事项：

接口当中的常量，可以省略public static final，注意：不写也照样是这样
接口当中的常量，必须进行赋值；不能不赋值
接口中常量的名称，使用完全大写的字母，用下划线进行分隔（推荐命名规则）

代码演示：

// 接口中定义常量
public interface MyInterfaceConst {
   

    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;

}

// 访问常量
public class Demo05Interface {
   
    public static void main(String[] args) {
   
        // 访问接口当中的常量（接口名.常量名）
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

小结 [ 导图 ]

1. 3 接口的多实现

使用接口的时候，需要注意：

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

public interface MyInterfaceA {
   
    // 错误写法！接口不能有静态代码块
// static {
   
//
// }

    // 错误写法！接口不能有构造方法
// public MyInterfaceA() {
   
//
// }
}

一个类的直接父类是唯一的，但是一个类可以同时实现多个接口（接口的多实现）
★ 格式：

public class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
   
	// 重写接口中所有抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}
// [ ]：表示可选操作

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

// 定义多个接口
interface A {
   
	public abstract void showA();
	public abstract void show();
}
interface B {
   
	public abstract void showB();
	public abstract void show();
}

// 定义实现类
public class C implements A,B{
   
	@Override
	public void showA() {
   
		System.out.println("showA");
	}
	
	@Override
	public void showB() {
   
		System.out.println("showB");
	}
	
	@Override
	public void show() {
   
		System.out.println("show");
	}
}

如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
★ 格式：

public abstract class 类名 implements 接口名1,接口名2,... {
   
    // 未重写接口中所有抽象方法
}

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

// 定义多个接口
interface A {
   
	public default void methodA(){
   }
	public default void method(){
   }
}

interface B {
   
	public default void methodB(){
   }
	public default void method(){
   }
}

// 定义实现类
public class C implements A,B{
   
	@Override
	public void method() {
   
		System.out.println("method");
	}
}

优先级问题：一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法

// 定义接口
public interface MyInterface {
   
    public default void method() {
   
        System.out.println("接口的默认方法");
    }
}

// 定义父类
public class Fu {
   
    public void method() {
   
        System.out.println("父类方法");
    }
}

// 定义子类
public class Zi extends Fu implements MyInterface {
   
	// 未重写method方法
}

// 定义测试类
public class Demo01Interface {
   
    public static void main(String[] args) {
   
        Zi zi = new Zi();
        zi.method();
    }
}
/* 输出结果： 父类方法 */

1. 4 接口的多继承

概念：

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似
接口的继承使用 extends 关键字，子接口继承父接口的方法

区别：

类与类之间是单继承的，直接父类只有一个
类与接口之间是多实现的，一个类可以实现多个接口
接口与接口之间是多继承的

注意事项：

多个父接口当中的抽象方法如果重复，没关系

// 定义父接口
interface MyInterfaceA {
   
    public abstract void methodA();
    public abstract void methodCommon();
}

interface MyInterfaceB {
   
    public abstract void methodB();
    public abstract void methodCommon();
}

// 定义子接口
public interface MyInterface extends MyInterfaceA, MyInterfaceB {
   
    public abstract void method();
}

/* 这个子接口当中有几个方法？答：4个 methodA 来源于接口A methodB 来源于接口B methodCommon 同时来源于接口A和B method 来源于我自己 */

多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字

// 定义父接口
interface A {
   
	public default void method(){
   
		System.out.println("AAAAAA");
	}
}
interface B {
   
	public default void method(){
   
		System.out.println("BBBBBB");
	}
}

// 定义子接口
interface D extends A,B{
   
	@Override
	public default void method() {
   
		System.out.println("DDDDDD");
	}
}

小贴士：

子接口重写默认方法时，default关键字可以保留；

子类重写默认方法时，default关键字不可以保留。

二、多态

2. 1 概述

多态性是继封装、继承之后，面向对象的第三大特性
定义：多态是指同一行为，具有多个不同表现形式
前提（多态存在的三个必要条件）
- ① 继承或者实现（二选一）
- ② 方法的重写（意义体现：不重写，无意义）
- ③ 父类引用指向子类对象（格式体现）
  - 如：Parent p = new Child();

2. 2 多态的体现

多态的格式和使用：

代码当中体现多态性，其实就是一句话：父类引用指向子类对象
格式：

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

代码示例：

// 左侧父类的引用，指向了右侧子类的对象
Fu obj = new Zi();  // 使用多态的写法
obj.method();

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

访问方式1：直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
访问方式2：间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找

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

访问规则：看new的是谁，就优先用谁，没有则向上找
口诀：编译看左边，运行看右边

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

代码演示：

定义父类

public class Fu /*extends Object*/ {
   

    int num = 10;

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

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

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

}

定义子类

public class Zi extends Fu {
   

    int num = 20;
    int age = 16;

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

    @Override
    public void method() {
   
        System.out.println("子类方法");
    }

    public void methodZi() {
   
        System.out.println("子类特有方法");
    }
}

定义测试类

public class Demo01 {
   

    public static void main(String[] args) {
   
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        
        /*成员变量： 编译看左边，运行还看左边 */
        System.out.println(obj.num); // 父：10 （通过对象名称访问成员变量）
// System.out.println(obj.age); // 错误写法！

        // 子类没有覆盖重写，就是父：10
        // 子类如果覆盖重写，就是子：20
        obj.showNum();// 子：20 （通过成员方法访问成员变量）
        System.out.println("=============");
        
        
		/* 成员方法： 编译看左边，运行看右边 */
		obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
// obj.methodZi(); // 错误写法！
    } 
}

小贴士：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写（“编译看左，运行看右”的体现）

2. 3 多态的好处

说明：实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利

代码演示：

定义父类

public abstract class Animal {
   
	public abstract void eat();
}

定义子类

class Cat extends Animal {
   
	public void eat() {
   
		System.out.println("吃鱼");
	}
}

class Dog extends Animal {
   
	public void eat() {
   
		System.out.println("吃骨头");
	}
}

定义测试类

public class Test {
   
	public static void main(String[] args) {
   
		// 多态形式，创建对象
		Animal c = new Cat();
		Animal d = new Dog();
		
		// 调用showCatEat
		showCatEat(c);  // 吃鱼
		// 调用showDogEat
		showDogEat(d); // 吃骨头
		/* 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */
		showAnimalEat(c); // 吃鱼
		showAnimalEat(d); // 吃骨头
	}
	public static void showCatEat (Cat c){
   
		c.eat();
	}
	public static void showDogEat (Dog d){
   
		d.eat();
	}
	public static void showAnimalEat (Animal a){
   
		a.eat();
	}
}

分析：

2. 4 引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型（默认）

// 格式
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat(); // 父类引用指向一个子类对象

向上转型一定是安全的，没有问题的，正确的
但也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
解决方案：用对象的向下转型（还原）

向下转型（强制）

// 格式
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a; // 父类类型向子类类型向下转换

小贴士：

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。
也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型代码演示：

定义类

abstract class Animal {
   
	abstract void eat();
}

class Cat extends Animal {
   
    @Override
	public void eat() {
   
		System.out.println("猫吃鱼");
	}
	// 子类特有方法
	public void catchMouse() {
   
		System.out.println("猫抓老鼠");
	}
}

class Dog extends Animal {
   
	@Override
	public void eat() {
   
		System.out.println("狗吃骨头");
	}
	public void watchHouse() {
   
		System.out.println("狗看家");
	}
}

定义测试类

public class Demo01Main {
   

    public static void main(String[] args) {
   
        // 对象的向上转型，就是：父类引用指向之类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

// animal.catchMouse(); // 错误写法！

        // 向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠
    }
}

转型的异常

java.lang.ClassCastException

// 示例：
Animal animal = new Cat(); 

 /* 下面是错误的向下转型： 本来new的时候是一只猫，现在非要当做狗。 错误写法！编译不会报错，但是运行会出现异常： java.lang.ClassCastException，类转换异常 */
 Dog dog = (Dog) animal;

如何才能知道一个父类引用的对象，本来是什么子类？

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验
格式：对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例

public class Demo02Instanceof {
   

    public static void main(String[] args) {
   
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃骨头

        // 如果希望调用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
   
            Dog dog = (Dog) animal;
            dog.watchHouse();// 调用的是 Dog 的 watchHouse
        }
        // 判断一下animal本来是不是Cat
        if (animal instanceof Cat) {
   
            Cat cat = (Cat) animal;
            cat.catchMouse();// 调用的是 Cat 的 catchMouse
        }
    }
}