多态的概念

什么是多态?可以先把它理解成:同样是父类类型的变量,实际指向的对象不同,调用同一个方法时,就可能表现出不同的行为。

例如,学生、老师和管理员都属于人员,但他们各自展示信息的方式可以不同。我们可以统一使用 Person 类型来接收这些对象,真正调用方法时,再执行对应角色的方法。

多态的常见写法是:

java
父类类型 对象名 = new 子类类型();

例如:

java
Person p = new Student();

等号左边的 Person 是变量声明的类型,右边实际创建的是 Student 对象。变量用父类类型声明,不代表创建出来的对象就变成了父类对象。

这里先以继承关系来理解多态。使用这种写法,需要父子类之间有继承关系,并让父类类型的变量指向子类对象。如果想让同一个方法在不同子类中表现出不同的行为,还需要子类重写父类的方法。

为什么需要多态?

假如我们正在写一个学生管理系统,里面有学生、老师和管理员三个角色。现在需要写一个 register() 方法,处理这些角色的信息。

还没学多态时,我们可能会想到分别写三个方法,让它们接收 Student、Teacher 和 Administrator。可是三个角色都是人员,处理流程又差不多,难道每增加一个角色,就得再写一个方法吗?

既然这三个类都可以继承 Person,那就把 register() 方法的参数写成共同的父类 Person。这样三个角色的对象都能传进来,而且只需要写一个方法。

java
public class Test1 {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);

        Teacher t = new Teacher();
        t.setName("李四");
        t.setAge(25);

        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(30);

        register(s);
        register(t);
        register(admin);
    }

    // 使用三个角色共同的父类作为参数
    public static void register(Person p) {
        p.show();
    }
}

class Person {
    private String name;
    private int age;

    // 无参构造方法
    public Person() {
    }

    // 带参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

class Student extends Person {
    @Override
    public void show() {
        System.out.println("学生的信息为:" + getName() + "," + getAge());
    }
}

class Teacher extends Person {
    @Override
    public void show() {
        System.out.println("老师的信息为:" + getName() + "," + getAge());
    }
}

class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员的信息为:" + getName() + "," + getAge());
    }
}

运行结果:

纯文本
学生的信息为:张三,18
老师的信息为:李四,25
管理员的信息为:管理员,30

这里用打印信息来演示 register() 的处理过程,暂时没有编写真正的注册业务逻辑。

注意 register(Person p):虽然参数写的是 Person,但我们先后传入的是 Student、Teacher 和 Administrator 对象。它们都属于 Person 的子类,所以都能被接收。

还有个问题:方法里只写了一次 p.show(),为什么输出时有“学生的信息”“老师的信息”“管理员的信息”三种结果?

因为这三个子类都重写了 show()。当 p 实际指向学生对象时,执行学生的 show();指向老师对象时,执行老师的 show();指向管理员对象时,也就执行管理员的 show()。

这就是多态在这个例子中的作用:一个方法接收多种子类对象,再根据实际对象执行对应的行为。

多态调用成员的特点

多态还有一个比较容易弄混的地方:通过父类类型的变量访问成员变量,与调用重写后的成员方法,结果可能不一样。

可以先记住两句话:

  • 成员变量:编译看左边,运行也看左边。
  • 成员方法:编译看左边,运行看右边。 这里说的是可以被子类重写的实例方法。

拿 Animal a = new Dog(); 举个例子:

java
public class Test1 {
    public static void main(String[] args) {
        Animal a = new Dog();

        System.out.println(a.name);
        a.show();
    }
}

class Animal {
    String name = "动物";

    public void show() {
        System.out.println("Animal --- show方法");
    }
}

class Dog extends Animal {
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog --- show方法");
    }
}

class Cat extends Animal {
    String name = "猫";

    @Override
    public void show() {
        System.out.println("Cat --- show方法");
    }
}

运行结果:

纯文本
动物
Dog --- show方法

为什么打印的是“动物”?

a 的声明类型是 Animal,因此写 a.name 时,访问的是 Animal 中定义的 name,打印出 动物。

虽然右边创建的是 Dog 对象,Dog 中也有一个叫 name 的成员变量,但成员变量没有方法重写的机制。通过 Animal 类型的变量访问 name,就会使用 Animal 的这个成员变量。

为什么调用的是 Dog 的 show()?

