Java/多态（对象的转型）

多态

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人的“休息”方法，张三是睡觉，李四是旅游，数学教授是做数学题; 同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。
多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

多态的优缺点：
多态的主要优势是提高了代码的可扩展性，符合开闭原则。但是多态也有弊端，就是无法调用子类特有的功能（比如例二中不能使用父类的引用变量调用Dog类特有的seeDoor()方法）

package TestTextbook;

/**
 * @author cc
 * @date 2020年3月24日
*/
public class TestPoly {
public static void main(String[] args) {
//目前没发现多态的意义，略略略
	/*Fruit cc = new Fruit();
	cc.colour();
	Apple wang = new Apple();
	wang.colour();*/
	//多态产生
	Fruit cc1 = new Apple();
	FruitCol(cc1);
	Fruit cc2 = new Banana();
	FruitCol(cc2);
}
//传值
static void FruitCol(Fruit cc){
	cc.colour();
}
}

class Fruit{
	public void colour() {
		System.out.println("a riot of colour");
	}
	
}
class Apple extends Fruit{

	@Override
	public void colour() {
		System.out.println("red");
	}

}

class Banana extends Fruit{
	@Override
	public void colour() {
		System.out.println("yellow");
	}

}

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("汪汪汪！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
         
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }
 
    /* 如果没有多态，我们这里需要写很多重载的方法。
     * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}

运行结果：
喵喵喵！
汪汪汪！
开门中……

对象的转型

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!

public class TestCasting {
	public static void main(String[] args) {
		Object obj = new String("小王"); // 向上可以自动转型
		// obj.charAt(0) 无法调用。编译器认为obj是Object类型而不是String类型
		/* 编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
		 * 不然通不过编译器的检查。 */
		String str = (String) obj; // 向下转型
		System.out.println(str.charAt(0)); // 位于0索引位置的字符
		System.out.println(obj == str); // true.他们俩运行时是同一个对象
	}
}

运行结果：
小
true