多态性之编译期多态和运行期多态(JAVA版)

多态性之编译期多态和运行期多态(JAVA版)

    上一篇讲述了C++中的多态性，由于多态性是面向对象编程中常用的特性，所以JAVA作为面向对象的主流语言自然也有多态性，它的多态性其实和C++的概念差不多，只是实现形式和表现形式不一样。在C++中可能还会提到多态的划分，但是在JAVA中可能很多人都不会听到编译期多态和运行期多态这种划分，一般我们说到多态都是指运行期多态，因为这才是面向对象思想的真正体现之处，即OOP(面向对象)的多态性的体现，所以JAVA中我们不再讨论编译期多态这个问题，只重点讨论运行期多态，下面简称运行期多态为JAVA中的多态性。

    1. 编译期多态（静态多态）

    如上所述，此处不再多说，大家如果学习JAVA的话就不要深究这个问题了，直接进入运行期多态。

    2. 运行期多态（动态多态）

    运行期多态主要是指在程序运行的时候，动态绑定所调用的函数，动态地找到了调用函数的入口地址，从而确定到底调用哪个函数。

（1）前提

    A. 要有继承关系。
    B. 要有方法重写。其实没有也是可以的，但是如果没有这个就没有意义。
    C. 要有父类引用指向子类对象。

（2）多态中的成员访问特点

    A. 成员变量：编译看左边，运行看左边。
    B. 构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
    C. 成员方法：编译看左边，运行看右边。由于成员方法存在方法重写，所以它运行看右边。

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

（3）多态性的例子

    下面的例子大部分引用自传智播客风清扬的程序，这里主要是引导大家进行理解，所以选择这些十分经典的例子进行讲解，也有部分是我新增的例子，为了帮助大家加深理解。

// 例1：多态性




class Fu {



	public int num = 100;



 



	public void show() {



		System.out.println("show Fu");



	}



	



	public static void function() {



		System.out.println("function Fu");



	}



}



 




class Zi extends Fu {



	public int num = 1000;



	public int num2 = 200;



 



	public void show() {



		System.out.println("show Zi");



	}



	



	public void method() {



		System.out.println("method zi");



	}



	



	public static void function() {



		System.out.println("function Zi");



	}



}



 




class DuoTaiDemo {



	public static void main(String[] args) {



		//要有父类引用指向子类对象。




		//父 f =  new 子();




		Fu f = new Zi();



		System.out.println(f.num);



		//找不到符号




		//System.out.println(f.num2);




		



		f.show();



		//找不到符号




		//f.method();




		f.function();



	}



}

运行结果：



 



100



show Zi



function Fu

    

    例1是一个经典的多态性例子，父类中和子类中有一些同样名称的成员方法和成员变量，那么这里的访问原则就遵从（2）中的原则，从运行结果可以很清楚地看到这一点。我们这里关键来说说多态性到底体现在哪里。从main方法中可以看到，我们定义了一个父类的引用然后指向了子类的对象，我们关键来研究show()方法的调用，因为这才是多态性的关键之处。这里其实存在一个向上转型，即将子类对象向上转型到了一个父类引用，然后我们利用这个父类引用调用show()方法的时候，由于在子类中重写了show()方法，并且该方法是一个普通的成员方法，并不是什么静态方法，所以，遵从“编译看左边，运行看右边”的原则，这个原则正是多态性的体现。这是因为在运行期间才实现的动态绑定，将父类的引用绑定到了子类的对象上，从而用父类的引用去调用父类和子类都有的方法时，实际上调用的是子类的方法，这就是多态性。虽然是父类的引用，但是在运行期间却绑定到了子类对象上。

    同时，大家需要注意，main方法中注释掉的部分，父类的引用即使绑定到了子类对象上，但是依然是不能访问子类的特有成员和特有方法的，比如main方法中的f.num2和f.method()都会出错，这也是多态性的一个缺点，无法调用子类特有的功能。

    上图是针对例1给出的一个内存解释，该图中的程序和例1并不完全一致，但是结构是类似的，大家根据此图可以更加清晰地看出多态的实现过程。

    下面给出一些其它例子。供大家学习参考。

// 例2：向上向下转型




class 孔子爹 {



	public int age = 40;



		



	public void teach() {



		System.out.println("讲解JavaSE");



	}



}



	




class 孔子 extends 孔子爹 {



	public int age = 20;



		



	public void teach() {



		System.out.println("讲解论语");



	}



		



	public void playGame() {



		System.out.println("英雄联盟");



	}



}



	



//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了



//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?



//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹



//向上转型



孔子爹 k爹 = new 孔子();



//到人家那里去了



System.out.println(k爹.age); //40




k爹.teach(); //讲解论语




//k爹.playGame(); //这是儿子才能做的



	



	



//讲完了，下班回家了



//脱下爹的装备，换上自己的装备



//向下转型



孔子 k = (孔子) k爹; 



System.out.println(k.age); //20




k.teach(); //讲解论语




k.playGame(); //英雄联盟

    例2很形象地说明了向上转型和向下转型的问题，这里的向上转型就是多态性的一个体现。注意，这个例子只是用来让大家理解，并不能直接运行，大家可以修改成合理的字母表示，然后运行。这个例子是摘自风清扬的一个经典的例子，十分形象合理。

