面向对象中的多态性

一、多态的概述

什么是多态性？

继承性是多态性的前提，一个对象拥有多个形态，这就是对象的多态性多态性
举例说明：
父类为人类，子类为学生，此时创建一个对象叫做小明，这个小明对象既是学生也是人类，这就是多态性的体现

---

二、多态的格式及使用

1、代码当中如何体现多态性？

       答：父类引用指向子类对象

多态的格式如下：

//	(1)
	父类名称 对象名 = new 子类名称();
//	(2)
	接口名称 对想名 = new 实现类名称();

2、 多态中成员变量和成员方法的使用特点

（1）访问成员变量的两种方式：

① 直接通过对象名访问成员变量时，看等号左边是谁则优先用谁，没有则向上找
举例说明：

// 定义了一个父类
public class Fu {
	int num = 10;
}
// 定义了一个子类继承父类
public class Zi extends Fu {
	int num = 20;
}
// 创建一个代码启动入口类
public class Start {
	public static void main(String[] args) {
	// 定义一个多态写法：父类引用指向子类
		Fu obj = new Zi();
		// 打印输出obj.num
		// 直接通过对象名访问num变量，
		// 看等号左边是谁则优先用谁
		// 没有则向上找(虽然已经是父类了，但是还可以向上找，父类的父类是Object)
		// 等号左边是父类，所以打印输出是10，而不是20
		System.out.println(obj.num);//结果为10
	}
}

② 间接通过成员方法访问成员变量，看该方法属于谁则优先用谁，没有则向上找
举例说明：

// 定义了一个父类
public class Fu {
	int num = 10;
	public void showNum() {
		System.out.println(num);
	}
}
// 定义了一个子类继承父类
public class Zi extends Fu {
	int num = 20;
	// 覆盖重写showNum
	@Override
	public void showNum() {
		System.out.println(num);
	}
}
// 创建一个代码启动入口类
public class Start {
	public static void main(String[] args) {
	// 定义一个多态写法：父类引用指向子类
		Fu obj = new Zi();
		/*
		* 注意：
		* 子类如果没有覆盖重写showNum方法，那么就使用父类方法，结果为10
		* 子类如果覆盖重写showNum方法，那么就使用子类方法，结果为20
		*/
		obj.showNum()
	}
}

口诀：编译看左边，运行还看左边

（2）访问成员方法的规则：看new是谁，就优先用谁，没有则向上找

举例说明：

// 定义了一个父类
public class Fu {
	int num = 10;
	public void showNum() {
		System.out.println(num);
	}
	public void method() {
		System.out.println("父类方法执行");
	}
	public void methoFu() {
		System.out.println("父类特有方法执行");
	}
}
// 定义了一个子类继承父类
public class Zi extends Fu {
	int num = 20;
	// 覆盖重写showNum
	@Override
	public void showNum() {
		System.out.println(num);
	}
	@Override
	public void method() {
		System.out.println("子类覆盖重写方法执行");
	}
	public void methoZi() {
		System.out.println("子类特有方法执行");
	}
}
// 创建一个代码启动入口类
public class Start {
	public static void main(String[] args) {
	// 定义一个多态写法：父类引用指向子类
		Fu obj = new Zi();
		// 成员方法的调用规则：看new是谁，就优先用谁，没有则向上找
		// 子类覆盖重写了父类的方法，优先用子类
		obj.showNum();
		obj.method();
		// 子类没有，父类有，则向上找使用父类
		obj.methodFu();
		
		// 错误写法！！！
		// 口诀是编译看左，运行看右。
		// 编译过程中看左边，左边是Fu，Fu中没有methodZi方法，座椅编译报错
		obj.methodZi();
		
	}
}

口诀：编译看左边，运行看右边

---

三、多态的优势

举个例子：
有一个含有work()抽象方法的员工类作为父类。还有两个子类，分别是讲师类和助教类，其中讲师类包含work(){讲课}的方法，主教类中包含work(){辅导}的方法

如果我们不用多态，只用子类创建讲师对象和助教对象，写法为

	Teacher one = new Teacher();
	one.work();// 讲课方法
	Assistant two = new Assistant();
	two.work();// 辅导方法

使用多态的写法为

	Employee one = new Teacher();
	one.work();// 讲课方法
	Employee two = new Assistent();
	two.work();// 辅导方法

当我们只想调用work方法，其他功能不关心的时候，就会发现使用多态的写法无论右边new的是偶换成哪个子类对象，等号左边的调用方法都不会变化

---

四、对象的上下转型

1、对象的向上转型

（1）向上转型的写法：
其实就是多态的写法，格式为

	父类名称 对象名 = new 子类名称();

（2）向上转型的含义：
创建了一个子类对象，把他当作父类来看待

举例如下：
情景为，父类为动物类，子类为猫类

	Aninmal cat = new Cat();

注意事项：
向上转型一定是安全的，没有问题的，正确的，为了便于理解我们可以把它看作是“数据类型转换的过程”，数据类型转换是从小范围到大范围，向上转型也是从子类范围到父类范围

2、对象的向下转型

（1）向下转型的写法为：

	子类名称 对象名 = (子类名称)父类对象;

举例解释：

// 含义：将向上转型为动物对象，还原为原本的猫对象
	Aninmal animal= new Cat();
	Cat cat = (cat)animal;

注意事项：
向下转型的时候必须保证向下转型为原来的的类，如果向下转型为不是原来的对象那么编译会报错