public class Privateoverride { 
  private void f() { System.out.println("private f()"); }
  public static main(String[] args) {
    PrivateOverride po = new Derived();
    po.f();
  }
}
class Derived extends PrivateOverride {
  public void f() { System.out.println("public f()"); }  

執行結果是：private f()
例子解釋說是由於基類中的private方法對於匯出類是不可見的

父類引用指向子類例項，編譯時引用呼叫的方法，編譯器只看父類是否有這個方法，如果父類的對應方法是private，且呼叫方法的方法和父類不在同一個類中，則編譯出錯，子類也不可以實現父類的private方法。如果對應方法是default，且呼叫方法的方法和父類不是同一個包，即使子類覆寫了父類的方法也會編譯出錯。如果對應方法是protected，則子類一定可以呼叫父類的protected方法，無論子類是否重寫該方法，編譯一定通過，因為protected的許可權是同包或子類範圍可以訪問。

=================-==================================

內部類根據位置的不同，可以分為兩種情況。
1        內部類在成員位置,在這總情況下實現內部的例項物件方法是：外部類名.內部類名 名字 = 外部類物件.內部類物件    Outter.Inner oi = new Outter().new Inner();
注意：若內部類被靜態修飾時，則變為外部類名.內部類名 物件名 = new 外部類.內部類()
注意：如果Inner類含有被static修飾的成員時，則Inner也必須被static修飾。當外部類的靜態方法訪問內部類時，該內部類Inner也必須為靜態。
2        內部類在區域性時可以直接訪問外部類中的成員，也可以直接訪問區域性成員，但是區域性成員要用final修飾。

內部類的共性 
　　內部類分為: 成員內部類、靜態巢狀類、方法內部類、匿名內部類。 
　　(1)、內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class檔案，但是前面冠以外部類的類名和$符號。 
　　(2)、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。 
　　(3)、內部類宣告成靜態的，就不能隨便的訪問外部類的成員變數，仍然是隻能訪問外部類的靜態成員變數。

class Outer
{ 
　　class Inner{} 
}

編譯上述程式碼會產生兩個檔案：Outer.class和Outer$Inner.class

//把類放在方法內
class Outer { 
　　public void doSomething(){ 
　　    class Inner
        {
　　public void seeOuter(){ } 
} 
　　} 
} 
 

(1)、方法內部類只能在定義該內部類的方法內例項化，不可以在此方法外對其例項化。 
(2)、方法內部類物件不能使用該內部類所在方法的非final區域性變數。 
因為方法的區域性變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，區域性變數成為歷史。但是該方法結束之後，在方法內建立的內部類物件可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些程式碼，並存儲在一個成員變數內。正因為不能保證區域性變數的存活期和方法內部類物件的一樣長，所以內部類物件不能使用它們。
下面是完整的例子： 

class Outer { 
	public void doSomething(){ 
　　		final int a =10; 
　　		class Inner{ 
　　			public void seeOuter(){ 
　　				System.out.println(a); 
　　			} 
　　		} 
　		Inner in = new Inner(); 
　	　	in.seeOuter(); 
　　	} 
　　	public static void main(String[] args) { 
　　		Outer out = new Outer(); 
　　		out.doSomething(); 
　　	} 
}

=================-=======================================

匿名內部類 
顧名思義，沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。 
匿名內部類就是沒有名字的內部類。什麼情況下需要使用匿名內部類？

如果滿足下面的一些條件，使用匿名內部類是比較合適的： 
1.只用到類的一個例項。 
2.類在定義後馬上用到。 
3.類非常小（SUN推薦是在4行程式碼以下） 
4.給類命名並不會導致你的程式碼更容易被理解。 
　　

在使用匿名內部類時，要記住以下幾個原則： 
1.匿名內部類不能有構造方法。 
2.匿名內部類不能定義任何靜態成員、方法和類。 
3.匿名內部類不能是public,protected,private,static。 
4.只能建立匿名內部類的一個例項。 
5.一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。 
6.因匿名內部類為區域性內部類，所以區域性內部類的所有限制都對其生效。 

//A、繼承式的匿名內部類 
public class Car { 
	public void drive(){ 
		System.out.println("Driving a car!"); 
　　	} 
	public static void main(String[] args) { 
		Car car = new Car(){ 
			public void drive() { 
			　　System.out.println("Driving anther car!"); 
　　			} 
　　		}; 
　　	car.drive(); 
　　	} 
} 
//結果輸出了：Driving another car! Car引用變數不是引用Car物件，而是Car匿名子類的物件。

//B、介面式的匿名內部類。 
interface Vehicle { 
	public void drive(); 
} 
class Test{ 
	public static void main(String[] args) { 
		Vehicle v = new Vehicle(){ 
			public void drive(){ 
				System.out.println("Driving a car!"); 
			} 
		}; 
		v.drive(); 
	} 
} 
//上面的程式碼很怪，好像是在例項化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面。

//C、引數式的匿名內部類。 
class Bar{ 
	void doStuff(Foo f){} 
} 

interface Foo{ 
	void foo(); 
} 

class Test{ 
	static void go(){ 
		Bar b = new Bar(); 
		b.doStuff(new Foo(){ 
			public void foo(){ 
				System.out.println("foofy"); 
			} 
		}); 
	} 
}

靜態巢狀類 
靜態內部類中可以定義靜態或者非靜態的成員。 
從技術上講，靜態巢狀類不屬於內部類。因為內部類與外部類共享一種特殊關係，更確切地說是對例項的共享關係。而靜態巢狀類則沒有上述關係。它只是位置在另一個類的內部，因此也被稱為頂級巢狀類。 
靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類物件時，也能夠訪問它。靜態巢狀類不能訪問外部類的成員和方法。

class Outer{ 
	static class Inner{} 
} 

class Test { 
	public static void main(String[] args){ 
		Outer.Inner n = new Outer.Inner(); 
	} 
} 

為什麼需要內部類？ 
典型的情況是，內部類繼承自某個類或實現某個介面，內部類的程式碼操作建立其的外圍類的物件。所以你可以認為內部類提供了某種進入其外圍類的視窗。

使用內部類最吸引人的原因是： 
每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與程式設計問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效地實現了“多重繼承”。