/*



例3	多态的好处：



		A:提高了代码的维护性(继承保证)



		B:提高了代码的扩展性(由多态保证)



		



	猫狗案例代码



*/




class Animal {



	public void eat(){



		System.out.println("eat");



	}



	



	public void sleep(){



		System.out.println("sleep");



	}



}



 




class Dog extends Animal {



	public void eat(){



		System.out.println("狗吃肉");



	}



	



	public void sleep(){



		System.out.println("狗站着睡觉");



	}



}



 




class Cat extends Animal {



	public void eat() {



		System.out.println("猫吃鱼");



	}



	



	public void sleep() {



		System.out.println("猫趴着睡觉");



	}



}



 




class Pig extends Animal {



	public void eat() {



		System.out.println("猪吃白菜");



	}



	



	public void sleep() {



		System.out.println("猪侧着睡");



	}



}



 



//针对动物操作的工具类




class AnimalTool {



	private AnimalTool(){}



 



	/*




	//调用猫的功能



	public static void useCat(Cat c) {



		c.eat();



		c.sleep();



	}



	



	//调用狗的功能



	public static void useDog(Dog d) {



		d.eat();



		d.sleep();



	}



	



	//调用猪的功能



	public static void usePig(Pig p) {



		p.eat();



		p.sleep();



	}



	*/



	public static void useAnimal(Animal a) {



		a.eat();



		a.sleep();



	}



	



}



 




class DuoTaiDemo2 {



	public static void main(String[] args) {



		//我喜欢猫，就养了一只




		Cat c = new Cat();



		c.eat();



		c.sleep();



		



		//我很喜欢猫，所以，又养了一只




		Cat c2 = new Cat();



		c2.eat();



		c2.sleep();



		



		//我特别喜欢猫，又养了一只




		Cat c3 = new Cat();



		c3.eat();



		c3.sleep();



		//...




		System.out.println("--------------");



		//问题来了,我养了很多只猫，每次创建对象是可以接受的




		//但是呢?调用方法，你不觉得很相似吗?仅仅是对象名不一样。




		//我们准备用方法改进




		//调用方式改进版本




		//useCat(c);




		//useCat(c2);




		//useCat(c3);




		



		//AnimalTool.useCat(c);




		//AnimalTool.useCat(c2);




		//AnimalTool.useCat(c3);




		



		AnimalTool.useAnimal(c);



		AnimalTool.useAnimal(c2);



		AnimalTool.useAnimal(c3);



		System.out.println("--------------");



		



		//我喜欢狗




		Dog d = new Dog();



		Dog d2 = new Dog();



		Dog d3 = new Dog();



		//AnimalTool.useDog(d);




		//AnimalTool.useDog(d2);




		//AnimalTool.useDog(d3);




		AnimalTool.useAnimal(d);



		AnimalTool.useAnimal(d2);



		AnimalTool.useAnimal(d3);



		System.out.println("--------------");



		



		//我喜欢宠物猪




		//定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用




		Pig p = new Pig();



		Pig p2 = new Pig();



		Pig p3 = new Pig();



		//AnimalTool.usePig(p);




		//AnimalTool.usePig(p2);




		//AnimalTool.usePig(p3);




		AnimalTool.useAnimal(p);



		AnimalTool.useAnimal(p2);



		AnimalTool.useAnimal(p3);



		System.out.println("--------------");



		



		//我喜欢宠物狼，老虎，豹子...




		//定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用




		//前面几个必须写，我是没有意见的




		//但是，工具类每次都改，麻烦不




		//我就想，你能不能不改了




		//太简单：把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?




		//改用另一种解决方案。




		



	}



	



	/*




	//调用猫的功能



	public static void useCat(Cat c) {



		c.eat();



		c.sleep();



	}



	



	//调用狗的功能



	public static void useDog(Dog d) {



		d.eat();



		d.sleep();



	}



	*/



}

    例3是一个更加全面的例子，也是摘自风清扬的例子，供大家学习参考。这个例子是说明一个简化的设计思想，应用到了多态，是一个稍微复杂一点的例子，大家可以用心去按照注释的思路自己思考下。

    最后，给出一个百度百科的例子，这个例子主要说明了接口和多态性的应用。

public interface Parent//父类接口




{



    public void simpleCall();



}




public class Child_A implements Parent




{



    public void simpleCall();



    {



    //具体的实现细节；




    }



}



 




public class Child_B implements Parent




{



    public void simpleCall();



    {



    //具体的实现细节；




    }



}

    然后，我们可以看到
    Parent pa = new Child_A();
    pa.simpleCall()则显然是调用Child_A的方法；
    Parent pa = new Child_B();
    pa.simpleCall()则是在调用Child_B的方法。所以，我们对于抽象的父类或者接口给出了我们的具体实现后，pa 可以完全不用管实现的细节，只访问我们定义的方法，就可以了。事实上，这就是多态所起的作用，可以实现控制反转这在大量的J2EE轻量级框架中被用到，比如Spring的依赖注入机制。

    3. 总结

    

    总之，在JAVA中大家就不要去过多纠结编译期多态和运行期多态，只要掌握好常用的多态性即运行期多态即可。这篇文章可能存在很多纰漏，希望大家看到后给予指正，谢谢。