Java多态的理解

Java的多态性

面向对象编程有三个特征，即封装、继承和多态。

封装隐藏了类的内部实现机制，从而能够在不影响使用者的前提下改变类的内部结构，同时保护了数据。

继承是为了重用父类代码，同时为实现多态性做准备。那么什么是多态呢？

方法的重写、重载与动态链接构成多态性。Java之因此引入多态的概念，缘由之一是它在类的继承问题上和C++不一样，后者容许多继承，这确实给其带来的很是强大的功能，可是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只容许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样作虽然保证了继承关系的简单明了，可是势必在功能上有很大的限制，因此，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

要理解多态性，首先要知道什么是“向上转型”。

我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我能够经过

Cat c = new Cat();
实例化一个Cat的对象，这个不难理解。但当我这样定义时：

Animal a = new Cat();
这表明什么意思呢？

很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。因为Cat是继承自它的父类Animal，因此Animal类型的引用是能够指向Cat类型的对象的。那么这样作有什么意义呢？由于子类是对父类的一个改进和扩充，因此通常子类在功能上较父类更强大，属性较父类更独特，

定义一个父类类型的引用指向一个子类的对象既可使用子类强大的功能，又能够抽取父类的共性。

因此，父类类型的引用能够调用父类中定义的全部属性和方法，而对于子类中定义而父类中没有的方法，它是迫不得已的；

同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的状况下，才能够被父类类型的引用调用；

对于父类中定义的方法，若是子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态链接。

看下面这段程序：

class Father{ 
public void func1(){ 
func2(); 
} 
//这是父类中的func2()方法，由于下面的子类中重写了该方法 
//因此在父类类型的引用中调用时，这个方法将再也不有效 
//取而代之的是将调用子类中重写的func2()方法 
public void func2(){ 
System.out.println("AAA"); 
} 
} 

class Child extends Father{ 
//func1(int i)是对func1()方法的一个重载 
//因为在父类中没有定义这个方法，因此它不能被父类类型的引用调用 
//因此在下面的main方法中child.func1(68)是不对的 
public void func1(int i){ 
System.out.println("BBB"); 
} 
//func2()重写了父类Father中的func2()方法 
//若是父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法 
public void func2(){ 
System.out.println("CCC"); 
} 
} 

public class PolymorphismTest { 
public static void main(String[] args) { 
Father child = new Child(); 
child.func1();//打印结果将会是什么？ 
} 
}
上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()再也不是同一个方法，因为父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

那么该程序将会打印出什么样的结果呢？

很显然，应该是“CCC”。

对于多态，能够总结它为：

1、使用父类类型的引用指向子类的对象；

2、该引用只能调用父类中定义的方法和变量；

3、若是子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态链接、动态调用）

4、变量不能被重写（覆盖），”重写“的概念只针对方法，若是在子类中”重写“了父类中的变量，那么在编译时会报错。

****************************************************************************************************************************

多态详解(整理)2008-09-03 19:29多态是经过: 
1 接口 和 实现接口并覆盖接口中同一方法的几不一样的类体现的 
2 父类 和 继承父类并覆盖父类中同一方法的几个不一样子类实现的.

1、基本概念 

多态性：发送消息给某个对象，让该对象自行决定响应何种行为。 
经过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 

java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，可是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 

1. 若是a是类A的一个引用，那么，a能够指向类A的一个实例,或者说指向类A的一个子类。 
2. 若是a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。 

2、Java多态性实现机制 

SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 
一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另一个指向类对象，代表该对象所属的类型）； 
另外一个指针指向一块从java堆中为分配出来内存空间。 

3、总结 

一、经过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 

DerivedC c2=new DerivedC(); 
BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类 
a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法 

分析： 
* 为何子类的类型的对象实例能够覆给超类引用？ 
自动实现向上转型。经过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass； 
* a.play()将执行子类仍是父类定义的方法？ 
子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。因此才有多态性。一个基类的对象引用，被赋予不一样的子类对象引用，执行该方法时，将表现出不一样的行为。 

在a1=c2的时候，仍然是存在两个句柄，a1和c2，可是a1和c2拥有同一块数据内存块和不一样的函数表。 

二、不能把父类对象引用赋给子类对象引用变量 

BaseClass a2=new BaseClass(); 
DerivedC c1=a2;//出错 

在java里面，向上转型是自动进行的,可是向下转型却不是，须要咱们本身定义强制进行。 
c1=(DerivedC)a2; 进行强制转化,也就是向下转型. 

三、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。 
你可能说这个规则不对的，由于父类引用指向子类对象的时候，最后执行的是子类的方法的。 
其实这并不矛盾，那是由于采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而倘若子类的这个方法在父类中并无定义，则会出错。 
例如，DerivedC类在继承BaseClass中定义的函数外，还增长了几个函数（例如 myFun()） 

分析： 
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。 
这里你能够这样理解，至关于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址因为在子类中已经被改写了，因此对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。 

