Java多态性

Java中多态的实现方式：

实现接口
继承父类并进行方法重写
同一个类中进行方法重载

C++的多态性实现机制剖析

1.    多态性和虚函数



#include <iostream.h>
class animal
{
public:
    void sleep()
    {
        cout<<"animal sleep"<<endl;
    }
    void breathe()
    {
        cout<<"animal breathe"<<endl;
    }
};
class fish:public animal
{
public:
    void breathe()
    {
        cout<<"fish bubble"<<endl;
    }
};
void main()
{
    fish fh;
    animal *pAn=&fh;
    pAn->breathe();
}


注意，程序中没有定义虚函数。程序执行的结果是什么？答案是输出：animal breathe 

    我们在main()函数中首先定义了一个fish类的对象fh，接着定义了一个指向animal类的指针变量pAn，将fh的地址赋给了指针变量pAn，然后利用该变量调用pAn->breathe()。许多学员往往将这种情况和C++的多态性搞混淆，认为fh实际上是fish类的对象，应该是调用fish类的breathe()，输出“fish bubble”，然后结果却不是这样。下面我们从两个方面来讲述原因。 

1、  编译的角度；C++编译器在编译的时候，要确定每个对象调用的函数的地址，这称为早期绑定（early binding），当我们将fish类的对象fh的地址赋给pAn时，C++编译器进行了类型转换，此时C++编译器认为变量pAn保存的就是animal对象的地址。当在main()函数中执行pAn->breathe()时，调用的当然就是animal对象的breathe函数。 

2、  内存模型的角度；我们给出了fish对象内存模型，如下图所示 


我们构造fish类的对象时，首先要调用animal类的构造函数去构造animal类的对象，然后才调用fish类的构造函数完成自身部分的构造，从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图1-1中的“animal的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，输出animal breathe，也就顺理成章了。 

前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late binding）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual关键字，这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显式地声明为virtual。

#include <iostream.h>
class animal
{
public:
    void sleep()        {   cout<<"animal sleep"<<endl;}
    virtual void breathe()  {   cout<<"animal breathe"<<endl;   }
};
class fish:public animal
{
public:
    void breathe()  {   cout<<"fish bubble"<<endl;}
};
void main()
{
    fish fh;
    animal *pAn=&fh;
    pAn->breathe();
}

大家可以再次运行这个程序，你会发现结果是“fish bubble”，也就是根据对象的类型调用了正确的函数。 

那么当我们将breathe()声明为virtual时，在背后发生了什么呢？ 

编译器在编译的时候，发现animal类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。对于例1-2的程序，animal和fish类都包含了一个虚函数breathe()，因此编译器会为这两个类都建立一个虚表，如下图所示： 


那么如何定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。对于例1-2的程序，由于pAn实际指向的对象类型是fish，因此vptr指向的fish类的vtable，当调用pAn->breathe()时，根据虚表中的函数地址找到的就是fish类的breathe()函数。 

正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？ 
答案是在构造函数中进行虚表的创建和虚表指针的初始化。还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。对于例2-2的程序来说，当fish类的fh对象构造完毕后，其内部的虚表指针也就被初始化为指向fish类的虚表。在类型转换后，调用pAn->breathe()，由于pAn实际指向的是fish类的对象，该对象内部的虚表指针指向的是fish类的虚表，因此最终调用的是fish类的breathe()函数。 

要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。 
总结（基类有虚函数）： 

1、  每一个类a都有虚表。 

2、  虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类有3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。 

3、  派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。 

1.多态性是面向对象程序设计的重要部分。在Java语言中，通过使用方法的重载和重写实现类的多态性。
2.重写(覆盖)是指父子类之间的关系，当子类继承父类中所有可能被子类访问的成员方法时，如果子类的方法名与父类的方法名相同，那么子类就不能继承父类的方法，这时，称为子类的方法重写了父类的方法。重写体现了子类补充或者改变父类方法的能力。通过重写，可以使一个方法在不同的子类中表现出不同的行为。多态其实不依赖具体类，依赖抽象类和接口，接下来附上一个例子：
目录结构：



Animal.java文件:
package tom.bean;

/*
 * 定义一个动物类，作为父类
 */
public class Animal {
	public Animal(){	//无参构造方法
	}
	
	public void eat(){	//eat()方法
		System.out.println("动物吃东西");
	}
}



Dog.java文件:
package tom.bean;

/*
 * 定义一个狗类，作为动物类的子类，继承动物类
 */
public class Dog extends Animal{
	public Dog(){	//无参构造方法
	}
	
	public void eat(){	//eat()方法，重写了Animal类的eat()方法
		System.out.println("狗吃狗粮");
	}
}



Cat.java文件:
package tom.bean;

/*
 * 定义一个猫类，作为动物类的子类，继承动物类
 */
public class Cat extends Animal{
	public Cat(){	//无参构造方法
	}
	
	public void eat(){	//eat()方法,重写了Animal类的eat()方法
		System.out.println("猫吃猫粮");
	}
}

Tiger.java文件:
package tom.bean;

