【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、重写方法的快捷键

1. 在子类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