Java 基础学习（八）多态、接口、造型与内部类

1 多态

1.1 多态

1.1.1 多态的意义

一个类型的引用在指向不同的对象时会有不同的实现。依然借助前面案例中的 Person类、Student类和 Teacher 类举例，看如下的代码：

Person p1 = new Student();
Person p2 = new Teacher();
p1.schedule();
p2.schedule();

同样声明为 Person 类型的变量 p1和p2，当指向不同的对象时，可以有不同的表现。这种现象在 Java中被称为多态。

多态是面向对象的三大基本特征之一，包含：

• 个体多态
• 行为多态

1.1.2 什么是多态

多态的定义：计算机程序运行时，相同的消息可能会送给多个不同的类别之对象，而系统可依据对象所属类别，引发对应类别的方法，而有不同的行为。

这个定义很晦涩，可以从两个方面理解：

1、个体多态

• 父类型定义的变量引用的子类型个体是多种多样的，如：Person变量可以引用Student、Teacher、Worker对象等
• 个体多态是用向上造型实现的

2、行为多态

• 父类型变量引用子类型实例后，执行方法时候可以得到多种结果，如：Person变量分别引用Student、Teacher、Worker对象时候执行schedule方法得到的结果不同
• 行为多态是利用方法重写实现的

1.1.3 为什么需要多态

比如，有类关系如下图所示：

?

如何使用多态呢？首先多态的前提是继承，在有继承关系存在时候才能使用多态，其次是要对子类型进行统一处理，比如，所以人员都要执行计划。具体在实际开发中可以先不要考虑多态，先按照具体类型编程，当发现各种子类型都需要相同处理时候，再重构代码提升到父类型统一进行处理，这样就是多态处理了。比如：学生要执行计划schedule，教师要执行计划schedule，工人也要执行计划schedule，就统一装到Person数组中，用循环调用schedule方法一起执行计划。

1.1.4【案例】多态的基础应用示例

在上一个案例的基础上，测试行为多态。

案例示意代码如下：

public class PolyDemo1 {
    public static void main(String[] args) {
        // 使用父类引用指向子类对象 -> 子类向上造型
        Person p1 = new Student("Tom", 12);
        Person p2 = new Teacher("Andy", 28);
        Person p3 = new Worker("Jerry", 28);
        // 父类引用调用抽象方法，实际执行子类实现的方法
        // -> 行为多态
        p1.schedule();
        p2.schedule();
        p3.schedule();
        // 父类引用仅能访问父类中声明的成员
        // 父类应用无法访问子类中声明的成员
        // p1.study(); // 编译错误，无法访问
    }
}

1.1.5【案例】多态的扩展应用示例

在上一个案例的基础上，使用数组存储多个对象，统一执行其 schedule() 方法。

案例示意代码如下：

package oop_04.polymorphic;
public class PolyDemo2 {
    public static void main(String[] args) {
        // 多态数组
        Person[] array = {new Student("Tom", 12)
                            ,new Teacher("Andy", 28)
                            ,new Worker("Jerry", 28)};
        for(int i=0;i<array.length;i++) {
            test(array[i]);
        }
        Student s1=new Student("Lucy",15);
        // 子类类型的对象也可以传入该方法
        test(s1);
    }
    /**
     * 方法的参数为父类形态
     * 该父类的任意子类对象均可以传入该方法
     * @param person
     */
    public static void test(Person person){
        person.schedule();
    }
}

2 接口 interface

2.1 什么是接口

2.1.1 多继承问题

讨论接口之前，先看一个物品归类的生活实例：

?

查看这个商品分类，可看出：

1、相同类别的商品具有相似特征，且属性类似：比如“新鲜水果“类、”海鲜水产“类

2、同类标签便于管理统一存储和调度

3、也存在跨类别的分类标签：比如“地方特产“、”国际美食“

4、跨类别的分类标签体现了一个物品属于多种类型的现象，这种现象称为“多继承”

如果用 Java 代码来表现上述情况，会发现，Java的继承可以实现树形分类，但是无法处理跨类别标签：

?

不过，Java提供了接口，解决了跨类型的继承问题。

2.1.2 什么是接口

接口在JAVA编程语言中是一个抽象类型，通常以interface来声明。

从面向对象编程的角度，可以将接口理解为对不同类型的事物的共同的行为特征的抽象。例如，鹰和飞机属于不同类型的事物，但是都有飞行的行为特征。

?

