java繼承內部類

Ⅰ java內部類使用，什麼時候該使用內部類及使

java中的內部類和介面加在一起，可以的解決常被C++程序員抱怨java中存在的一個問題 沒有多繼承。

每個內部類都能獨立的繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。

1.內部類繼承

因為內部類的構造器必須連接到指向其外圍類對象的引用，所以在繼承內部類的時候使用特殊語法。問題在於，指向外圍類對象的引用必須被初始化，而在導出類中不存在可連接的默認對象。所以必須要用特殊語法來明確說清楚他們之間的關聯。

[java]view plain

• classWithInner{

• classInner{}

• }

• .Inner{

• InheritInner(WithInnerwi){

• wi.super();

• }

• }

2 內部類覆蓋

當繼承一個外圍類的時候，內部類不會發生什麼變化。當明確的繼承一個內部類時會發生變化。

[java]view plain

• publicclassEgg{

• privateYolky;

• protectedclassYolk{

• publicYolk(){

• System.out.println("Egg.Yolk");

• }

• }

• publicEgg(){

• System.out.println("NewEgg");

• y=newYolk();

• }

• }

[java]view plain

• publicclassBigEggextendsEgg{

• publicclassYolk{

• publicYolk(){

• System.out.println("BigEgg.yolk()");

• }

• }

• publicstaticvoidmain(String[]args){

• newBigEgg();

• }

• }

輸出：

New Egg
Egg.Yolk

Ⅱ Java，內部類有什麼特別的好處嗎

提起Java內部類（Inner Class）可能很多人不太熟悉明埋飢，實際上類似的概念在C++里也有，那就是嵌套類（Nested Class），關於這兩者的區別與聯系，在下文中會有對比。內部類從表面上看，就是在類中又定義了一個類（下文會看到，內部類可以在很多地方定義），而實際上並沒有那麼簡單，乍看上去內部類似乎有些多餘，它的用處對於初學者來說可能並不是那麼顯著，但是隨著對它的深入了解，你會發現Java的設計者在內部類身上的確是用心良苦。學會使用內部類，是掌握Java高級編程的一部分，它可以讓你更優雅地設計你的程序結構。下面從以下幾個方面來介紹：

