java多态的体现

多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

例如：

Parent p = new Child();

多态中的成员访问特点

成员变量

编译看左边，运行看左边。

构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

成员方法

编译看左边，运行看右边。

由于成员方法存在方法重写，所以它运行看右边。

静态方法

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

多态的弊端

不能使用子类的特有功能

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

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看门");
	}
}

class DuoTaiTest {
	public static void main(String[] args) {
		//定义为狗
		Animal a = new Dog();
		a.eat();
		a.lookDoor();
	}
}

可以看见，如果调用子类的lookDoor()方法是行不通的

解决方案

如果就想使用子类的特有功能呢？

创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题

//向上转型：
    Parent p = new Child();
//向下转型：
    Child c = (Child)p; //要求该p必须是能够转换为Child的。

多态继承中的内存图解

思考

看程序写结果:先判断有没有问题，如果没有，写出结果

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();	// 爱
		
		B b = new C();
		b.show();
	}
}

结果是：

爱
你

分析

当a.show();时，首先看自身是否含有show()方法，没有就去找父类是否含有这个show()方法

父类存在

public void show() {
	show2();
}

子类即调用show2()

public void show2() {
	System.out.println("爱");
}

同理b.show()时，C含有show()方法，调用父类的show()

public void show() {
	super.show();
}

由上可知，B的show()即是调用show2()，则C调用show2()为

public void show2() {
	System.out.println("你");
}

因此结果为：

爱
你