原文地址：http://www.cnblogs.com/plmnko/archive/2010/10/19/1855760.html
C++中，如果父類中的函數前邊標有virtual，才顯現出多態。
如果父類func是virtual的，則
Super *p =new Sub();
p->func(); // 調用子類的func
如果不是virtual的，p->func將調用父類原來的函數。
Java中，不管寫不寫virtual都是多態的，子類的同名函數會override父類的。與C++很不同的是，初始化的過程也不相同。在還未初始化子類的時候，子類的同名函數就已經覆蓋了父類的了。例如：
public class Super {
public Super() {
System.out.println("super constructor...");
m();
}
protected void m() {
System.out.println("test");
}
}
public class Sub extends Super{
private final Date date;
public Sub(){
date=new Date();}
public void m()
{
System.out.println(date);
}
public static void main(String[] args)
{
Super test1=new Sub();
test1.m(); //執行的子類的m
}
}
new Sub的時候首先調用Super，Super構造函數調用的m就已經是被Sub覆蓋的m，所以會print出null（因爲日期沒有初始化）。所以在java中，不要在父類構造函數中調用外部可改變的方法，有可能會輸出可改變方法中還沒初始化的東西。
但是，同樣的初始化在C++中，初始化一個子類的時候，父類調用的m，是父類自己的m，不會調用子類的。
——————
另外一個參考也很有用：http://7880.com/info/Article-51701560.html，如下：
C++和java中多態機制的異同
以前我有個錯誤的觀點：即使在C++和java中多態性的實現機制可能不同，但它們的表現形式應該相同，也就是說如果代碼結構相同，那麼執行結果也應該相同。可惜事與願違，事情並不總是你想象中的那樣子。（在看下文以前，你最好先考慮一下這個問題，你有什麼看法呢？）
ok,讓我們進入正題。
首先本文不討論面向對象編程的基本概念，如封裝、繼承和數據抽象等，這方面的資料現在應該多如牛毛，只是稍微提一下多態性的概念。根據Bjarne Stoustrup的說法，多態性其實就是方法調用的機制，也就是說當在編譯時無法確定一個對象的實際類型時，應當能夠在運行時基於對象的實際類型來決定調用的具體方法（動態綁定）。
我們先來看一下在C++中的函數調用方式：
Ø 普通函數調用：具體調用哪個方法在編譯時間就可以決定（通過查找編譯器的符號表），同時在使用標準過程調用機制基礎上增加一個表示對象身份的指針（this指針）。
Ø 虛函數調用：函數調用依賴於對象的實際類型，一般地說，對象的實際類型只能在運行時間才能確定。虛函數一般要有兩個步驟來支持，首先每一個類產生出一堆指向虛函數的指針，放在表格中，這個表格就叫虛函數表（virtual table）；然後每一個類對象（class object）會添加一個指向相關虛函數表（virtual table）的指針，通常這個指針叫做vptr。
在java中又是如何的呢？恩，區別還是滿大的。在java虛擬機中，類實例的引用就是指向一個句柄（handle）的指針，而該句柄（handle）其實是一對指針：其中一個指針指向一張表，該表格包含了對象的方法列表以及一個指向類對象（表示對象類型）的指針；另一個指針指向一塊內存地址，該內存是從java堆中爲對象的數據而分配出來的。
唔，你要說了，好象差不多嘛，不是都要維護一張函數表嗎？別急，讓我們先看一下例子，這樣你就能更好的理解它們之間的區別到底有多大了。
下面是C++和java的例子，不看後面的答案，你能夠正確說出它們的執行結果嗎？
例1：C++
class Base
{
public:
Base()
{
init();
}
virtual ~Base() {}
public:
virtual void do_init()
{
init();
}
protected:
virtual void init()
{
cout << "in Base::init()" << endl;
}
};
class Derived : public Base
{
public:
Derived()
{
init();
}
protected:
void init()
{
cout << "in Derived::init()" << endl;
}
};
int main(int argc, char* argv[])
{
Base* pb;
pb = new Derived();
delete pb;
return 0;
}
例2：java
class Base
{
public Base()
{
init();
}
protected void init()
{
System.out.println("in Base::init()");
}
public void do_init()
{
init();
}
}
class Derived extends Base
{
public Derived()
{
init();
}
protected void init()
{
System.out.println("in Derived::init()");
}
}
public class Test
{
public static void main(String[] args)
{
Base base = new Derived();
}
}
例1的執行結果是：
in Base::init()
in Derived::init()
例2的執行結果是：
in Derived::init()
in Derived::init()
看了結果後，你是馬上頓悟呢抑或是處於疑惑中呢？ok,我們來分析一下兩個例子的執行過程。
首先看一下例1（C++的例子）：
1. Base* pb; 只是聲明，不做什麼。
2. pb = new Derived();
1) 調用new操作符，分配內存。
2) 調用基類（本例中是Base）的構造函數
3) 在基類的構造函數中調用init()，執行程序首先判斷出當前對象的實際類型是Base（Derived還沒構造出來，當然不會是Derived），所以這裏調用的是Base::init()。
4) 調用派生類（本例中是Derived）的構造函數，在這裏同樣要調用init()，執行程序判斷出當前對象的實際類型是Derived，調用Derived::init()。
3. delete pb; 無關緊要。
例2（java的例子）的執行過程：
1. Base base = new Derived();
1) 分配內存。
2) 調用基類（本例中是Base）的構造函數
3) 在基類的構造函數中調用init()，執行程序首先判斷出當前對象的實際類型是Derived（對，Derived已經構造出來，它的函數表當然也已經確定了）所以這裏調用的是Derived::init()。
4) 調用派生類（本例中是Derived）的構造函數，在這裏同樣要調用init()，執行程序判斷出當前對象的實際類型是Derived，調用Derived::init()。
明白了吧。java中的類對象在構造前（調用構造函數之前）就已經存在了，其函數表和對象類型也已經確定了，就是說還沒有出生就已經存在了。而C++中只有在構造完畢後（所有的構造函數都被成功調用）才存在，其函數表和對象的實際類型纔會確定。所以這兩個例子的執行結果會不一樣。當然，構造完畢後，C++與java的表現就都一樣了，例如你調用Derived::do_init()的話，其執行結果是：
in Derived::init()。
個人認爲，java中的多態實現機制沒有C++中的好。還是以例子說明吧：
例子3：C++
class Base
{
public:
Base()
{
init();
}
virtual ~Base() {}
protected:
int value;
virtual void init()
{
value = 100;
}
};
class Derived : public Base
{
public:
Derived()
{
init();
}
protected:
void init()
{
cout << "value = " << value << endl;
// 做一些額外的初始化工作
}
};
int main(int argc, char* argv[])
{
Base* pb;
pb = new Derived();
delete pb;
return 0;
}
例4：java
class Base
{
public Base()
{
init();
}
protected int value;
protected void init()
{
value = 100;
}
}
class Derived extends Base
{
public Derived()
{
init();
}
protected void init()
{
System.out.println("value = " + value);
// 做一些額外的初始化工作
}
}
public class Test
{
public static void main(String[] args)
{
Base base = new Derived();
}
}
例3的執行結果是：
value = 10
例4的執行結果是：
value = 0
value = 0
從以上結果可以看出，java例子中應該被初始化的值（這裏是value）沒有被初始化，派生類根本不能重用基類的初始化函數。試問，如果初始化要在構造時完成，並且初始化邏輯比較複雜，派生類也需要額外的初始化，派生類是不是需要重新實現基類的初始化函數呢？這樣的面向對象方法好不好呢？歡迎大家討論。
作者的聯繫方式：[email protected]
Reference:
1. Stanley B. Lippman：深度探索C++對象模型（Inside The C++ Object Model）。
---- 侯捷譯，華中科技出版社 2001
——————
另外一個關於java的例子：
http://blog.csdn.net/lzz313/archive/2009/06/16/4274936.aspx
class Parent{
int x=10;
public Parent(){
add(2);
}
void add(int y){
x+=y;
}
}
class Child extends Parent{
int x=9;
void add(int y){
x+=y;
}
public static void main(String[] args){
Parent p=new Child();
System.out.println(p.x);
}
}
問輸出結果是什麼？
答案應該是10。
要理解結果爲什麼是10，需要首先明白下面的知識：
(1)方法和變量在繼承時的隱藏與覆蓋
隱藏：若B隱藏了A的變量或方法，那麼B不能訪問A被隱藏的變量或方法，但將B轉換成A後可以訪問A被隱藏的變量或者方法。
覆蓋：若B覆蓋了A的變量或者方法，那麼不僅B不能訪問A被覆蓋的變量或者方法，將B轉換成A後同樣不能訪問A被覆蓋的變量或者方法。
(2)Java中變量與方法在繼承中的隱藏與覆蓋規則：
一、父類的實例變量和類變量能被子類的同名變量隱藏。
二、父類的靜態方法被子類的同名靜態方法隱藏，父類的實例方法被子類的同名實例方法覆蓋。
三、不能用子類的靜態方法隱藏父類的實例方法，也不能用子類的實例方法覆蓋父類的靜態方法，否則編譯器會異常。
四、用final關鍵字修飾的最終方法不能被覆蓋。
五、變量只能被隱藏不會被覆蓋，子類的實例變量可以隱藏父類的類變量，子類的類變量也可以隱藏父類的實例變量。
在上面的試題中，子類Child的實例方法add(int y)覆蓋了父類Parent的實例方法add(int y)，而子類的實例變量x則是隱藏了父類的實例變量x。
Child對象的初始化過程是：
首先爲父類的實例變量x分配內存空間，因爲在定義變量x時爲它賦了值(int x=10),所以會同時將這個值賦給x。
其次調用父類的無參構造函數，Parent的構造函數中做的唯一的事情就是調用了add(2);
第三、由於子類的add(int y)方法覆蓋了父類的方法，所以add(2)實際調用的是子類的方法，在子類的add方法中做了如下操作x+=j;在這裏由於子類的實例變量x隱藏了父類的實例變量x，所以這條語句是針對子類本身的，但是這時還沒有爲子類的實力變量x分配空間，它的默認值是0，加2之後是2。
第四、父類初始化完畢後接着初始化子類，爲子類的x分配內存空間並將它賦值爲9，之前的add(2)操作白瞎了。
再次注意Parent p=new Child();這條語句，它是用父類的引用指向子類的對象，而前面已經說過變量只會被隱藏不會被覆蓋，所以這時的p.x值應該是父類的10，而不是子類的9；
如果將輸出語句換成下面的語句結果就是9了：
System.out..println(((Child)p).x); //首先將p轉換成Child類型
