Java学习之多态（Polymorphism）

多态是java面向对象的核心之一，因为它最大程度的提高了程序的可拓展性。

实现多态的三个条件：

• 有继承关系
• 有方法重写
• 有父类引用指向子类对象

1、多态的简单实现

/*
abstract class Animal {
	public String name; 
	
	Animal(String name) {
		this.name=name;
	}
	abstract public void enjoy();
}
*/
class Animal{
	public String name;
	Animal(String name) {
		this.name=name;
	}
	public void enjoy() {
		System.out.println("动物叫....");
	}
}

class Cat extends Animal {
	public String eyeColor;
	
	Cat(String name, String eyeColor) {
		super(name);
		this.eyeColor = eyeColor;
		
	}
	public void enjoy() {
		System.out.println("猫叫....");
	}
}


class Dog extends Animal{
	 public String furColor;
	 
	 Dog(String name, String furColor) {
		 super(name);
		 this.furColor=furColor;
	 }
	 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();
	}	
}

public class testClass {
	
	public void f(Animal p) {
		System.out.println("name=" + p.name);
		if(p instanceof Cat) {
			Cat q = (Cat)p;
			System.out.println("eyeColor=" + q.eyeColor);
		} else if(p instanceof Dog) {
			Dog q = (Dog)p;
			System.out.println("furColor=" + q.furColor);
		}
		
	}

	public static void main(String[] args) {
		//Animal ani = new Animal("name");//抽象类不能new出对象来，即抽象类不能实例化。
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("dogname","black");
		Lady l1 = new Lady("l1",c);
		Lady l2 = new Lady("l2",d);
		
		l1.myPetEnjoy();
		l2.myPetEnjoy();
	}

}

2、这样写也是多态，注意区别继承和转型。

public class TestExtends {

	public static void main(String[] args) {
		Sun s = new Sun();
		s.f();
		Father f = (Father)s;
		f.f();
		System.out.println(f.value);
		Father ff = s;
		ff.f();
		System.out.println(ff.value);
	}
}

class Father{
	public int value = 100;
	public void f(){
		System.out.println("father");
	}
}

class Sun extends Father{
	public int value = 150;
	public void f(){
		System.out.println("child");
	}
}

这里的输出是：

child
child
100
child
100

第一个child:：因为子类sun对父类Father的 f() 方法进行了重写，所以，这里调用的是重写后的 f ()方法..

第二个child：这里满足继承、重写、父类引用指向子类对象，故表现为多态，调用的仍然是对象实际类型的f()方法，输出child.

第三个100：因为f 是指向子类对象的父类引用，所以该引用只能看到父类的成员变量，而看不到子类的成员变量，这里表现为转型的屏蔽性，而不是多态，多态是针对方法的。

第四个child：同第二

第五个100：同第三