Java多态的理解

面向对象编程有三大特性：封装，继承，多态。本文主要介绍一下自己对java中多态的理解。

要想清楚的理解什么是多态，就必须要了解“向上转型”这个概念。 下面我们通过一个例子来介绍向上转型。

public class Person {
	
	private void eat(){
		System.out.println("Person is eating");
	}
	
	protected void sleep(){
		System.out.println("Person is sleeping");
	}

	public void play(){
		System.out.println("Person is playing");
	}
	
}

public class Student extends Person {
	
	public void study(){
		System.out.println("Student is studying");
	}
	
}

public class Main {

	public static void main(String[] args) {
		
		Student s = new Student();   //实例化Student类的对象
		s.study();  
		s.play();   
		s.sleep();
		
		Person p = s;   //向上转型
		p.play();      
		p.sleep();
		
	}
}

上面代码中定义了两个类：Person类和Student类。Student类继承自Person类。 

Person类中有三个方法：私有方法eat()， 保护方法sleep()，公有方法play()。

因为Student类继承自Person类，则Person类中的protected方法和public方法可以被继承下来。所以Student类拥有三个方法：sleep()，play(), study()。这三个方法可以被Student类对象调用。

Person p = s;    该行代码即实现了所谓的“向上转型”操作。 所谓“向上转型”，即：将子类对象的引用转换为父类的引用。

该行代码中，s为子类Student类的引用，p为父类Person类的引用。

那么进行向上转型操作后，会有什么效果呢，也就是说我们要弄清父类引用p可以调用哪些方法。

既然向上转型为父类引用，则p只可以调用父类的方法，而且只能是父类中可以被子类继承的方法（这样说不太严谨，暂且先不考虑方法的重写）。换句话说，子类的新方法都会被遗弃。向上转型之后，父类引用所能调用的方法，相对子类对象引用所能调用的方法来说，会变窄。

明白了上述“向上转型”之后，我们接下来，再看下面的代码：

public class Person {
	
	private void eat(){
		System.out.println("Person is eating");
	}
	
	protected void sleep(){
		System.out.println("Person is sleeping");
	}

	public void play(){
		System.out.println("Person is playing");
	}
	
}

public class Student extends Person {
	
	public void study(){
		System.out.println("Student is studying");
	}
	
	public void play(){
		System.out.println("Student is playing");
	}
	
}

public class Worker extends Person{

	public void work(){
		System.out.println("Worker is working");
	}
	
	public void play(){
		System.out.println("Worker is playing");
	}
	
}

public class Main {

	public static void main(String[] args) {
		
		Person p1 = new Student();
		p1.play();
		
		Person p2 = new Worker();
		p2.play();
	}
}

上述代码的变化之处在于：父类中有play()方法，而其两个子类中也都分别有play()方法。则子类中的方法将会覆盖父类中的方法。也就是说，当我们写如下代码时：

Student s = new Student();

s.play();

代码将会输出：Student is playing。 由此可知子类覆盖了父类的方法。

而对于上述main方法中的代码来说，我分别实例化了两个子类对象，并将其向上转型为父类引用，当我们运行上述程序之后，我们发现父类引用分别调用了对应的子类中的方法。Such a suprise！ 对于这种机制，我们称之为“多态”。

总的来说，多态的实现有三个条件：继承，方法重写，父类引用指向子类对象。

串起来来说就是：子类继承父类，并且子类重写了父类中的方法，我们实例化一个子类对象，并用父类的引用去指向它。父类引用调用重写方法时，会在运行时正确调用对应子类中的方法。

或者说：当我们进行向上转型之后，我们拥有父类的引用，而这个父类的引用只能够调用父类中可以被子类继承的方法。而如果正好父类中的这个方法在子类中进行了重写，那么父类引用在调用这个方法时，将会调用的是子类中的方法，不再是父类中的方法，这便是多态。

参考文献：Java编程思想