可以把接口看成是特殊的抽象类。

2.1.3 接口和抽象类

抽象类和接口都属于抽象的概念，它们有一些区别，可以从同类别和跨类别的角度来考虑：

• 同一种类别的公共行为和属性可以抽取到抽象类中。抽象类用于表示一种具有共性的类，可以包含实现的方法和具体的属性。比如，对于喜鹊和老鹰这两种鸟类，它们都属于鸟类的范畴，可以将它们共同的行为和属性抽象到一个抽象类（如Bird）中，以实现代码的重用和扩展。
• 不同种类的公共行为可以抽取到接口中。接口用于定义一组相关的方法，用于表示某种能力或行为。比如，喜鹊、老鹰和飞机都具有起飞和着陆的功能，但它们并不属于同一种类，此时可以将与飞行相关的共同行为抽取到一个接口（如Flyable）中，不同类别的对象可以通过实现该接口来具备飞行的能力。

根据以上原则，对于喜鹊来说，它可以继承自抽象类Bird，以获取鸟类的共性属性和行为，并且还可以实现接口Flyable，以具备飞行的能力。

抽象类和接口的设计原则：

• 将所有子类共有的方法抽象化到父类中，可以使用抽象类。
• 将部分子类中的公共方法抽象化到接口中，适用于不同类别但具有相似行为的对象。

通过合理地使用抽象类和接口，可以实现代码的复用和扩展，并且更好地表示对象之间的关系和行为。选择使用抽象类还是接口取决于具体的设计需求和对象之间的关系。

2.2 接口的语法

2.2.1 接口的语法

使用interface定义接口：

1、接口中只能定义常量和方法

• 可以省略常量的修饰词 public static final
• 可以省略抽象方法修饰词 public abstract

2、接口不能实例化创建对象,

3、接口只能被继承，作为父类型被子类型实现

比如，定义飞行接口：

• 包含常量ID
• 包含 3 个抽象方法

代码结构示意如下：

?

2.2.2 实现接口

子类使用implements实现接口：必须实现该接口中所有的抽象方法。

具体语法如下所示：

?

一个类可以实现多个接口：实现的接口直接用逗号分隔。

具体语法如下所示：

?

2.2.3【案例】接口的示例

定义接口 Flyable 和类 Bird，并类 Plane实现接口Flyable，以及类 Eagle 继承Bird并实现Flyable；编写代码测试接口的用法。

案例示意代码如下所示：

package oop_04.interface01;
/**
 * 飞行接口
 */
public interface Flyable {
    int ID = 1;
    /**
     * 起飞
     */
    void takeOff();
    /**
     * 飞行
     */
    void fly();
    /**
     * 着陆
     */
    void land();
}
package oop_04.interface01;
public class Plane implements Flyable{
    @Override
    public void takeOff() {
        System.out.println("Plane takeOff...");
    }
    @Override
    public void fly() {
        System.out.println("Plane fly...");
    }
    @Override
    public void land() {
        System.out.println("Plane land...");
    }
}
package oop_04.interface01;
public class Bird {
    public void eat(){
        System.out.println("eat...");
    }
    public void sleep(){
        System.out.println("sleep...");
    }
}
package oop_04.interface01;
public class Eagle
        extends Bird implements Flyable{
    @Override
    public void takeOff() {
        System.out.println("Eagle takeOff...");
    }
    @Override
    public void fly() {
        System.out.println("Eagle fly...");
    }
    @Override
    public void land() {
        System.out.println("Eagle land...");
    }
}
package oop_04.interface01;
public class InterfaceDemo1 {
    public static void main(String[] args) {
        // Flyable flyable=new Flyable();  // 接口不可被实例化
        System.out.println(Flyable.ID);    // 接口中定义的是静态常量
        Flyable eagle = new Eagle();       // 接口类型引用指向实现类的对象
        eagle.fly();                       // 实际执行实现类重写的方法逻辑
        Flyable plane = new Plane();       // 接口类型引用指向实现类的对象
        plane.fly();                       // 实际执行实现类重写的方法逻辑
        // eagle.eat();                    // 无法访问实现类特有的方法
    }
}

2.3 接口与多继承

2.3.1 接口的继承

在Java中，接口之间也可以进行继承，这被称为接口的继承或接口的扩展。

接口的继承允许一个接口继承另一个接口的方法签名。通过继承，子接口可以获得父接口定义的方法签名，并且可以在子接口中添加新的方法签名。子接口继承了父接口的方法签名后，必须提供这些方法的具体实现。

