目录
1. 基本介绍
1.1 多态的概念
- 多态是方法或对象具有多种形态,是面向对象的第三大特征。
- 多态的前提是两个对象(类)存在继承关系,多态是建立在封装和继承基础之上的。
1.2 多态的具体体现
对象的多态是多态的核心和重点。
规则:
- 一个对象的编译类型与运行类型可以不一致
- 编译类型在定义对象时,就确定了,不能改变,而运行类型是可以变化的
- 编译类型看定义对象时 = 号的左边,运行类型看 = 号的右边
1.3 入门案例
说明:
- 定义一个 Person 类 作为父类,定义 Student 类 和 Teacher 类作为子类继承父类;
- Person 类 拥有 mission() 方法;
- Student 类 和 Teacher 类 重写父类的 mission() 方法;
- 最后在 main 函数中利用多态形式创建对象。
代码如下:
(1)定义父类 Person 类:
package Polymorphism;
public class Person {
public void mission() {
System.out.println("人要好好活着!");
}
}
(2)定义子类 Student 类:
package Polymorphism;
public class Student extends Person {
@Override
public void mission() {
System.out.println("学生要好好学习!");
}
}
(3)定义子类 Teacher 类
package Polymorphism;
public class Teacher extends Person {
@Override
public void mission() {
System.out.println("老师要好好教书!");
}
}
(4)在 Test01 类中编写 main 函数,体现多态性
package Polymorphism;
//多态性
public class Test01 {
public static void main(String[] args) {
//多态形式,创建对象
//注意编译类型看等号左边,运行类型看等号右边
Person p1 = new Student();
//此时调用的是 Student 类 的 mission() 方法
p1.mission();
//多态形式,创建对象
Person p2 = new Teacher();
//此时调用的是 Teacher 类 的 mission() 方法
p2.mission();
}
}
(5)运行结果
学生要好好学习!
老师要好好教书!
2. 多态的转型
2.1 向上转型
-
本质:父类的引用指向子类的对象
-
特点:
- 编译类型看左边,运行类型看右边
- 可以调用父类的所有成员(需遵守访问权限)
- 不能调用子类的特有成员
- 运行效果看子类的具体实现
- 语法:
父类类型 引用名 = new 子类类型();
//右侧创建一个子类对象,把它当作父类看待使用
2.2 向下转型
-
本质:一个已经向上转型的子类对象,将父类引用转为子类引用
-
特点:
- 只能强制转换父类的引用,不能强制转换父类的对象
- 要求父类的引用必须指向的是当前目标类型的对象
- 当向下转型后,可以调用子类类型中所有的成员
- 语法:
子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式,将父类引用类型转为子类引用类型
2.3 代码示例
说明:
- 定义一个 Person 类 作为父类,定义 Student 类 和 Teacher 类作为子类继承父类;
- Person 类 拥有 mission() 方法;
- Student 类 和 Teacher 类 重写父类的 mission() 方法 并且 分别拥有各自的特有的 score() 方法 和 salary() 方法;
- 最后在 main 函数中 演示转型。
代码如下:
(1)定义类:
package Poly_;
public class Person {
public void mission() {
System.out.println("人要好好活着!");
}
}
class Student extends Person {
@Override
public void mission() {
System.out.println("学生要好好学习!");
}
public void score() {
System.out.println("学生得到好成绩!");
}
}
class Teacher extends Person {
@Override
public void mission() {
System.out.println("老师要好好教书!");
}
public void salary() {
System.out.println("老师得到高工资!");
}
}
(2)在 Test02 类中编写 main 函数,演示转型
package Poly_;
//转型演示
public class Test02 {
public static void main(String[] args) {
//向上转型(自动类型转换)
Person p1 = new Student();
//调用的是 Student 的 mission
p1.mission();
//向下转型
Student s1 = (Student)p1;
//调用的是 Student 的 score
s1.score();
}
}
(3)运行结果:
学生要好好学习!
学生得到好成绩!
2.4 转型的异常
2.4.1 类型转换异常
说明:使用强转时,可能出现异常,对2.3代码示例中的 Test02类 重新编写,演示转型异常
代码如下:
//异常演示
public class Test02 {
public static void main(String[] args) {
//向上转型
Person p1 = new Student();
//调用的是 Student 的 mission
p1.mission();
//向下转型
Teacher t1 = (Teacher) p1;
//运行时报错
p1.salary();
}
}
解释:这段代码在运行时出现了 ClassCastException 类型转换异常,原因是 Student 类与 Teacher 类 没有继承关系,因此所创建的是Student 类型对象在运行时不能转换成 Teacher 类型对象。
2.4.2 instanceof 比较操作符
为了避免上述类型转换异常的问题,我们引出 instanceof 比较操作符,用于判断对象的类型是否为XX类型或XX类型的子类型。
- 格式:对象 instanceof 类名称
- 解释:这将会得到一个boolean值结果,也就是判断前面的对象能不能当作后面类型的实例
- 代码示例 :
package Poly_;
//演示 instanceof 的使用
public class Test03 {
public static void main(String[] args) {
//向上转型
Person p1 = new Student();
//调用的是 Student 的 mission
p1.mission();
//向下转型
//利用 instanceof 进行判断
if(p1 instanceof Student) {
//判断对象 p1 是否是 Student 类 的实例
Student s1 = (Student)p1;
s1.score(); //调用的是 Student 的 score
//上面这两句也可简写为 ((Student) p1).score();
}
else if(p1 instanceof Teacher){
//判断对象 p1 是否是 Teacher 类 的实例
Teacher t1 = (Teacher)p1;
t1.salary(); //调用的是 Teacher 的 salary
//同理,上面这两句也可简写为 ((Teacher) p1).salary();
}
}
}
- 运行结果:
学生要好好学习!
学生得到好成绩!
3.动态绑定(重点)
- 当调用对象方法的时候,该方法会和该对象的运行类型绑定
- 当调用对象属性时,没有动态绑定机制,即哪里声明,哪里使用。
- 代码示例:
package dynamic_;
//演示动态绑定
public class DynamicBinding {
public static void main(String[] args) {
//向上转型(自动类型转换)
//程序在编译阶段只知道 p1 是 Person 类型
//程序在运行的时候才知道堆中实际的对象是 Student 类型
Person p1 = new Student();
//程序在编译时 p1 被编译器看作 Person 类型
//因此编译阶段只能调用 Person 类型中定义的方法
//在编译阶段,p1 引用绑定的是 Person 类型中定义的 mission 方法(静态绑定)
//程序在运行的时候,堆中的对象实际是一个 Student 类型,而 Student 类已经重写了 mission 方法
//因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法(动态绑定)
p1.mission();
}
}
//父类
class Person {
public void mission() {
System.out.println("人要好好活着!");
}
}
//子类
class Student extends Person {
@Override
public void mission() {
System.out.println("学生要好好学习!");
}
}
- 运行结果:
学生要好好学习!
4. 应用
4.1 多态数组
多态数组:数组的定义类型为父类类型,里面保存的实际元素类型为子类类型。
代码示例:(循环调用基类对象,访问不同派生类的方法)
- 说明:
- 定义一个 Person 类 作为父类,定义 Student 类 和 Teacher 类 作为子类继承父类;
- Person 类 拥有 name(姓名) 属性 以及 mission() 方法;
- Student 类 和 Teacher 类 拥有各自特有的 score 和 salary 属性,,除此之外,重写父类的 mission() 方法 ;
- 要求:最后在 main 函数中 创建一个 Person 对象 、一个 Student 对象 和 一个 Teacher 对象,统一放在数组里,并调用每个对象的 mission() 方法。
- 代码如下:
(1)父类 Person 类:
package polyarr;
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
// getter 和 setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// mission() 方法
public String mission() {
return name + "\t" + "要好好活着";
}
}
(2)子类 Student 类
package polyarr;
public class Student extends Person {
private double score;
public Student(String name, double score) {
super(name);
this.score = score;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
//重写父类的say方法
@Override
public String mission() {
return super.mission() + " score =" + score + " 要好好学习!";
}
}
(3)子类 Teacher 类
package polyarr;
public class Teacher extends Person {
private double salary;
public Teacher(String name, double salary) {
super(name);
this.salary = salary;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//重写父类的 mission 方法
@Override
public String mission() {
return super.mission() + " salary =" + salary + " 要好好教书!";
}
}
(4)PolyArray 类 中编写 main 函数
package polyarr;
/* * 演示多态数组 * 创建一个 Person 对象 * 创建一个 Student 对象 * 创建一个 Teacher 对象 * 统一放在数组里,并调用每个对象的 mission() 方法。 */
public class PolyArray {
public static void main(String[] args) {
Person[] persons = new Person[3];
persons[0] = new Person("小汤");
persons[1] = new Student("小韬", 100);
persons[2] = new Teacher("小蒲", 10000);
//循环遍历多态数组,调用 mission
for(int i = 0; i < persons.length; i++) {
//此处涉及动态绑定机制
// Person[i] 编译类型是 Person ,运行类型根据实际情况由 JVM 判断
System.out.println(persons[i].mission());
}
}
}
(5)运行结果:
小汤 要好好活着!
小韬 要好好活着! score = 100.0 要好好学习!
小蒲 要好好活着! salary = 10000.0 要好好教书!
4.2 多态参数
多态参数:方法定义的形参类型为父类类型,实参类型允许为子类类型。
代码示例:
- 说明:
- 定义一个 Person 类 作为父类,定义 Student 类 和 Teacher 类作为子类继承父类;
- Person 类 拥有 name(姓名) 属性
- Student 类 和 Teacher 类 拥有各自 特有 的 study() 和 teach() 方法 ;
- 要求:最后在 main 函数中 编写 test() 方法 ,功能是调用 Student 类 的 study() 或 Teacher 类 的 teach() 方法,用于演示 多态参数 的使用。
- 代码如下:
package polyparameter;
//演示多态参数
public class PolyParameter {
public static void main(String[] args) {
Student s1 = new Student("小蓝同学");
Teacher t1 = new Teacher("小绿老师");
//需先 new 一个当前类的实例化,才能调用 test 方法
PolyParameter polyParameter = new PolyParameter();
//实参是子类
polyParameter.test(s1);
polyParameter.test(t1);
}
//定义方法test,形参为 Person 类型(形参是父类)
//功能:调用学生的study或教师的teach方法
public void test(Person p) {
if (p instanceof Student){
((Student) p).study(); //向下转型
}
else if (p instanceof Teacher){
((Teacher) p).teach(); //向下转型
}
}
}
//父类
class Person {
private String name;
//有参构造
public Person(String name) {
this.name = name;
}
// getter 和 setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//子类
class Student extends Person {
public Student(String name) {
super(name);
}
// study() 方法
public void study() {
System.out.println(super.getName() + "\t" + "正在好好学习");
}
}
class Teacher extends Person {
public Teacher(String name) {
super(name);
}
// teach() 方法
public void teach() {
System.out.println(super.getName() + "\t" + "正在好好教书");
}
}
- 运行结果:
小蓝同学 正在好好学习
小绿老师 正在好好教书
5. 多态的优点
- 代码更加灵活:无论右边new的时候换成哪个子类对象,等号左边调用方法都不会变化。
- 提高程序的拓展性:定义方法的时候,使用父类类型作为参数,将来使用时,使用具体的子类类型操作
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:http://bianchenghao.cn/38941.html