细细的剖开Java多态

多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

多态存在的三个必要条件

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

例如：

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("你");
	}

因此结果为：

爱
你