多态与对象转型

对象转型有以下几条规则：

1）一个基类的引用类型变量可以“指向”其子类的对象；

2）一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）；

3）可以使用引用变量 instanceof  类名 来判断该引用变量所“指向”的对象是否属于该类或该类的子类

4）子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）。

下面看一个小程序：

public class Test01 {
	public static void main(String[] args){
		Test01 test = new Test01();
		Animal a = new Animal("name");
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("Dogname","yellow");
		test.f(a);
		test.f(c);
		test.f(d);
	}
	public void f(Animal a){
		System.out.println("name: "+ a.name);
		if(a instanceof Cat)
		{
			Cat cat = (Cat) a;
			System.out.println( " " + cat.color +" eyes");
		}else if(a instanceof Dog){
			Dog dog = (Dog)a;
			System.out.println(" "+dog.fur +" fur");
		}
	}
}
class Animal{
	public String name;
	public Animal(String name){
		this.name = name;	
	}
}
class Cat extends Animal{
	public String color;
	public Cat(String name,String color){
		super(name);
		this.color = color;
	}
	
}
class Dog extends Animal{
	public  String fur;
	public Dog(String name,String fur){
		super(name);
		this.fur = fur;	
	}
}

输出结果：

name: name
name: catname
 blue eyes
name: Dogname
 yellow fur

简单分析：

public void f(Animal a){ ...}参数为基类引用，基类引用“指向”子类对象，可扩展性较好。

######################################################################

下面了解一下面向对象中最核心的一个机制--动态绑定或者多态

所谓动态绑定是指“在执行期间”（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用相应的方法。

下面是一个小程序：

public class Test02 {
	public static void main(String[] args){
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("dogname","yellow");
		Lady l1 = new Lady("Lucy",c);
		Lady l2 = new Lady("Lily",d);
		l1.myPetEnjoy();
		l2.myPetEnjoy();
	}
}
class Animal{
	private String name;
	Animal(String name){
		this.name = name;
	}
	public void enjoy() {
		System.out.println("哈哈哈");
		
	}
	
}
class Cat extends Animal{
	private String color;
	Cat(String n,String c){
		super(n);
		this.color = color;
	}
	public void enjoy(){
		System.out.println("喵喵喵");
	}
}
class Dog extends Animal{
	private String furcolor;
	Dog(String s,String n){
		super(s);
		this.furcolor = n;
	}
	public void enjoy(){
		System.out.println("旺旺旺");
	}
}
class Lady{
	private String name;
	private Animal pet;
	Lady(String name ,Animal pet){
		this.name = name;
		this.pet = pet;
	}
	public void myPetEnjoy(){
		pet.enjoy();
	}
}

输出结果：

喵喵喵
旺旺旺

分析：

动态绑定或者多态使得程序的扩展性达到最优！

多态的存在必须有三个条件：

1）要有继承

2）要有重写

3）父类引用指向子类对象