【Java】Java进阶学习笔记(三)—— 面向对象(多态)
一、多态的概念
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:
多态性是对象多种表现形式的体现。
1、多态的优点
1. 消除类型之间的耦合关系;
2. 可替换性;
3. 可扩充性:定义方法的时候,使用父类类型作为参数,将来使用时,**使用具体的子类类型操作**
4. 接口性;
5. 灵活性:无论右边new的时候换成哪个子类对象,等号左边调用方法都不会变化。
6. 简化性
2、多态存在的三个必要条件
-
继承:在多态中必须存在有继承或实现关系的子类和父类;
-
方法的重写:子类对父类中的某些方法进行重新定义(重写,使用@Override注解进行重写)
-
父类引用指向子类对象:
Parent p = new Child()
;
class Shape {
void draw() {}
}
class Circle extends Shape {
void draw() {
System.out.println("Circle.draw()");
}
}
class Square extends Shape {
void draw() {
System.out.println("Square.draw()");
}
}
class Triangle extends Shape {
void draw() {
System.out.println("Triangle.draw()");
}
}
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示,详细说明请看注释:
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
执行以上程序,输出结果为:
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
3、多态中的成员特点
多态成员方法:编译看左边,运行看右边
此处举例Animal是父类,Dog是子类
Animal dog = new Dog(); //Animal是引用类型,Dog是实际类型
dog.eat(); //变量dog的实际类型是Dog,即是由Dog 这个实际类型new出来的,因此dog.eat() 调用的应该是子类Dog中重写的方法
4、重写方法的快捷键
- 在子类Dog中右键选择
Generate
2. 选择Override Methods然后点击生成
二、多态的转型
1、向上转型
-
本质:
父类的引用指向子类的对象 -
特点:
(1)编译类型看左边,运行类型看右边;
(2)可以调用父类的所有成员(需遵守访问权限);
(3)不能调用子类的特有成员;
(4)运行效果看子类的具体实现。 -
语法:
父类类型 引用名 = new 子类类型();
2、向下转型
- 本质:
一个已经向上转型的子类对象,将父类引用转为子类引用。
-
特点:
(1)只能强制转换父类的引用,不能强制转换父类的对象;
(2)要求父类的引用必须指向的是当前目标类型的对象;
(3)当向下转型后,可以调用子类类型中所有的成员。 -
语法:
子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式,将父类引用类型转为子类引用类型
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)运行结果:
学生要好好学习!
学生得到好成绩!
4、转型的异常
类型转换异常
说明:使用强转时,可能出现异常,对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 类型对象。
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();
}
}
}
运行结果:
学生要好好学习!
学生得到好成绩!
5、动态绑定
- 当调用对象方法的时候,该方法会和该对象的运行类型绑定
- 当调用对象属性时,没有动态绑定机制,即哪里声明,哪里使用。
代码示例:
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("学生要好好学习!");
}
}
三、多态实例
1、多态的使用
/* 文件名 : Employee.java */
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给: " + this.name
+ " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
假设下面的类继承Employee类:
/* 文件名 : Salary.java */
public class Salary extends Employee
{
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给:" + getName()
+ " ,工资为:" + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("计算工资,付给:" + getName());
return salary/52;
}
}
测试代码
/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00);
Employee e = new Salary("员工 B", "上海", 2, 2400.00);
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("\n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}
以上实例编译运行结果如下:
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck --
Salary 类的 mailCheck 方法
邮寄支票给:员工 A ,工资为:3600.0
使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法
邮寄支票给:员工 B ,工资为:2400.0
例子解析
实例中,实例化了两个 Salary 对象:一个使用 Salary 引用 s,另一个使用 Employee 引用 e。
当调用 s.mailCheck() 时,编译器在编译时会在 Salary 类中找到 mailCheck(),执行过程 JVM 就调用 Salary 类的 mailCheck()。
e 是 Employee 的引用,但引用 e 最终运行的是 Salary 类的 mailCheck() 方法。
在编译的时候,编译器使用 Employee 类中的 mailCheck() 方法验证该语句, 但是在运行的时候,Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。
以上整个过程被称为虚拟方法调用,该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现,因此,重写的方法能在运行时调用,不管编译的时候源代码中引用变量是什么数据类型。
2、多态数组
多态数组:数组的定义类型为父类类型,里面保存的实际元素类型为子类类型。
代码示例:(循环调用基类对象,访问不同派生类的方法)
说明:
定义一个 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 要好好教书!
3、多态参数
多态参数:方法定义的形参类型为父类类型,实参类型允许为子类类型。
代码示例:
说明:
定义一个 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" + "正在好好教书");
}
}
运行结果:
小蓝同学 正在好好学习
小绿老师 正在好好教书
四、多态的实现方式
方式一:重写
这个内容已经在上一章节详细讲过,就不再阐述,详细可访问:Java 重写(Override)与重载(Overload)。
方式二:接口
1. 生活中的接口最具代表性的就是插座,例如一个三接头的插头都能接在三孔插座中,因为这个是每个国家都有各自规定的接口规则,有可能到国外就不行,那是因为国外自己定义的接口类型。
2. java中的接口类似于生活中的接口,就是一些方法特征的集合,但没有方法的实现。
方式三:抽象类和抽象方法
参考博客:
https://blog.csdn.net/z972065491/article/details/127220556