开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第11天，点击查看活动详情

多态（ Polymorphism ）

面向对象编程-多态

多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

多态的具体体现

方法的多态

重写和重载就体现多态

对象的多态 (核心，困难，重点)

（1）一个对象的编译类型和运行类型可以不一致

（2）对象的编译类型在定义对象时，就确定了，不能改变

（3）对象的运行类型是可以变化的

（4）编译类型看定义时 = 号的左边，运行类型看 = 号的右边

多态注意事项和细节讨论

多态的前提是：
两个对象(类)存在继承关系

2 . 特点

多态的前提1：是继承
多态的前提2：要有方法的重写
父类引用指向子类对象,如：Animal a = new Cat();
多态中，编译看左边，运行看右边

多态的向上转型

（1）本质：父类的引用指向了子类的对象

（2）语法：父类类型引用名 = new 子类类型();

（3）特点：编译类型看左边，运行类型看右边。

可以调用父类中的所有成员（需遵守访问权限），不能调用子类中特有成员；最终运行效果看子类的具体实现！

package cn.tedu.oop2;
/*本类用作多态的入门案例*/
public class TestDemo {
    public static void main(String[] args) {
        //6.创建“纯纯的”对象用于测试
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();//小动物Animal吃啥都行~调用的是父类自己的功能
        c.eat();//小猫爱吃小鱼干~调用的是子类重写后的功能
        d.eat();//小狗爱吃肉骨头~调用的是子类重写后的功能
        /*2.父类对象不可以使用子类的特有功能*/
        //a.jump();//报错，Animal类里并没有这个方法
        //a.run();//报错，Animal类里并没有这个方法
        c.jump();//小猫Cat跳的老高啦~,子类可以调用自己的功能
        d.run();//小狗Dog跑的老快啦~,子类可以调用自己的功能

        //7.创建多态对象进行测试
        /*3.口诀1：父类引用指向子类对象
        * 解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存*/
        Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
        Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
        //8.测试多态对象
        /*4.口诀2：编译看左边，运行看右边
        * 解释：必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
        *      必须要在子类重写这个方法，才能满足多态，实际干活的是子类*/
        a2.eat();//小猫爱吃小鱼干~，多态对象使用的是父类的定义，子类的方法体
    }
}
/*1.多态的前提：继承+重写*/
//1.创建父类
class Animal{
    //3.创建父类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//2.1创建子类1
class Cat extends Animal{
    //4.1添加重写的方法
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //5.1添加子类的特有功能
    public void jump(){
        System.out.println("小猫Cat跳的老高啦~");
    }
}
//2.2创建子类2
class Dog extends Animal{
    //4.2添加重写的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头~");
    }
    //5.2添加子类的特有功能
    public void run(){
        System.out.println("小狗Dog跑的老快啦~");
    }
}

多态的向下转型

（1）语法：子类类型引用名 = (子类类型) 父类引用;

（2）只能强转父类的引用，不能强转父类的对象

（3）要求父类的引用必须指向的是当前目标类型的对象

（4）当向下转型后，可以调用子类类型中所有的成员

属性没有重写之说！属性的值看编译类型


//转型演示
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();
	}
}



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("老师得到高工资！");
	}
}

java 的动态绑定机制(非常非常重要)

Java 重要特性: 动态绑定机制

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

//演示动态绑定
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) 多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

说明：定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 name(姓名) 属性以及 mission() 方法；
Student 类和 Teacher 类拥有各自特有的 score 和 salary 属性,，除此之外，重写父类的 mission() 方法；
要求：最后在 main 函数中创建一个 Person 对象、一个 Student 对象和一个 Teacher 对象，统一放在数组里，并调用每个对象的 mission() 方法。

父类 Person 类：

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" + "要好好活着";
	}
}

子类 Student 类

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 + " 要好好学习！";
	}
}

子类 Teacher 类

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 + " 要好好教书！";
	}
}

编写 main 函数

/*
 * 演示多态数组
 * 创建一个 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());  
		}
	}
}

小汤 要好好活着！
小韬 要好好活着！ score = 100.0 要好好学习！
小蒲 要好好活着！ salary = 10000.0 要好好教书！

1) 多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型。代码示例：

说明：
定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 name(姓名) 属性
Student 类和 Teacher 类拥有各自特有的 study() 和 teach() 方法；
要求：最后在 main 函数中编写 test() 方法，功能是调用 Student 类的 study() 或 Teacher 类的 teach() 方法，用于演示多态参数的使用。

//演示多态参数
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" + "正在好好教书");
	}
}

小蓝同学 正在好好学习 小绿老师 正在好好教书

多态的优点

代码更加灵活：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。
提高程序的拓展性：定义方法的时候，使用父类类型作为参数，将来使用时，使用具体的子类类型操作

JAVA 面向对象------ 多态