接口的继承使用关键字extends，后面跟着要继承的父接口名称。一个接口可以继承多个接口，多个父接口之间使用逗号分隔。

下面是一个接口继承的示例：

interface Shape {
    void draw();
}
interface Circle extends Shape {
    double getRadius();
}
interface Colorable {
    void setColor(String color);
}
interface ColoredCircle extends Circle, Colorable {
    void rotate();
}

在上面的示例中，接口Circle继承了接口Shape，表示Circle接口扩展了Shape接口的方法签名。接口ColoredCircle继承了接口Circle和Colorable，表示ColoredCircle接口扩展了这两个父接口的方法签名，并且可以在子接口中添加新的方法签名rotate()。

接口的继承使得接口之间可以建立层次结构，从而实现方法签名的复用和组合。通过继承，我们可以定义更具体和特定的接口，以满足不同的需求和功能。

2.3.2 接口与多继承

接口与多继承的关系是一个常见的面试话题。在Java中，类只能继承自一个父类，这是单继承的限制。然而，一个类可以实现多个接口，这就允许了多继承的实现。

多继承的概念意味着一个类可以从多个父类继承属性和方法。然而，在Java中，类只能继承一个父类。这就是为什么Java引入接口的原因，以实现多继承的效果。通过实现多个接口，一个类可以获得多个接口定义的行为和功能，实现了类的多继承。

如下图所示：

?

在这个示例中，有三个接口：Person（人）、Flyable（可飞行）和Swimmable（可潜水）。

钢铁侠类实现了Person接口，并且还实现了Flyable和Swimmable接口。这意味着钢铁侠类具有Person接口定义的人的行为和属性，同时也具有Flyable接口定义的飞行行为和Swimmable接口定义的潜水行为。

通过实现多个接口，钢铁侠类获得了多个接口定义的行为和功能，实现了类的多继承效果。钢铁侠类可以同时表现出人的特征、飞行的能力和潜水的能力。

接口的多继承使得类可以在不受单继承限制的情况下，获得多个接口定义的功能，提供了更大的灵活性和可扩展性。

2.3.3 经典面试题目：接口和抽象类的区别

面试时候可以尝试从语法层面回复这个问题：

接口和抽象类在语法上有一些区别，主要涉及以下几个方面：

声明方式：抽象类使用 abstract 关键字进行声明，使用 class 关键字定义类。接口使用 interface 关键字进行声明。

继承关系：抽象类通过使用 extends 关键字继承其他类或抽象类。一个类只能继承一个抽象类。接口通过使用 implements 关键字实现一个或多个接口。一个类可以实现多个接口。

方法实现：抽象类可以包含实现的方法和抽象的方法。接口只能包含抽象的方法，不包含具体的方法实现。所有的方法都隐式地被声明为抽象方法，不需要使用 abstract 关键字。实现接口的类必须提供方法的具体实现。Java 8 引入了接口中的静态方法和默认方法，使得接口具备了一定的实现能力。

2.3.4 经典面试题目：Java如何实现多继承的

在Java中，类是单继承的，即一个类只能继承自一个父类。然而，通过接口的使用，Java可以实现多继承的效果。类可以实现多个接口中的方法，从而获得多个接口定义的行为和功能。这种机制提供了灵活性和可扩展性，使得Java在面对多继承需求时能够更好地满足设计和开发的需要。

3 造型

3.1 向上造型

3.1.1 向上造型

向上造型（Upcasting）是指将一个子类对象赋值给父类引用变量的过程。通过向上造型，可以将一个子类对象视为其父类类型，实现多态性的体现。

向上造型的特点：

• 子类对象可以赋值给父类引用变量，但是父类对象不能赋值给子类引用变量。
• 向上造型是自动进行的，不需要额外的转换操作。
• 通过向上造型，可以调用父类中声明的方法，但无法调用子类中特有的方法。

向上造型的优势：

• 实现多态性：通过向上造型，可以将不同子类的对象视为父类类型，统一对待，实现多态性的效果。
• 灵活性和扩展性：通过向上造型，可以在不改变父类引用的情况下，使用不同的子类对象，使程序具备更大的灵活性和可扩展性。

3.1.2 【案例】向上造型示例