四、Java与C++多态性的比较 

jvm关于多态性支持解决方法是和c++中几乎同样的， 
只是c++中编译器不少是把类型信息和虚拟函数信息都放在一个虚拟函数表中，可是利用某种技术来区别。 

Java把类型信息和函数信息分开放。Java中在继承之后，子类会从新设置本身的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类本身的虚拟函数。 
虚拟函数调用是通过虚拟函数表间接调用的，因此才得以实现多态的。

Java的全部函数，除了被声明为final的，都是用后期绑定。

四. 1个行为,不一样的对象,他们具体体现出来的方式不同, 
好比: 方法重载 overloading 以及 方法重写(覆盖)override 
class Human{ 
void run(){输出 人在跑} 
} 
class Man extends Human{ 
void run(){输出 男人在跑} 
} 
这个时候,同是跑,不一样的对象,不同(这个是方法覆盖的例子) 
class Test{ 
void out(String str){输出 str} 
void out(int i){输出 i} 
} 
这个例子是方法重载,方法名相同,参数表不一样 

ok,明白了这些还不够,还用人在跑举例 
Human ahuman=new Man(); 
这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象 
意思是说,把 Man这个对象当 Human看了. 

好比去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! " 
这2句话,就是最好的证实,由于不知道它是大熊猫,但知道它的父类是动物,因此, 
这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理. 

这种方式下要注意 new Man();的确实例化了Man对象,因此 ahuman.run()这个方法 输出的 是 "男人在跑 " 

若是在子类 Man下你 写了一些它独有的方法 好比 eat(),而Human没有这个方法, 

在调用eat方法时,必定要注意 强制类型转换 ((Man)ahuman).eat(),这样才能够... 

对接口来讲,状况是相似的...

实例:

package domatic; 

//定义超类superA 
class superA { 
int i = 100; 

void fun(int j) { 
j = i; 
System.out.println("This is superA"); 
} 
} 

// 定义superA的子类subB 
class subB extends superA { 
int m = 1; 

void fun(int aa) { 
System.out.println("This is subB"); 
} 
} 

// 定义superA的子类subC 
class subC extends superA { 
int n = 1; 

void fun(int cc) { 
System.out.println("This is subC"); 
} 
} 

class Test { 
public static void main(String[] args) { 
superA a = new superA(); 
subB b = new subB(); 
subC c = new subC(); 
a = b; 
a.fun(100); 
a = c; 
a.fun(200); 
} 
} 
/* 
* 上述代码中subB和subC是超类superA的子类,咱们在类Test中声明了3个引用变量a, b, 
* c,经过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问： 
* "为何(1)和(2)不输出：This is superA"。 
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时, 
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法, 
* 可是这个被调用的方法必须是在超类中定义过的, 
* 也就是说被子类覆盖的方法。 
* 因此,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),可是因为(1)中的a被b赋值, 
* 指向了子类subB的一个实例,于是(1)所调用的fun()其实是子类subB的成员方法fun(), 
* 它覆盖了超类superA的成员方法fun()；一样(2)调用的是子类subC的成员方法fun()。 
* 另外,若是子类继承的超类是一个抽象类,虽然抽象类不能经过new操做符实例化, 
* 可是能够建立抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。 
* 不过,抽象类的子类必须覆盖实现超类中的全部的抽象方法, 
* 不然子类必须被abstract修饰符修饰,固然也就不能被实例化了 
*/ 
以上大多数是以子类覆盖父类的方法实现多态.下面是另外一种实现多态的方法-----------重写父类方法

1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类能够有多个子类，而在子类里能够重写父类的方法（例如方法print()），这样每一个子类里重写的代码不同，天然表现形式就不同。这样用父类的变量去引用不一样的子类，在调用这个相同的方法print()的时候获得的结果和表现形式就不同了，这就是多态，相同的消息（也就是调用相同的方法）会有不一样的结果。举例说明： 
//父类 
public class Father{ 
//父类有一个打孩子方法 
public void hitChild(){ 
} 
} 
//子类1 
public class Son1 extends Father{ 
//重写父类打孩子方法 
public void hitChild(){ 
System.out.println("为何打我？我作错什么了！"); 
} 
} 
//子类2 
public class Son2 extends Father{ 
//重写父类打孩子方法 
public void hitChild(){ 
System.out.println("我知道错了，别打了！"); 
} 
} 
//子类3 
public class Son3 extends Father{ 
//重写父类打孩子方法 
public void hitChild(){ 
System.out.println("我跑，你打不着！"); 
} 
} 

//测试类 
public class Test{ 
public static void main(String args[]){ 
Father father; 

father = new Son1(); 
father.hitChild(); 

father = new Son2(); 
father.hitChild(); 

father = new Son3(); 
father.hitChild(); 
} 
} 
都调用了相同的方法，出现了不一样的结果！这就是多态的表现！