publicinterfaceContents{
intvalue();
}
publicinterfaceDestination{
StringreadLabel();
}
publicclassGoods{
{
privateinti=11;
publicintvalue(){
returni;
}
激返}
{
privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
publicDestinationdest(Strings){
returnnewGDestination(s);
}
publicContentscont(){
returnnewContent();
}
}
classTestGoods{
publicstaticvoidmain(String[]args){
Goodsp=newGoods();
Contentsc=p.cont();
Destinationd=p.dest("Beijing");
}
}

在這個例子里類Content和GDestination被定義在了類Goods內部，並且分別有著protected和private修飾符來控制訪問級別。Content代表著Goods的內容，而GDestination代表著Goods的目的地。它們分別實現了兩個介面Content和Destination。在後面的main方法里，直接用 Contents c和Destination d進行操作，你甚至連這兩個內部類的名字都沒有看見！這樣，內部類的第一個好處就體現出來了 隱藏你不想讓別人知道的操作，也即封裝性。

同時，我們也發現了在外部類作用范圍之外得到內部類對象的第一個方法，那就是利用其外部類的方法創建並返回。上例中的cont()和dest()方法就是這么做的。那麼還有沒有別的方法呢？當然有，其語法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在創建非靜態內部類對象時，一定要先創建起相應的外部類對象。至於原因，也就引出了我們下一個話題 非靜態內部類對象有著指向其外部類對象的引用，對剛才的例子稍作修改：

publicclassGoods{
privateintvalueRate=2;
{
privateinti=11*valueRate;
publicintvalue(){
returni;
}
}
{
液告privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
publicDestinationdest(Strings){
returnnewGDestination(s);
}
publicContentscont(){
returnnewContent();
}
}

在這里我們給Goods類增加了一個private成員變數valueRate，意義是貨物的價值系數，在內部類Content的方法value()計算價值時把它乘上。我們發現，value()可以訪問valueRate，這也是內部類的第二個好處 一個內部類對象可以訪問創建它的外部類對象的內容，甚至包括私有變數！這是一個非常有用的特性，為我們在設計時提供了更多的思路和捷徑。要想實現這個功能，內部類對象就必須有指向外部類對象的引用。Java編譯器在創建內部類對象時，隱式的把其外部類對象的引用也傳了進去並一直保存著。這樣就使得內部類對象始終可以訪問其外部類對象，同時這也是為什麼在外部類作用范圍之外向要創建內部類對象必須先創建其外部類對象的原因。

有人會問，如果內部類里的一個成員變數與外部類的一個成員變數同名，也即外部類的同名成員變數被屏蔽了，怎麼辦？沒事，Java里用如下格式表達外部類的引用：

outerClass.this

有了它，我們就不怕這種屏蔽的情況了。

靜態內部類

和普通的類一樣，內部類也可以有靜態的。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部的引用。這實際上和C++中的嵌套類很相像了，Java內部類與C++嵌套類最大的不同就在於是否有指向外部的引用這一點上，當然從設計的角度以及以它一些細節來講還有區別。

除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。

局部內部類

是的，Java內部類也可以是局部的，它可以定義在一個方法甚至一個代碼塊之內。

publicclassGoods1{
publicDestinationdest(Strings){
{
privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
returnnewGDestination(s);
}
publicstaticvoidmain(String[]args){
Goods1g=newGoods1();
Destinationd=g.dest("Beijing");
}
}

上面就是這樣一個例子。在方法dest中我們定義了一個內部類，最後由這個方法返回這個內部類的對象。如果我們在用一個內部類的時候僅需要創建它的一個對象並創給外部，就可以這樣做。當然，定義在方法中的內部類可以使設計多樣化，用途絕不僅僅在這一點。

下面有一個更怪的例子：

publicclassGoods2{
privatevoidinternalTracking(booleanb){
if(b){
classTrackingSlip{
privateStringid;
TrackingSlip(Strings){
id=s;
}
StringgetSlip(){
returnid;
}
}
TrackingSlipts=newTrackingSlip("slip");
Strings=ts.getSlip();
}
}
publicvoidtrack(){
internalTracking(true);
}
publicstaticvoidmain(String[]args){
Goods2g=newGoods2();
g.track();
}
}

你不能在if之外創建這個內部類的對象，因為這已經超出了它的作用域。不過在編譯的時候，內部類TrackingSlip和其他類一樣同時被編譯，只不過它由它自己的作用域，超出了這個范圍就無效，除此之外它和其他內部類並沒有區別。

匿名內部類

java的匿名內部類的語法規則看上去有些古怪，不過如同匿名數組一樣，當你只需要創建一個類的對象而且用不上它的名字時，使用內部類可以使代碼看上去簡潔清楚。它的語法規則是這樣的：

new interfacename(){......}; 或 new superclassname(){......};

下面接著前面繼續舉例子：

publicclassGoods3{
publicContentscont(){
returnnewContents(){
privateinti=11;
publicintvalue(){
returni;
}
};
}
}

這里方法cont()使用匿名內部類直接返回了一個實現了介面Contents的類的對象，看上去的確十分簡潔。

在java的事件處理的匿名適配器中，匿名內部類被大量的使用。例如在想關閉窗口時加上這樣一句代碼：

frame.addWindowListener(newWindowAdapter(){
publicvoidwindowClosing(WindowEvente){
System.exit(0);
}
});

有一點需要注意的是，匿名內部類由於沒有名字，所以它沒有構造函數（但是如果這個匿名內部類繼承了一個只含有帶參數構造函數的父類，創建它的時候必須帶上這些參數，並在實現的過程中使用super關鍵字調用相應的內容）。如果你想要初始化它的成員變數，有下面幾種方法：

如果是在一個方法的匿名內部類，可以利用這個方法傳進你想要的參數，不過記住，這些參數必須被聲明為final。

將匿名內部類改造成有名字的局部內部類，這樣它就可以擁有構造函數了。

在這個匿名內部類中使用初始化代碼塊。

為什麼需要內部類？

java內部類有什麼好處？為什麼需要內部類？

首先舉一個簡單的例子，如果你想實現一個介面，但是這個介面中的一個方法和你構想的這個類中的一個方法的名稱，參數相同，你應該怎麼辦？這時候，你可以建一個內部類實現這個介面。由於內部類對外部類的所有內容都是可訪問的，所以這樣做可以完成所有你直接實現這個介面的功能。

不過你可能要質疑，更改一下方法的不就行了嗎？

的確，以此作為設計內部類的理由，實在沒有說服力。

真正的原因是這樣的，java中的內部類和介面加在一起，可以的解決常被C++程序員抱怨java中存在的一個問題 沒有多繼承。實際上，C++的多繼承設計起來很復雜，而java通過內部類加上介面，可以很好的實現多繼承的效果。

Ⅲ Java為什麼要使用內部類

1.內部類提供進入其外圍類的綠色通道；
2.一般來說，內部類繼承自某個類或實現某個介面讓改指，和介面一起實現java中多重繼承；
3.private內部類給類的坦配設計者提供了一種途徑，通過這種方式可以完全阻止任何依賴於類型的編碼，並且完全隱藏了殲做實現的細節；
4.匿名內部類可以使得代碼更加地靈活。

Ⅳ 使用內部類讓Java實現「多繼承」

使用內部類讓Java實現 多繼承

眾所周知 Java沒有像c++那樣支持多繼承 但是我們可以使用介面或內部類來模擬實現多繼承

我們使用內部類來實現一個繼承自消費者笑禪 又繼承自生產者的派生類

實際上Java之所以設計出內部類這個概念 一方面是為了更好的封裝性 另一方面就是藉助內部類模擬實現多繼承

首先我們定義一個消費者抽象基類

view plainprint？

/** * Consumer Class *@author androidyue *Last Modified 上午 */ public abstract class Consumer { protected float buyPrice protected abstract void buyGoods（） }

跡升吵以下是生產者抽象基類

view plainprint？

/** * Procer Class *@author androidyue *Last Modified 上午 */ public abstract class Procer { protected float cost protected abstract void proce（） }

使用內部類實現 多繼承 的派生子類

view plainprint？姿侍

/** *Java實現 多繼承

*@author androidyue *Last Modified 上午 */ public class InnerClassDemo extends Procer { private ConsumerBuyer buyer

public void desribeMySelf（）{ System out println（ 使用Java模擬多繼承 ） this proce（） this buyer=new ConsumerBuyer（） this buyer buyGoods（）

}

@Override protected void proce（） { st= f System out println（ 我是生產者 我以每件 +st+ RMB的成本生產一件產品 然後以 元價格對外出售 ） }

class ConsumerBuyer extends Consumer{

@Override protected void buyGoods（） { this buyPrice= f System out println（ 我是消費者 我以 +this buyPrice+ RMB 買了一件售價 元的商品 不信吧 因為我也是生產者！^_^ ）

}

}

}

在程序入口調用

view plainprint？

/** * the entrance of application *@author androidyue *Last Modified 上午 */ public class AppMain { public static void main（String[] args）{ InnerClassDemo demo=new InnerClassDemo（） demo desribeMySelf（） }