/*
 * 定义一个Tiger老虎类，继承Animal动物类
 */
public class Tiger extends Animal {
}





Test.java文件，测试类：
package tom.test;

import tom.bean.Cat;
import tom.bean.Dog;
import tom.bean.Tiger;

/*
 * 测试类，打印输出信息
 */
public class Test {
	public static void main(String[] args){
		Dog dog=new Dog();//创建Dog类的对象
		System.out.println("执行dog.eat();语句后的结果：");
		dog.eat();//调用eat()方法
		Cat cat=new Cat();//创建Cat类的对象
		System.out.println("执行cat.eat();语句后的结果：");
		cat.eat();//调用eat()方法
		Tiger tiger=new Tiger();//创建Tiger对象
		System.out.println("执行tiger.eat()；语句的结果：");
		tiger.eat();//调用eat()方法，此时调用的是父类的eat()方法
	}
}



运行Test.java文件后，结果为:

从上面的例子可以知道，Dog类和Cat类都重写了父类的eat()方法，所以执行的是子类的eat()方法，但是Tiger类没有重写父类的方法，所以执行的是父类中的eat()方法。

3.方法的重载是指在一个类中出现多个方法名相同，但参数个数或参数类型不同的方法，则称为方法的重载。Java语言在执行该具有重载关系的方法时，将根据调用参数的个数和类型区分具体执行的是哪个方法。下面给出一个例子：定义一个Shape类，在类中定义两个名称为getArea()的方法(参数个数不同)和两个名称为draw()的方法(参数类型不同)：
Shape.java文件：
package tom.bean;

public class Shape {
	final float PI=3.14159f;//定义一个用于表示圆周率的常量PI
	
	public float getArea(float r){	//定义一个用于计算面积的方法getArea()，求圆形的面积
		float area=PI*r*r;
		return area;
	}
	
	public float getArea(float length,float width){	//重载getArea()方法，用来求矩形的面积，重载方法带的参数个数不同
		float area=length*width;
		return area;
	}
	
	//画任意形状的图形
	public void draw(int num){	//定义一个用于画图的方法draw()
		System.out.println("画一个"+num+"个任意形状的图形");
	}
	
	//画指定形状的图形
	public void draw(String shape){	//重载draw()方法,重载方法中带的参数类型不同
		System.out.println("画一个"+shape);
	}
	
	//主方法
	public static void main(String[] args){
		Shape shape=new Shape();//创建Shape类的对象
		float l=10;//声明一个常量，初始化为10，表示矩形的长
		float w=20;//声明一个常量，初始化为20，表示矩形的宽
		float rectangleArea=shape.getArea(l, w);//获得矩形的面积，并赋予rectangleArea
		System.out.println("长度为"+l+",宽度为"+w+"的矩形面积为:"+rectangleArea);//打印输出矩形的面积
		float r=5;
		float circleArea=shape.getArea(r);
		System.out.println("半径为"+r+"的圆形的面积为:"+circleArea);
		shape.draw(3);//调用draw()方法
		shape.draw("圆锥");
	}
}

运行此程序，结果为：
 
注：重载的方法直接并不一定必须有联系，但是为了提高程序的可读性，一般只重载功能相似的方法，在进行方法的重载时，方法返回值的类型不能作为区分方法的标志！
4.以上就是通过方法的重写和重载实现类的多态性，仅供大家学习参考，写得不好，请见谅，如有错误请指出，谢谢！



      多态分为两种情况，一种是编译的时候的多态性，一种是运行时的多态性。
      编译时的多态性：编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
      运行时的多态性：运行时的多态性就直到运行时，才根据实际情况实现何种操作。C#中运行时的多态性是通过复写虚函数实现的。


      C#中的，多态人们很不容易分清楚。明明是一个相同的名称，而调用起来，却出现了不同的结果。现在来通过一个例子来体会一下多态是如何实现的。
                   

      子类继承父类得到的方法，可以通过重写来覆盖。这样父类的实例就可以使用子类的方法。
 class Program
    {
        static void Main(string[] args)
        {
            fruit ep;                      //定义一个水果的实例
            ep= new Apple();
            ep.AddFruit(5);
            ep = new Orange();
            ep.AddFruit(4);
        }
    }

    public abstract class fruit     //创建一个抽象类-水果
    {
        private uint nint_Weight;
        public abstract void AddFruit(uint nWeight);
    }
    public class Apple : fruit         //创建水果的子类-苹果
    {
        public override void AddFruit(uint nWeight)
        {
            Console.WriteLine("你添加了一个苹果，质量为{0}",nWeight);
        }
    }
    public class Orange : fruit       //创建水果的子类-橘子
    {
        public override void AddFruit(uint nWeight)
        {
            Console.WriteLine("你添加了一个橘子，质量为{0}", nWeight);
        }
    }


              



      继承：当子类继承父类的时候，子类可以不用重新定义父类中的方法，可以直接使用。
      多态：当子类重写父类的方法时。父类的对象，调用子类的方法时候，会根据情况来选择基类的方法。