调用 a.show() 时,编译器先检查 Animal 里有没有可以调用的 show()。如果父类类型里根本没有这个方法,这行代码就不能通过编译。

而程序运行时,a 指向的实际对象是 Dog,并且 Dog 已经重写了 show(),所以最终打印的是 Dog --- show方法。

这里可以联系继承时学过的虚方法表来理解:调用重写后的实例方法时,程序能够根据实际对象找到对应的版本。现在先记住变量访问与重写方法调用的区别就可以了。

多态的优势与局限

优势:减少重复代码,方便扩展

前面的 register(Person p) 就是一个很直观的例子。以后如果又增加一种继承 Person 的角色,只要这个新角色也提供相应的 show() 实现,就可以继续使用同一个 register() 方法,不需要专门给它再写一个同样的处理方法。

同一个父类类型的变量也能接收不同子类对象,例如:

java
Person p = new Student();
p.show();

p = new Teacher();
p.show();

两次都是调用 p.show(),但 p 先指向学生对象,后来又指向老师对象,因此会执行不同版本的 show()。使用多态时,调用方式保持一致,具体行为可以随着实际对象改变。

局限:不能直接调用子类独有的方法

多态也有一个限制:父类类型的变量不能直接调用只在子类中定义的方法。

假设 Person 没有 study(),只有 Student 才定义了这个方法:

java
Person p = new Student();
// p.study(); // 编译不通过:Person 中没有 study() 方法

明明右边创建的是学生对象,为什么还不能调用呢?因为编译器看到 p 是 Person 类型,会先检查 Person 有没有这个方法。没有的话,就无法通过编译。

但我们确实知道这里的对象是 Student,那能不能再把它当成 Student 来使用?可以,这就是向下转型。

向下转型与 instanceof

向下转型

前面的 Person p = new Student(); 是把子类对象交给父类类型的变量来接收,可以理解成向上转型。

如果需要调用学生独有的 study(),就可以再转回 Student 类型:

java
Student s = (Student) p;
s.study();

写法看起来和之前学过的强制类型转换有点像。不过,向下转型不会把对象真的变成另一种对象,只是让我们通过子类类型的变量来使用它。前提是这个对象本来就属于对应的子类类型。

例如,p 实际指向的是 Student,转换为 Student 就没问题;如果非要把它转成 Teacher,虽然某些写法能通过编译,运行时却会抛出 ClassCastException。

instanceof:先判断,再转换

如果不确定 p 实际指向哪种对象,可以先用 instanceof 判断类型:

java
if (p instanceof Student) {
    Student s = (Student) p;
    s.study();
}

只有 p 指向的对象是 Student(或它的子类)时,条件才成立,随后再转换并调用 study()。这样可以避免把一个老师对象误转成学生对象。

新版 instanceof:判断和转换一起写

上面的代码还要先判断,再写一遍强制转换。Java 后来提供了更简洁的写法:

java
if (p instanceof Student s) {
    s.study();
}

这行代码可以这样理解:如果 p 指向的是 Student 对象,就把它当成 Student 类型,并命名为 s;接下来就可以直接使用 s 调用学生独有的方法。如果类型不匹配,条件为 false,也就不会执行花括号里的代码。

这种写法叫作 instanceof 模式匹配。它在 JDK 14 中以预览功能出现,从 JDK 16 开始正式支持。

下面把这几种写法放在一个完整示例中,方便对照:

java
public class Test1 {
    public static void main(String[] args) {
        Person p = new Student();

        // p.study(); // 编译不通过,Person 没有 study() 方法

        // 先判断,再手动向下转型
        if (p instanceof Student) {
            Student s = (Student) p;
            s.study();
        }

        // JDK 16 起可以直接使用模式匹配写法
        if (p instanceof Student s) {
            s.study();
        }
    }
}

class Person {
}

class Student extends Person {
    public void study() {
        System.out.println("学生正在学习");
    }
}

运行结果:

纯文本
学生正在学习
学生正在学习

两种写法得到的结果一样。区别在于新版 instanceof 将类型判断、转换和变量声明放在了一起,代码更简洁。

回头看多态的几个例子,我们既可以用 Person 类型统一接收学生、老师和管理员,也能在确实需要调用子类特有功能时,通过类型判断和向下转型使用子类的方法。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。