最新在学习JAVASE的时候碰到了JAVA特性之一：多态，并且对多态引出的类型转换问题（upcast和downcast）很迷茫，故自己手写了代码进行测试验证，在此记录一下。
1.多态是同一个行为具有多个不同表现形式或形态的能力。
2.多态就是同一个接口，使用不同的实例而执行不同操作：
想象这样一个场景下：
在银行进行创建一个新的账户时，银行可能需要登记下持卡人的性别，但是在进行创建之前即我们写下创建账户的代码时，我们是无法确定持卡人的性别的，但是有一点可以确定的是持卡人不论男人(Man)还是女人(Woman)他们都是属于人(Person)这一类的，在没有JAVA多态这一性质时我们可能需要分别针对男性和女性这两种性别去写两个创建账户的方法。而JAVA中的多态可以解决这个问题，即我们只需要将持卡人所属的基类传入我们的函数即可。
// 1.
// 创建账户的方法，形参为持卡人，返回一个账户
public Account creatCount(持卡人){
....
}
// 2.
// 在没有多态特性时，需要针对性别写下两个方法
public Account creatCount(Man m){
....
}
public Account creatCount(Woman w){
....
}
// 3.
// 在有多态特性时，只需将Man、Woman所属的基类Person传入即可：
public Account creatCount(Person p){
....
}
可见JAVA中的多态特性可以减少代码的编写，避免同一个方法的重载，提高代码复用性。
1.我们可以将一个衍生类引用转换为其基类引用，这叫做向上转换(upcast)或者宽松转换。
2.将一个基类引用向下转型(downcast)成为衍生类的引用，但要求该基类引用所指向的对象
下面代码中:
创建了一个基类Animal，类Cat和类Dog继承类Animal，并对Animal类中的getName、eat、shout方法进行重写；
类Cat和类Dog中分别有一个自己独有的方法：cute方法和watchDoor方法；
创建了Test类进行测试，其中Test类中出了main方法，还包括一个打印动物基本信息的方法：printInfo；
package test;
public class Test{
public static void main(String[] args){
Test t = new Test();
// upcast
Animal a = new Cat("咪咪");
Animal b = new Dog("旺财");
// a is a cat
t.printInfo(a);
a.eat();
a.shout();
System.out.println("*************");
// b is a dog
t.printInfo(b);
b.getName();
b.eat();
b.shout();
System.out.println("*************");
// downcast
Cat c = (Cat) a;
Dog d = (Dog) b;
// 调用Cat和Dog中各自特有的方法
c.Cute();
d.watchDoor();
}
public void printInfo(Animal animal){
System.out.println("我是 " + animal.getKind() + ", 我的名字叫 " + animal.getName());
}
}
abstract class Animal{
private String kind; // 动物的种类
public Animal(String kind){
this.kind = kind;
}
public String getKind() {
return kind;
}
public abstract String getName();
public abstract void eat();
public abstract void shout();
}
class Cat extends Animal{
private String name; // 动物的名字
public Cat(String name){
super("cat");
this.name = name;
}
// 重写Animal类中的getName方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 重写Anmial类中的eat方法
public void eat(){
System.out.println("cat eat fish");
}
// 重写Anmial类中的shout方法
public void shout(){
System.out.println("喵喵喵~");
}
// Cat类中独有的方法：可爱
public void Cute(){
System.out.println("我很可爱~");
}
}
class Dog extends Animal{
private String name; // 动物的名字
public Dog(String name){
super("dog");
this.name = name;
}
// 重写Animal类中的getName方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 重写Anmial类中的eat方法
public void eat(){
System.out.println("dog eat bone");
}
// 重写Anmial类中的shout方法
public void shout(){
System.out.println("汪汪汪！");
}
// dog类中独有的方法：看门
public void watchDoor(){
System.out.println("我是dog可以看门！");
}
}
程序运行结果：
我是 cat, 我的名字叫 咪咪
cat eat fish
喵喵喵~
*************
我是 dog, 我的名字叫 旺财
dog eat bone
汪汪汪！
*************
我很可爱~
我是dog可以看门！
下面结合代码对upcast和downcast分别进行解析：
public void printInfo(Animal animal)，具体调用代码：t.printInfo(a); t.printInfo(b);可见printInfo方法需要传入的参数是Animal类的，而我们的a和b是满足条件的，分别打印出了猫和狗的信息，即说明在调用方法是使用的是子类中的方法。此外a.eat(); a.shout();以及b.eat();b.shout();也分别打印出了猫和狗的对应信息；Cat c = (Cat) a;Dog d = (Dog) b;是downcast的体现，即将指向子类的基类强制转换为原来的子类，此时便可调用子类中独有的方法：c.Cute();d.watchDoor();而a和b是无法调用cat和dog类中独有的方法的，即a和b只能调用基类Animal中的方法，当调用子类的方法时运行会报错，例如a调用Cat类中的独有方法cute，运行报错，具体如下图所示：
1.面对多态时，明确“编译看左，运行看右”原则；
2.多态特性可以可以减少代码的编写，避免同一个方法的重载，提高代码通用性；
3.明确只有进行downcast后，才可调用子类中独有的方法；