多态的概念
什么是多态?可以先把它理解成:同样是父类类型的变量,实际指向的对象不同,调用同一个方法时,就可能表现出不同的行为。
例如,学生、老师和管理员都属于人员,但他们各自展示信息的方式可以不同。我们可以统一使用 Person 类型来接收这些对象,真正调用方法时,再执行对应角色的方法。
多态的常见写法是:
父类类型 对象名 = new 子类类型();例如:
Person p = new Student();等号左边的 Person 是变量声明的类型,右边实际创建的是 Student 对象。变量用父类类型声明,不代表创建出来的对象就变成了父类对象。
这里先以继承关系来理解多态。使用这种写法,需要父子类之间有继承关系,并让父类类型的变量指向子类对象。如果想让同一个方法在不同子类中表现出不同的行为,还需要子类重写父类的方法。
为什么需要多态?
假如我们正在写一个学生管理系统,里面有学生、老师和管理员三个角色。现在需要写一个 register() 方法,处理这些角色的信息。
还没学多态时,我们可能会想到分别写三个方法,让它们接收 Student、Teacher 和 Administrator。可是三个角色都是人员,处理流程又差不多,难道每增加一个角色,就得再写一个方法吗?
既然这三个类都可以继承 Person,那就把 register() 方法的参数写成共同的父类 Person。这样三个角色的对象都能传进来,而且只需要写一个方法。
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(); 举个例子:
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() 方法,不需要专门给它再写一个同样的处理方法。
同一个父类类型的变量也能接收不同子类对象,例如:
Person p = new Student();
p.show();
p = new Teacher();
p.show();两次都是调用 p.show(),但 p 先指向学生对象,后来又指向老师对象,因此会执行不同版本的 show()。使用多态时,调用方式保持一致,具体行为可以随着实际对象改变。
局限:不能直接调用子类独有的方法
多态也有一个限制:父类类型的变量不能直接调用只在子类中定义的方法。
假设 Person 没有 study(),只有 Student 才定义了这个方法:
Person p = new Student();
// p.study(); // 编译不通过:Person 中没有 study() 方法明明右边创建的是学生对象,为什么还不能调用呢?因为编译器看到 p 是 Person 类型,会先检查 Person 有没有这个方法。没有的话,就无法通过编译。
但我们确实知道这里的对象是 Student,那能不能再把它当成 Student 来使用?可以,这就是向下转型。
向下转型与 instanceof
向下转型
前面的 Person p = new Student(); 是把子类对象交给父类类型的变量来接收,可以理解成向上转型。
如果需要调用学生独有的 study(),就可以再转回 Student 类型:
Student s = (Student) p;
s.study();写法看起来和之前学过的强制类型转换有点像。不过,向下转型不会把对象真的变成另一种对象,只是让我们通过子类类型的变量来使用它。前提是这个对象本来就属于对应的子类类型。
例如,p 实际指向的是 Student,转换为 Student 就没问题;如果非要把它转成 Teacher,虽然某些写法能通过编译,运行时却会抛出 ClassCastException。
instanceof:先判断,再转换
如果不确定 p 实际指向哪种对象,可以先用 instanceof 判断类型:
if (p instanceof Student) {
Student s = (Student) p;
s.study();
}只有 p 指向的对象是 Student(或它的子类)时,条件才成立,随后再转换并调用 study()。这样可以避免把一个老师对象误转成学生对象。
新版 instanceof:判断和转换一起写
上面的代码还要先判断,再写一遍强制转换。Java 后来提供了更简洁的写法:
if (p instanceof Student s) {
s.study();
}这行代码可以这样理解:如果 p 指向的是 Student 对象,就把它当成 Student 类型,并命名为 s;接下来就可以直接使用 s 调用学生独有的方法。如果类型不匹配,条件为 false,也就不会执行花括号里的代码。
这种写法叫作 instanceof 模式匹配。它在 JDK 14 中以预览功能出现,从 JDK 16 开始正式支持。
下面把这几种写法放在一个完整示例中,方便对照:
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 类型统一接收学生、老师和管理员,也能在确实需要调用子类特有功能时,通过类型判断和向下转型使用子类的方法。
聊两句
评论审核后显示有疑问、补充,或者想交流一下,都可以写在这里。
评论区将在滚动到这里时加载。