多态：
概述：
多态是继 封装性，继承性，面向对象的第三大特性
定义：
多态：是指同一行为具有多个不同的表现形式.
生活中：比如跑的动作：猫，狗，大象，跑起来的动作都是不一样的
飞的动作：昆虫，鸟类，人造飞机，飞起来的动作都是不一样的
可见同一行为通过不同的事物，可以表现出不同的形态.
多态描述的就是这样的一种状态
前提：
1.继承或实现【二选其一】
2.父类的引用指向子类的对象【格式体现】
3.方法的重写【意义：不重写无意义】
表现：多态表现得格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();
备注：父类类型指的是子类对象继承的父类类型，或者实现的父接口类型.
public class Fu{
public void method(){
System.out.println("父类的method方法");
}
}
//1.继承
public class Zi extends Fu{
//2.重写
@Override
public void method(){
System.out.println("子类重写后的method方法");
}
}
public class TestPolymorphismDemo01{
public static void main(String[] args){
//多态格式
/*
父类类型 变量名 = new 子类对象；
变量名.方法名();
*/
//3.父类引用指向子类的对象
Fu fu = new Zi();
fu.method();//本质调用的是子类当中重新给之后的method方法
}
}
如果在使用多态方式调用方法时，首先检查父类当中是否有该方法，
如果没有则编译直接报错，如果有执行的是子类重写后的方法
好处：
在实际开发中，父类类型作为方法的 形式参数(不同于实际参数)，传递子类对象(实参)给方法，
进行方法的调用更能体现出多态的扩展性和便利性
代码如下：
//定义一个抽象的父类
public abstract class Animal{
//定义一个抽象的方法
public abstract void eat();
}
//定义子类
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
public class Dog extends Animal{
@Override
public void eat(){
System.out.println("啃骨头");
}
}
public class TestPolyDemo03 {
public static void main(String[] args) {
//根据不同的对象来表现不同的吃的内容
Cat c = new Cat();
//showCatEat(c);//猫吃鱼
Dog d = new Dog();
//showCatEat(dog);
showAnimalEat(c);
showAnimalEat(d);
}
/*public static void showCatEat(Cat cat){
cat.eat();
}
public static void showDogEat(Dog dog){
dog.eat();
}*/
/*
以上两个方法可以用多态进行简化 可以用showAnimalEat来替代
*/
public static void showAnimalEat(Animal animal){
animal.eat();
}
}
说明：由于多态特性的支持，showAnimalEat方法中的Animal类型，是Dog和Cat的父类类型，
父类类型接收子类对象，当然可以把cat对象和dog对象传递给方法.
当程序执行过程中.执行eat方法实际执行的是各自子类对象重写之后的eat方法
不仅仅可以做到替代，在扩展性方面，无论之后出现多个子类，都不用编写showXxxEat()方法了
直接使用showAnimalEat()方法了
好处：体现在 可以使程序编写更简单，并且具有良好的扩展性.
访问类中的成员变量有两种方式（多态前提）
1.直接通过对象名访问成员变量：看等号左边是谁，优先用谁，如果没有继续往上找
2.间接的通过成员方法访问成员变量：看该方法属于谁，优先用谁，如果没有继续往上找
//定义一个父类
public class Fu{
int num = 10;
//成员方法
public void showNum(){
System.out.println(num);
}
}
//子类
public class Zi extends Fu {
int num = 20;
@Override
public void showNum(){
System.out.println(num);
}
}
//测试类
public class TestPolyFieldDemo01 {
public static void main(String[] args){
//多态的表示形式
//父类类型 变量名 = new 子类对象；
//变量名.成员变量名
Fu fu = new Zi();
System.out.println(fu.num);
fu.showNum();//10 20
}
}
引用数据类型的转型
多态的转型：分为向上转型和向下转型两种情况：
向上转型：
向上转型：多态本身就是子类类型向父类类型 向上壮转型的过程，这个过程是默认的
当一个父类引用指向了一个子类对象时，便是向上转型.
使用格式:
父类类型 变量名 = new 子类类型();
比如Animal animal = new Cat();
向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的：
一个已经向上转型的子类对象，将父类的引用又转为子类的引用，可以使用强制类型转换
使用格式：
子类类型 变量名 = (子类类型)父类变量名;
比如：Cat cat = (Cat) animal;
转型异常：
在进行向下转换的过程中，一不小心就会出现java.lang.ClassCastException类型转换异常
为了避免这种类型转换异常的发生，java就提供了 【instanceof】 关键字，给引用变量做类型的校验
格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型则返回true
如果变量不属于该数据类型则返回false
所以在转换前，我们最好先进行引用变量的类型判断，
代码如下：
public class Test{
public static void main(Stirng[] args){
//向上转形
Animal animal = new Cat();
//向下转型
if(animal instanceof Cat){
//表明你就是一只猫
Cat cat = (Cat)animal;
cat.eat();//吃鱼
cat.catchMouse();//逮老鼠
}else if(animal instanceof Dog){
//表名你就是一只狗
Dog dog = (Dog)animal;
dog.lookDoor();
}
}
}