【Java】面向对象之多态
生活中，比如动物中跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一类的事物通过不同的实际对象可以体现出来的不同的形态。多态，描述的就是这样的状态。
多态： 是指同一行为，具有多个不同表现形式。
具备多态的前提：
（1）具备继承或者实现【二选一】；
（2）方法的重写【不重写，无意义】；
（3）父类引用指向子类对象【格式体现】。
多态的体现
多态体现的格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();
注意事项：父类类型指子类对象继承的父类类型，或者实现的父接口类型。
定义父类：
public class Fu { public void method() { System.out.println("父类方法"); } public void methodFu() { System.out.println("父类特有方法"); } }
定义子类：
public class Zi extends Fu { @Override public void method() { System.out.println("子类方法"); } }
定义测试类：
public class Demo { public static void main(String[] args) { // 使用多态的写法 // 左侧父类的引用，指向了右侧子类的对象 Fu obj = new Zi(); obj.method(); obj.methodFu(); } }
1、访问成员变量
定义父类：
public class Fu { int num = 10; public void showNum() { System.out.println(num); } }
定义子类：
public class Zi extends Fu { int num = 20; int age = 16; @Override public void showNum() { System.out.println(num); } }
（1）直接通过对象名称访问成员变量
定义测试类：
public class Demo{ public static void main(String[] args) { Fu obj = new Zi(); System.out.println(obj.num); // 父：10 } }
看 “=” 左边是谁，优先用谁，没有则向上找。
（2）间接通过成员方法访问成员变量
定义测试类：
public class Demo { public static void main(String[] args) { Fu obj = new Zi(); // 子类没有覆盖重写，就是父：10 // 子类如果覆盖重写，就是子：20 obj.showNum(); } }
看该方法属于谁，优先用谁，没有则向上找。
现在我们将上面的测试类添加一段代码，代码如下：
public class Demo{ public static void main(String[] args) { Fu obj = new Zi(); obj.showNum(); System.out.println(obj.age); } }
你会发现编译的时候报错了，这是为什么呢？
那是因为 “=” 左边时父类，但是父类当中没有 age 成员变量，所以编译报错。因此：
成员变量：编译看左边，运行也看左边。
1、访问成员方法
定义父类：
public class Fu {public void method() { System.out.println("父类方法"); } public void methodFu() { System.out.println("父类特有方法"); } }
定义子类：
public class Zi extends Fu { @Override public void method() { System.out.println("子类方法"); } public void methodZi() { System.out.println("子类特有方法"); } }
定义测试类：
public class Demo { public static void main(String[] args) { Fu obj = new Zi(); // 父子都有，优先用子类 obj.method(); // 子类方法 // 子类没有，父类有，向上找到父类 obj.methodFu(); // 父类特有方法 } }
看 new 的是谁，就优先用谁，没有则向上找。
现在我们将上面的测试类添加一段代码，代码如下：
public class Demo { public static void main(String[] args) { Fu obj = new Zi(); obj.method(); obj.methodFu(); obj.methodZi(); } }
你会发现编译时直接就报错了，这是为什么呢？
那是因为 “=” 左边时父类，但是父类当中没有 methodZi 方法，所以编译报错。因此：
成员方法：编译看左边，运行看右边。
多态的好处
先看一组例子，定义父类：
public abstract class Animal { public abstract void eat(); }
定义子类：
// 子类Cat public class Cat extends Animal {
@Override public void eat() { System.out.println("吃鱼"); } } // 子类Dog public class Dog extends Animal {
@Override public void eat() { System.out.println("吃骨头"); } }
如果不使用多态的方式，测试类代码如下：
public class Demo { public static void main(String[] args) { Cat cat = new Cat(); cat.eat(); Dog dog = new Dog(); dog.eat(); } }
public class Demo { public static void main(String[] args) { Animal cat = new Cat(); cat.eat(); Animal dog = new Dog(); dog.eat(); } }
因此，无论右边 new 的是哪个子类对象，“=” 左边调用方法都不会发生变化。
再看一组例子，子类和父类的与上面一样，请注意测试类代码。
如果不使用多态的方式：
public class Demo { public static void main(String[] args) { Cat cat = new Cat(); Dog dog = new Dog(); // 调用showCatEat showCatEat(cat); // 调用showDogEat showDogEat(dog); } public static void showCatEat(Cat c) { c.eat(); } public static void showDogEat(Dog d) { d.eat(); } }
如果使用多态的形式：
public class Demo { public static void main(String[] args) { // 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致 showAnimalEat(cat); showAnimalEat(dog); } public static void showAnimalEat(Animal a) { a.eat(); } }
因此：
（1）由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
（2）当eat方法执行时多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
（3）不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处体现在可以使程序编写的更简单并有良好的扩展。实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法进行方法的调用，更能体现出多态的扩展性与便利。
多态转型
多态的转型分为向上转型与向下转型两种。
定义父类：
public abstract class Animal { public abstract void eat(); }
定义子类：
// 子类Cat public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } public void catchMouse() { System.out.println("猫抓老鼠"); } } // 子类Dog public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃SHIT"); } public void watchHouse() { System.out.println("狗看家"); } }
1、向上转型
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型，使用格式如下：
父类类型 变量名 = new 子类类型();
定义测试类：
public class Demo { public static void main(String[] args) { // 对象的向上转型就是：父类引用指向之类对象。 Animal animal = new Cat(); // 本来创建的时候是一只猫 animal.eat(); // 猫吃鱼 // animal.catchMouse(); // 错误写法！ } }
向上转型一定是安全的，没有问题的。但是也有一个弊端：对象一旦向上转型为父类就无法调用子类原本特有的内容（如标红的代码）。
如何解决这个这个问题呢？答案是向下转型。
2、向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。使用格式如下：
子类类型 变量名 = (子类类型) 父类变量名;
父类和子类的代码与上述一致，测试代码如下：
public class Demo { public static void main(String[] args) { Animal animal = new Cat(); animal.eat(); // 向下转型，进行“还原”动作 Cat cat = (Cat) animal; cat.catchMouse(); // 猫抓老鼠 // 下面是错误的向下转型，错误写法！编译不会报错，但是运行会出现异常 // 本来new的时候是一只猫，现在非要当做狗 Dog dog = (Dog) animal; // java.lang.ClassCastException，类转换异常 } }
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
3、转型异常（ClassCastException）
为了避免ClassCastException的发生（向下转型已经提到过），Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true；
如果变量不属于该数据类型，返回false。
如果变量不属于该数据类型，返回false。
所以，转换前我们最好先做一个判断，代码如下：
public class Demo { public static void main(String[] args) { Animal animal = new Dog(); // 本来是一只狗 animal.eat(); // 狗吃SHIT // 如果希望掉用子类特有方法，需要向下转型 // 判断一下父类引用animal本来是不是Dog if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.watchHouse(); } // 判断一下animal本来是不是Cat if (animal instanceof Cat) { Cat cat = (Cat) animal; cat.catchMouse(); } // 实际开发的时候更多的是单独抽离出来使用 pet(new Dog()); } public static void pet(Animal animal) { if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.watchHouse(); } if (animal instanceof Cat) { Cat cat = (Cat) animal; cat.catchMouse(); } } }
