一句话概括就是：事物在运行过程中存在不同的状态。

多态的三个前提：

1、要有继承关系；

2、子类要重写父类的方法；

3、父类引用指向子类对象。

但是其中又有很多细节需要注意。首先我们定义两个类，一个父类Animal，一个子类Cat。

父类Animal

class Animal {
	int num = 10;
	static int age = 20;

	public void eat() {
		System.out.println("动物吃饭");
	}

	public static void sleep() {
		System.out.println("动物在睡觉");
	}

	public void run() {
		System.out.println("动物在奔跑");
	}
}

子类Cat

class Cat extends Animal {
	int num = 80;
	static int age = 90;
	String name = "tomCat";

	public void eat() {
		System.out.println("猫吃饭");
	}

	public static void sleep() {
		System.out.println("猫在睡觉");
	}

	public void catchMouse() {
		System.out.println("猫在抓老鼠");
	}
}

测试类Test

class Test {
	public static void main(String[] args) {
		Animal animal = new Cat();

		animal.eat();
		animal.sleep();
		animal.run();

		System.out.println(animal.num);
		System.out.println(animal.age);
	}
}

那我们来看一下运行结果：

可以看出来

子类Cat重写了父类Animal的非静态成员方法am.eat();的输出结果为：猫吃饭

子类重写了父类(Animal)的静态成员方法am.sleep();的输出结果为：动物在睡觉

未被子类（Cat）重写的父类（Animal）方法am.run()输出结果为：动物在奔跑

System.out.println(animal.num);//输出结果为10
System.out.println(animal.age);//输出结果为20

那么我们可以根据以上情况总结出多态成员访问的特点：

成员变量：编译看左边(父类),运行看左边(父类)

成员方法：编译看左边(父类)，运行看右边(子类)。动态绑定

静态方法：编译看左边(父类)，运行看左边(父类)。 (静态和类相关，算不上重写，所以，访问还是左边的)

只有非静态的成员方法,编译看左边,运行看右边

此外，以上的三段代码充分体现了多态的三个前提：

1、存在继承关系

Cat类继承了Animal类 .

2、子类要重写父类的方法

子类重写(override)了父类的两个成员方法eat()，sleep()。其中eat()是非静态的，sleep()是静态的（static）。

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

测试类Test中 Animal am = new Cat();语句在堆内存中开辟了子类(Cat)的对象，并把栈内存中的父类(Animal)的引用指向了这个Cat对象。

到此，满足了Java多态的的必要三个前提。