繼承的最大好處就是為了實現代碼的復用。那麼，子類到底從父類得到的什麼呢？
父類的private成員不會被子類繼承，子類不能訪問。但是子類對象的確包含父類的私有成員。 父類的 包訪問成員 繼承為子類的包訪問成員。就好像他們直接定義在子類中一樣。 父類的 protected 成員繼承為子類的protected 成員。就好像他們直接定義在子類中一樣。 父類的 public 成員繼承為子類的public 成員，就好像他們直接定義在子類中一樣。
實例方法
繼承到的實例方法在子類中可以直接被使用，還需重點理解是方法的重寫和重載。
重寫override
一個繼承鏈中，父類的方法對於子類來說具有相同的語義，但是不同的細節操作，因此子類需要override父類的這個方法以滿足自己的需求。
注意的點：
1、方法名，參數表一定和父類中的相同，返回類型相同，或者是子類。
1、訪問權限一定不低於父類的實例方法
2、拋出的異常一定是父類方法拋出的異常相同，或者子類。
如果拿C++和java對比，那麼java中的實例方法默認都是virtual的（java中沒有virtual這個key word），因此在java中，子類可以直接重寫父類方法的任何非final實例方法，但是在C++中，除非父類使用virtual標記一個方法為虛方法，子類才可以override這個方法。
對於重寫的方法，javac是不能確定的具體要調用那個類的方法，而是產生特殊的字節碼讓jvm去動態決定什麼方法。這個就是所謂的前期綁定和後期綁定的差異。
public class Test
{
public static void main(String [] args){
Object o = new SubClass();
o.toString();
}
}
class SubClass extends Object
{
public String toString() //重寫Object 的toString方法
{
return "SubClass";
}
}
Compiled from "Test.java"
public class Test {
public Test();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: new #2 // class SubClass
3: dup
4: invokespecial #3 // Method SubClass."<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #4 // Method java/lang/Object.toString:()Ljava/lang/String;
12: pop
13: return
}
其中3處紅色標記 的代碼，重要的區別就是invokespecial 和 invokevirtual ：invokespecial 代表前期綁定，在編譯期就能決定調用什麼方法，由javac確定調用什麼方法。invokevirtual 則是方法的後期綁定，由JVM決定調用什麼方法。
第一處是Test類的構造函數調用父類Object的構造函數，編譯期確定，他是前期綁定。
第二處是因為new 了一個SubClass對象，調用SubClass的構造函數，編譯期確定，他也是前期綁定的。
第三處是因為我們的 Object o 引用了重寫了toString方法的SubClass對象，javac不能知道具體調用Object中的toString，還是SubClass中的toString，於是產生特殊代碼讓JVM去決定。
修飾為 static 、 final 、private 的方法一定是前期綁定，因為他們根本都不存在override。
JVM需要在運行時動態決定調用那個版本的方法，這個過程對JVM來說就是 virtual method lookup（虛方法查找）。JVM將會從實際對象所屬的類 和 他的最近的父類中查找。如果自己定義了，則調用自己的版本，如果沒有則調用父類的版本。
重載overload
重載的定義：函數重載是指在同一作用域內，可以有一組具有相同函數名，不同參數列表的函數，這組函數被稱為重載函數。
注意：重載與否，不考慮函數的返回類型。C++也是如此。也就是說，2個函數的返回類型同不同都不影響他們能不能形成重載，只要他們函數名相同，參數表不同就滿足重載。
Java是默認是支持跨類重載的。但是C++就默認不支持在子類中重載父類的實例方法。那也就是說：java中的實例方法會自動導入到子類的作用域中，而C++則不是。
public class Test
{
public static void main(String[] args)
{
Derive d = new Derive();
d.print("hello", 2);
d.print("world");
/* output
hello
hello
world
world
world
world
world
*/
}
}
class Base
{
public void print(String msg)
{
for(int i=0;i<5;++i)
{
System.out.println(msg);
}
}
}
class Derive extends Base
{
public void print(String msg,int times) //在子類中重載父類方法
{
for(int i=0;i<times;++i)
{
System.out.println(msg);
}
}
}
對於C++
#include<iostream>
#include<string>
using namespace std;
class Base
{
public :
void print(const string& msg) const
{
for(int i=0;i<5;++i)
{
std::cout<<msg<<std::endl;
}
}
};
class Derive:public Base
{
public :
/*
*需要使用using Base::print將父類中的版本引如到子類的作用域中，這樣才能形成跨類重載，否則子類在使用一個參數版本的print函數時，會出現以下編譯錯誤：
*
* error: no matching function for call to ‘Derive::print(const char [6])’
*意思是編譯器在Derive類中找不到print(const char [6])版本的函數
* */
using Base::print;
void print(const string& msg,const int times) const
{
for(int i=0;i<times;++i)
{
std::cout<<msg<<std::endl;
}
}
};
int main()
{
Derive d ;
d.print("hello",2);
d.print("world");
}
實例字段
實例字段沒有什麼要說的，要說的就是實例字段的隱藏了：在子類中定義一個和父類同名的字段，那麼子類中的名稱將會隱藏父類中的同名字段。
幾乎沒有人使用這個技術，如果用到了，那麼說明代碼設計有問題（bad code）。
class Base
{
protected int i = 100;
}
class Derive extends Base
{
private int i = 1000; //隱藏了父類字段 i
public void foo()
{
System.out.println(i); //代表this.i
System.out.println(this.i);
System.out.println(super.i); //使用父類被隱藏的i
}
}
也可以使用cast，這是最終極的手段。因為super只能引用直接父類的成員，而不能引用父類的父類的成員。但使用cast可以做到。
class A
{
protected int i = 100;
}
class B extends A
{
protected int i = 1000;
}
class C extends B
{
private int i = 10000;
public void foo()
{
System.out.println("this.i:"+this.i); //10000
System.out.println("B.this.i:"+ ((B)this).i ); //1000
System.out.println("A.this.i:"+ ((A)this).i ); //100
}
}
static會被子類繼承嗎？答案是會。他們會被繼承為子類的static成員，而不是子類實例的成員。
同樣，private static成員不會被繼承，只有 包訪問 權限 ，protected public 成員才會被繼承。
父類的private成員不會被子類繼承，子類不能訪問。 父類的 包訪問成員 繼承為子類的包訪問成員。就好像他們直接定義在子類中一樣。 父類的 protected 成員繼承為子類的protected 成員。就好像他們直接定義在子類中一樣。 父類的 public 成員繼承為子類的public 成員，就好像他們直接定義在子類中一樣。
static 成員同樣也可以使用實例成員的訪問修飾符 public ，包訪問，protected ， priavcte。
static方法
static方法不能被override，只能被隱藏。
static字段
和實例字段一樣，static字段也可以被隱藏。如果要引用被隱藏的父類static字段，則需要顯式的通過父類的類名來使用。隱藏static字段通常也最好不要使用。
構造函數不能繼承，但是子類一定可以(也必須)借用父類的構造函數。java保證：除了Object類對象，每一個類的實例在構造時，先去調用父類的構造函數。
我們自定義類的構造函數的第一句一定是super(xx,...)，如果不是，那麼第一句就一定是this(xx,...)去調用本類的另一個構造函數。
如果子類構造函數不顯式的調用super()，那麼，javac會自動插入super()，也就是父類無參數的構造函數。
對於構造函數，其實類中所有構造函數都是隱式static的。很明顯的例證就是 構造函數無需通過實例就可以調用。