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 为什么需要多态

比如,有类关系如下图所示:

Java 基础学习(八)多态、接口、造型与内部类_第1张图片

如何使用多态呢?首先多态的前提是继承,在有继承关系存在时候才能使用多态,其次是要对子类型进行统一处理,比如,所以人员都要执行计划。具体在实际开发中可以先不要考虑多态,先按照具体类型编程,当发现各种子类型都需要相同处理时候,再重构代码提升到父类型统一进行处理,这样就是多态处理了。比如:学生要执行计划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

2 接口 interface

2.1 什么是接口

2.1.1 多继承问题

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

Java 基础学习(八)多态、接口、造型与内部类_第2张图片

查看这个商品分类,可看出:

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

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

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

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

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

Java 基础学习(八)多态、接口、造型与内部类_第3张图片

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

2.1.2 什么是接口

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

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

Java 基础学习(八)多态、接口、造型与内部类_第4张图片

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

2.1.3 接口和抽象类

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

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

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

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

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

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

2.2 接口的语法

2.2.1 接口的语法

使用interface定义接口:

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

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

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

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

比如,定义飞行接口:

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

代码结构示意如下:

Java 基础学习(八)多态、接口、造型与内部类_第5张图片

2.2.2 实现接口

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

具体语法如下所示:

Java 基础学习(八)多态、接口、造型与内部类_第6张图片

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

具体语法如下所示:

Java 基础学习(八)多态、接口、造型与内部类_第7张图片

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引入接口的原因,以实现多继承的效果。通过实现多个接口,一个类可以获得多个接口定义的行为和功能,实现了类的多继承。

如下图所示:

Java 基础学习(八)多态、接口、造型与内部类_第8张图片

在这个示例中,有三个接口: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修饰
  • 匿名内部类:在一行代码上继承父类并且创建出子类实例的语法,无类名

如下图所示:

Java 基础学习(八)多态、接口、造型与内部类_第9张图片

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

4.2 匿名内部类

4.2.1 什么是匿名内部类

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

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

语法示例如下:

Java 基础学习(八)多态、接口、造型与内部类_第10张图片

4.2.2 使用匿名内部类

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

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

比如存在一个父类Bird:

Java 基础学习(八)多态、接口、造型与内部类_第11张图片

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

Java 基础学习(八)多态、接口、造型与内部类_第12张图片

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

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

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

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

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

你可能感兴趣的:(Java,开发学习,学习,java,开发语言,运维,linux)