java 多态

java的特点就是封装，继承，多态。

多态实现必要条件：

1，继承

2，重写

3，父类对象指向子类应用。

继承和重写就很简单了，父类对象指向子类应用是什么一直不是很理解，就像是 ： 父类（） a = new 子类（）；这种形式。

看一个简单的例子

public class fuleizhixiangzile {
	public static void main(String[] args) {
		Animal a = new dog();
		a.call();
	}
}

class Animal {
	void call() {
		eat();
		
	}
	void eat() {
		System.out.println("a");
	}
}

class dog extends Animal {
	@Override
	void call() {
		// TODO Auto-generated method stub
		super.call();
	}

	@Override
	void eat() {
		// TODO Auto-generated method stub
		System.out.println("d");
		sleep();
	}

	void sleep() {
		System.out.println("sleep");
	}
}

当a调用call这个方法的时候同时实现了eat这个方法，但是子类已经重写了这个方法所以就备覆盖了，这里实现多态是因为子类比父类有更多的实现，范围更大，更可以实现多样化。

多态还有一个是动态绑定：

绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。动态绑定顾名思义就是运行的时候绑定。

看一个例子

public class Text {
	public static void main(String[] args) {
		American a = new American();
		Chinese c = new Chinese();
		jeck j = new jeck(a);
		j.jeck_Col();
	}

}

 abstract class Person{
	 abstract void colors();
 }
 
 class American extends Person{

	@Override
	void colors() {
		System.out.println("白种人");
	}
	 
 }
 class Chinese extends Person{
	 @Override
	void colors() {
		// TODO Auto-generated method stub
	System.out.println("黄种人");	
	}
 }
 class jeck{
	 Person p;
	 public jeck(Person p) {
		// TODO Auto-generated constructor stub
		 this.p = p;
	 }
	 void jeck_Col(){
		 p.colors();
	 }
 }

打印结果：白种人

将jeck这个类和Person这个类关联起来，当调用 jeck_Col()的时候就动态的把color加载进来了。