示例代码：

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void printInfo() {
        System.out.println("Person: " + name);
    }
}
class Student extends Person {
    private int studentId;
    public Student(String name, int studentId) {
        super(name);
        this.studentId = studentId;
    }
    public int getStudentId() {
        return studentId;
    }
    public void printInfo() {
        System.out.println("Student: " + getName() + ", Student ID: " + studentId);
    }
}
class Teacher extends Person {
    private String subject;
    public Teacher(String name, String subject) {
        super(name);
        this.subject = subject;
    }
    public String getSubject() {
        return subject;
    }
    public void printInfo() {
        System.out.println("Teacher: " + getName() + ", Subject: " + subject);
    }
}
public class Main {
    public static void main(String[] args) {
        Person person1 = new Student("Alice", 123);
        Person person2 = new Teacher("Bob", "Math");
        person1.printInfo(); // 输出: Student: Alice, Student ID: 123
        person2.printInfo(); // 输出: Teacher: Bob, Subject: Math
        // 向上造型
        Person person3 = new Student("Carol", 456);
        Person person4 = new Teacher("David", "Science");
        person3.printInfo(); // 输出: Student: Carol, Student ID: 456
        person4.printInfo(); // 输出: Teacher: David, Subject: Science
    }
}

在上述示例中，Person是一个基类，Student和Teacher是其子类。我们可以将Student和Teacher对象向上造型为Person类型，并将它们赋值给Person引用变量person3和person4。通过向上造型，我们可以使用Person引用变量调用Person类中的方法和属性。在调用printInfo()方法时，由于方法被子类重写，实际上会根据对象的实际类型调用相应的子类方法。

这样做的好处是，我们可以使用统一的Person类型处理不同类型的对象，实现了多态性。通过向上造型，我们可以灵活地处理不同类型的子类对象，使代码更具扩展性和可维护性。

3.2 向下造型

3.2.1 向下造型

向上造型中有个特性“无法调用子类中特有的方法”，如果调用子类行特有的方法呢？这个就需要使用向下造型了。

向下造型（Downcasting）是指将一个已经向上造型（Upcasting）的对象重新转回其原始的子类类型。它允许我们在需要的时候访问和调用子类特有的方法和属性。

3.2.2【案例】向下造型示例

在 Java 中，向下造型需要使用强制类型转换操作符(子类类型)来实现，但在进行向下造型之前，需要先确保对象实际上是指定的子类对象。否则，如果尝试对一个不兼容的对象进行向下造型，将会抛出ClassCastException异常。

以下是一个示例，演示了向下造型的使用：

/**
 * 演示向下转型
 */
public class Demo02 {
    public static void main(String[] args) {
        Person person1 = new Student("Alice", 123);
        Person person2 = new Teacher("Bob", "Math");
        // 直接使用类型引用调用子类特有的方法会编译错误
        // person1.getStudentId(); // 编译错误
        // person2.getSubject(); // 编译错误
        
        // 向下转型
        Student student = (Student) person1;
        Teacher teacher = (Teacher) person2;
        System.out.println(student.getStudentId()); // 输出: 123
        System.out.println(teacher.getSubject()); // 输出: Math
        
        // 向下转型时，如果类型不匹配，会抛出ClassCastException
        // Teacher teacher2 = (Teacher) person1; // 抛出ClassCastException
    }
}

需要注意的是，在进行向下造型之前，我们需要确保对象实际上是指定的子类对象。否则，如果尝试对一个不兼容的对象进行向下转型，将会导致运行时异常。

向下转型的使用需要谨慎，应确保转型操作的合法性和正确性。如果不确定对象是否适合进行向下转型，可以使用instanceof运算符进行类型检查，以避免可能的异常。

3.2.3 instanceof 运算

instanceof 运算符用于检测对象是否是指定类型的实例。它经常与向下造型一起使用，以实现类型安全的转换，避免类型转换异常的发生。

instanceof 运算符的语法如下：

对象 instanceof 类型

其中，对象是要检测的对象，类型是要检测的类名或接口名。

instanceof 运算符返回一个布尔值，如果对象是指定类型的实例，则返回 true，否则返回 false。

下面是一个示例，演示了instanceof 运算符的使用：

Person person1 = new Student("Alice", 123);
Person person2 = new Teacher("Bob", "Math");
// 使用instanceof运算符判断对象是否是某个类的实例
System.out.println(person1 instanceof Student); // 输出: true
System.out.println(person1 instanceof Person);  // 输出: true
System.out.println(person1 instanceof Teacher); // 输出: false
System.out.println(person2 instanceof Student); // 输出: false

