多态理解
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法
多态必要条件
- 继承
- 重写
- 父类引用指向子类对象
多态简单例子
package basicForMando；
/*
* @name 多态
* @description 公共父类
* @question
* 1.Cat 是什么 和 Animal2 有关吗
* 2. instanceof 如何判断类型
* 3. (Cat)a 是什么意思 为什么带括号
* */
public class Polymorphic {
public static void main(String[] args) {
show(new Cat());//3 Cat对象调用show方法
}
// 3.1 传参new Cat() 到 a => Animal2 a = new Cat();
public static void show(Animal2 a){
//4.1 输出 new Cat().eat()
a.eat();
// 判断类型
if(a instanceof Cat){
System.out.println(a);
// instanceof Cat ?
System.out.println(a instanceof Cat);
//(Cat)a
Cat cat =(Cat)a;
//4.2 输出 Cat().work()
cat.work();
}
}
}
//1.建立父类(超类)
abstract class Animal2{
// 方法还是变量?
abstract void eat();
}
//2.继承父类
class Cat extends Animal2{
//2.1 重写父类方法(父类中没有就会报错)
public void eat(){
System.out.println("吃鱼");
}
//2.2 子类独有方法
public void work(){
System.out.println("抓老鼠");
}
}
多态复杂例子
Employee(父类超类)
package finance;
/*
* 父类(超类)
* 构造函数里 this.name 是成员变量private String name,name 为参数String name;
* */
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 是成员变量private String name,name 为参数String name;
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;
}
}
Salary(子类继承父类)
package finance;
public class Salary extends Employee {
private double salary;//全年工资
// 继承父类,子类构造函数
public Salary(String name,String address,int number,double salary){
// 传参继承的父类Employee
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;
}
}
输出
package finance;
public class VirtualDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
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();
}
}
--print--
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 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。
- 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。
以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。
多态的实现方式
多态的实现方式
方式一：重写
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。
方式二：接口
- 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
- java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。
方式三：抽象类和抽象方法
详情请看 Java抽象类 章节。
