Java之多态



Java中面向对象最核心的东东——多态。通过多态使我们的程序复用性和可扩展性更好。

多态，也叫动态绑定或迟绑定，是指在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。简单理解为只要子类方法重写了，实际当中new的是哪个的方法，调用的就是哪个的方法来进行实现。

动态绑定的条件：有继承、有重写、父类引用指向子类对象

通过如下toy program来说明多态的好处及其实现方式。

abstract class Animal{   //有抽象方法的类必须是抽象类
	private String name;
	Animal(String name) { this.name =  name;}
		
	//抽象方法，只有被定义，由子类去重写实现
	public abstract void enjoy();
}

class Cat extends Animal{
	private String eyesColor; //有自己的成员变量
	Cat(String n, String e){
		super(n);
		eyesColor = e;
	}
	
	//重写enjoy，有自己的特性，是猫的叫声，而不只是动物的叫声
	public void enjoy(){
		System.out.println("猫叫声......");
	}
}

class Dog extends Animal{
	private String furColor;
	Dog(String n, String e){
		super(n);
		furColor = e;
	}
	
	//重写了父类的方法，多态
	public void enjoy(){
		System.out.println("狗叫声......");
	}
}

//可扩展，只需添加一个类，有自己的特性：鸟叫声
/*class Bird extends Animal{
	Bird(){ super("bird"); }
	public void enjoy(){
		System.out.println("鸟叫声......");
	}
}*/

//小姑娘养着一只宠物
class Lady{
	private String name;
	//定义成父类（Animal）的引用，最灵活，想养什么宠物养什么宠物，可以运用对象转型
	private Animal pet;   
	Lady(String name, Animal pet){
		this.name=name;
		this.pet=pet;
	}
	//实际调用的是pet的enjoy方法（动态绑定），实际new的是谁调的就是谁的方法(父类引用指向子类对象)，实现可扩展
	//如果不用多态，需要进行判断传进来的是哪种pet，然后才能去调用相应的方法
	public void myPetEnjoy(){pet.enjoy();}
}

public class Test{
	public static void main(String args[]){
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("dogname","black");
		//Bird b = new Bird();
		Lady l1 = new Lady("l1",c);
		Lady l2 = new Lady("l2",d);
		//Lady l3 = new Lady("l3",b);
		l1.myPetEnjoy(); //传进来的是Cat，所以打印出来的是猫叫声
		l2.myPetEnjoy(); //传进来的是Dog，所以打印出来的是狗叫声
		//l3.myPetEnjoy();
	}
}

输出结果：

       

如果想添加新的业务，大管家main方法可以变，但是业务方法，即结构是不需要变的，只要添加一个类，重写抽象方法就可以。例子中除了猫叫声、狗叫声，如果以后想实现鸟叫声，只需要添加一个鸟类，然后在main方法中进行相应的调用，Lady这个类是不需要进行修改的，实现了程序的可扩展。

OOP强调的是类与类、对象与对象之间的关系，如果设计好的话，程序的健壮性、扩展性、维护性会比较好。不会因为添加新的业务而牵一发动全身，只需要在原有结构的基础上添加新的类即可完成。