在上述示例中，我们创建了一个 Person 类的实例 person1，它实际上是一个 Student 对象。使用 instanceof 运算符可以判断 person1 是否是 Student 类的实例，结果为 true。同样地，我们也可以判断 person1 是否是 Person 类的实例，结果同样为 true。然而，由于 person1 并不是 Teacher 类的实例，所以返回 false。

使用 instanceof 运算符可以帮助我们在进行类型转换之前先进行类型检测，确保转换的安全性。这样可以避免类型转换异常的发生，并在需要时选择执行相应的操作。

3.2.4使用instanceof保护造型

使用 instanceof 运算符可以保护向下造型，避免 ClassCastException 异常的发生，从而减少程序中的运行错误。

在使用 instanceof 运算符进行向下造型时，可以先使用 instanceof 进行类型检测，以确保对象的类型与要转型的类型匹配。如果匹配成功，就可以进行转型操作，否则可以选择执行其他逻辑或抛出异常。

下面是一个示例，演示了如何使用 instanceof 运算符保护向下造型：

if (person1 instanceof Student) {
    Student student = (Student) person1;
    System.out.println(student.getStudentId()); // 输出: 123
}

在上述示例中，我们先使用 instanceof 运算符检测 person1 是否是 Student 类的实例。如果匹配成功，我们就可以将 person1 强制转型为 Student 类型，并调用 getStudentId() 方法。这样可以避免在转型过程中发生 ClassCastException 异常。

此外，Java 17 引入了 instanceof 模式匹配的新特性，可以进一步简化向下转型的编码：

if (person1 instanceof Student student) {
    System.out.println(student.getStudentId()); // 输出: 123
}

在上述示例中，我们使用 instanceof 模式匹配，将匹配成功的结果直接绑定到 student 变量上，省去了显式的类型转换操作。这样可以更加简洁地实现向下转型，并且代码更加清晰易读。

使用 instanceof 运算符和 instanceof 模式匹配可以提高程序的健壮性，确保类型转换的安全性，减少潜在的运行时错误。

4 内部类

4.1 内部类概述

4.1.1 内部类概述

内部类，顾名思义，就是声明在一个外部类内部的类。内部与外部，是一个相对的说法：外部类是指内部类所在的类。

内部类一般有以下4种分类：

• 局部内部类：声明在外部类的局部位置上，有类名
• 成员内部类：声明在外部类的成员位置上，有类名，无static修饰
• 静态内部类：声明在外部类的成员位置上，有类名，有static修饰
• 匿名内部类：在一行代码上继承父类并且创建出子类实例的语法，无类名

如下图所示：

上述4种内部类中，匿名内部类在日常开发中较为常见，将在本节中进行介绍。其他的内部类在基础的开发中较为少见，在一些特定的设计模式和框架中有所应用，将在后续的课程中进行介绍。

4.2 匿名内部类

4.2.1 什么是匿名内部类

如果在一段程序中需要创建一个类的对象（通常这个类需要实现某个接口或者继承某个类），而且对象创建后，这个类的价值也就不存在了，这个类可以不必命名，称之为匿名内部类。

利用匿名内部类可以写出简洁明快的代码，在实际开发中应用非常广泛。

语法示例如下：

?

4.2.2 使用匿名内部类

匿名内部类的语法在一行代码上完成了两个功能：继承父类，创建子类行对象，所以要有1个前提条件：有一个可以被继承的父类型， 这个父类型可以是类、抽象类、接口。如下所示：

?

利用匿名内部类，可以在一行代码上继承父类并且创建出子类实例。这样可以使用最简洁的代码实现最多的功能。由于利用匿名内部类可以写出简洁明快的代码，在实际开发中应用非常广泛。

比如存在一个父类Bird：

?如果需要创建一个子类重写其move方法，对比一下普通类和匿名内部类的区别：

?

显然，匿名内部类显得更加简洁方便。匿名内部类简洁地省略类子类类名，也因为没有类名造成不能再复用类名创建更多地对象。在使用匿名内部类时候要注意：

1、如果只是简洁地继承父类，并且只需要创建一个子类对象，就采用匿名内部类。

2、如果子类需要反复使用创建一组子类对象就采用普通的子类。

3、匿名内部类一定是子类，一定需要有父类型时候才能使用。

4、匿名内部类的最大优点就是语法简洁，在一行上继承子类并且创建类了子类对象。