java使用內部類
⑴ java為什麼要用內部類
1.內部類能訪問外圍類的所有成員，包括私有成員。
當生成一個內部類對象時，此對象與製造它的外圍類對象之間就有了一種聯系，所以它能訪問其外圍類對掘雹薯象的所有成肆和員，而不需要任何特殊的條件。如下面代碼所示：
[java]view plain
classOutterClass{
privateinti=1;
classInnerClass{判者
publicvoiddisplayPrivate(){
System.out.println(i);
}
}
}
publicclassMainClass{
publicstaticvoidmain(String[]args){
OutterClassoutter=newOutterClass();
OutterClass.InnerClassinner=outter.newInnerClass();
inner.displayPrivate();
}
}
由上面的代碼可以看出，內部類能夠訪問外部類的私有成員變數。在這段代碼中，還需要注意的是
①生成內部類對象，必須要先有外圍類對象，具體的做法請見代碼；
②內部類能訪問外圍類的私有成員這一點，C++中的嵌套類是沒有這個特性的。
2.內部類與static
①內部類不能含有static方法；
②內部類不能含有static數據成員，除非是static final；
③內部類可以繼承含有static成員的類。
3.匿名內部類
匿名內部類，看起來非常奇怪。因為它太簡潔了，但這也帶來一個好處，用匿名內部類寫出來的代碼通常比較簡潔啦！
⑵ 一個java內部類有幾個分類
共有四種內部類，分別是:
1.常規內部類
2.靜態內部類
3.局部內部類
4.匿名內部類
⑶ java的內部類與匿名內部類
public interface Contents {
int value();
}
激御public interface Destination {
String readLabel();
}
明則岩public class Goods {
private class Content implements Contents {
private int i = ;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = nt();
Destination d = 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);
注意在創建非靜態內部類對象時 一定要先創建起相應的外部類對象 至於原因 也就引出了我們下一個話題——
非靜態內部類對象有著指向其外部類對象的引用
對剛才的例子稍作修改
public class Goods {
private valueRate= ;
private class Content implements Contents {
private int i = *valueRate;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
修改的部分用藍色顯示了 在這里我們給Goods類增加了一個private成員變數valueRate 意義是貨物的價值系數 在內部類Content的方法value()計算價值時把它乘上 我們發現 value()可以訪問valueRate 這也是內部類的第二個好處——一個內部類對象可以訪問創建它的外部類對象的內容 甚至包括私有變數！這是一個非常有用的特性 為我們在設計時提供了更多的思路和捷徑 要想實現這個功能 內部類對象就必須有指向外部類對象的引用 Java編譯器在創建內部類對象時 隱式的把其外部類對象的引用也傳了進去並一直保存著 這樣就使得內部類對象始終可以訪問其外部類對象 同時這也是為什麼在外部類作用范圍之外向要創建內部類對象必須先創建其外部類對象的原因
有人會問 如果內部類里的一個成員變數與外部類的一個成員變數同名 也即外部類的同名成員變數被屏蔽了 怎麼辦？沒事 Java里用如下格式表達外部類的引用
outerClass this
有了它 我們就不怕這種屏蔽的情況了
靜態內部類
和普通的類一樣 內部類也可以有靜態的 不過和非靜態內部類相比 區別就在於靜態內部類沒有了指向外部的引用 這實際上和C++中的嵌套類很相像了 Java內部類與C++嵌套類最大的不同就在於是否有指向外部的引用這一點上 當然從設計的角度以及以它一些細節來講還有區別
除此之外 在任何非靜態內部類中 都不能有靜態數據 靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層） 不過靜態內部類中卻可以擁有這一切 這也算是兩者的第二個區別吧
局部內部類
是的 Java內部類也可以是局部的 它可以定義在一個方法甚至一個代碼塊之內
public class Goods {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() { return label; }
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods g= new Goods ();
Destination d = g dest( Beijing );
}
}
上面就是這樣一個例子 在方法dest中我們定義了一個內部類 最後由這個方法返回這個內部類的對象 如果我們在用一個內部類的時候僅需要創建它的一個對象並創給外部 就可以這樣做 當然 定義在方法中的內部類可以使設計多樣化 用途絕不僅僅在這一點
下面有一個更怪的例子
public class Goods {
private void internalTracking(boolean b) {
if(b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() { return id; }
}
TrackingSlip ts = new TrackingSlip( slip );
String s = ts getSlip();
}
}
public void track() { internalTracking(true); }
public static void main(String[] args) {
Goods g= new Goods ();
g track();
}
}
你不能在if之外創建這個內部類的對象 因為這已經超出了它的作用域 不過在編譯的時候 內部類TrackingSlip和其他類一樣同時被編譯 只不過它由它自己的作用域 超出了這個范圍就無效 除此之外它和其他內部類並沒有區別
匿名內部類
java的匿名內部類的語法規則看上去有些古怪 不過如同匿名數組一樣 當你只需要創建一個類的對象而且用不上它的名字時 使用內部類可以使代碼看上去簡潔清楚 它的語法規則是這樣的
// 有點js中 return function(){ };的意思
new interfacename(){ }; 或 new superclassname(){ };
// 介面的名字或者父類的名字
下面接著前面繼續舉例子
public class Goods {
public Contents cont(){
return new Contents(){
private int i = ;
public int value() {
return i;
}
};
}
}
這里方法cont()使用匿名內部類直接返回了一個實現了介面Contents的類的對象 看上去的確十分簡潔
在java的事件處理的匿名適配器中 匿名內部類被大量的使用 例如在想關閉窗口時加上這樣一句代碼
frame addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System exit( );
}
});
有一點需要注意的是 匿名內部類由於沒有名字 所以它沒有構造函數（但是如果這個匿名內部類繼承了一個只含有帶參數構造函數的父類 創建它的時候必須帶上這些參數 並在實現的過程中使用super關鍵字調用相應的內容） 如果你想要初始化它的成員變數 有下面幾種方法
如果是在一個方法的匿名內部類 可以利用這個方法傳進你想要的參數 不過記住 這些參數必須被聲明為final
將匿名內部類改造成有名字的局部內部類 這樣它就可以擁有構造函數了
在這個匿名內部類中使用初始化代碼塊
為什麼需要內部類？
java內部類有什麼好處？為什麼需要內部類？
首先舉一個簡單的例子 如果你想實現一個介面 但是這個介面中的一個方法和你構想的這個類中的一個方法的名稱 參數相同 你應該怎麼辦？這時候 你可以建一個內部類實現這個介面 由於內部類對外部類的所有內容都是可訪問的 所以這樣做可以完成所有你直接實現這個介面的功能
不過你可能要質疑 更改一下方法的不就行了嗎？
的確 以此作為設計內部類的理由 實在沒有說服力
lishixin/Article/program/Java/hx/201311/26601
⑷ 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內部類有幾種
Java中的幾種內部類：
成員內部類：作為外部類的一個成員存在，與外部類的屬性、方法並列。當某個類除了他的外部類，不會被其他類使用時應該選擇使用成員內部類。
局部內部類：局部內部類定義在外部類的某個代碼塊或方法塊中。如果只會在某個方法或塊中創建這個類的對象，就可以使用局部內部類。
匿名內部類：匿名內部類一般定義在需要傳遞介面或回調的的地方，一個匿名內部類一定是在new的後面，用其隱含實現一個介面或繼承一個類。假如只需要創建這個類的一個對象不需要知道其實際類型(不需要使用到類名)，那麼就可以使用匿名內部類。
靜態內部類：和成員內部類一樣，作為外部類的一個成員存在，與外部類的屬性、方法並列，只不過在聲明類的時候加入了static關鍵字。有時候，使用內部類只是為了把一個類隱藏在另外一個類的內部，並不需要內部類引用外圍類對象。這時可以使用靜態內部類，以便取消產生對外部類的引用。
⑹ 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（） }
lishixin/Article/program/Java/hx/201311/25912
⑻ java中內部類
在java語言中，有一種類叫做內部類(inner class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時，內部類的名稱為OuterClass$InnerClass.class 。
1、內部類訪問數據變數
當在某些時候，內部類中定義的變數與外部類中變數名稱相同時，如何確保正確地訪問每一個變數呢？
1.1在main中直接從外部類調用內部類的方法
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}
void print()
{
Inner inner = new Inner();//得到內部類的引用
inner.print();
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在這里內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指針前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。
1.2在main中顯式返回內部類引用
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。
1.3當main方法在Outer類內部
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此處變化
inner.print();
}
}
因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。
1.4在main方法中直接產生內部類對象
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此處變化
inner.print();
}
}
在利用new構造方法構造一個外部類對象時，並沒有連帶著構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。
2、局部內部類
在方法中定義的內部類是局部內部類，它只能訪問方法中的final類型的局部變數，因為用final定義的局部變數相當於是一個常量，延長了其生命周期，使得方法在消亡時，其內部類仍可以訪問該變數。另外，它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有訪問修飾符。
class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println("This is Inner.");//此句可看出它與匿名內部類用法的不同。
}
public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必須放在定義類Inner的後面
inner.print();
}
public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class
3、匿名內部類
匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些獨有特性：
匿名內部類必須擴展一個基類或實現一個介面，但是不能有顯式的extends和implements子句；
匿名內部類必須實現父類以及介面中的所有抽象方法；
匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個介面，則其構造方法是Object()；
匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。
abstract class A
{
abstract public void sayHello();
}
class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println("Hello!");
}
});
}
public void callInner(A a)
{
a.sayHello();
}
}
4、靜態內部類
和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類實例化的時候不必先實例化外圍類，可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類，才能再實例化本身。
5．內部類的繼承
當一個類繼承自一個內部類時，預設的構造器不可用。必須使用如下語法：
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println("Hello.");
}
}
}
public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先創建一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；
6、內部類的2種特殊用法
一個類從另一個類派生出來，又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。
interface Machine
{
void run();
}
class Person
{
void run()
{
System.out.println("run");
}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}
Machine getMachine()
{
return new MachineHeart();
}
}
class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine，則該如何調用父類的run方法？
利用內部類可解決c++中多重繼承所解決的問題
class A
{
void fn1()
{
System.out.println("It' s fn1.");
}
}
abstract class B
{
abstract void fn2();
}
class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println("It' s fn2.");
}
};
}
}
class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。
一般情況下 當我們需要在某一情形下實現一個介面，而在另一情形下又不需要實現這個介面時，我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。
⑼ Java 語言中使用內部類有什麼好處
一個類，要實現兩個介面，分別是介面A和介面B，介面A和介面B都有一個名字一樣的方法f（）；
此時就可以使用內部類實現介面B，外部類實現介面A。寫程序的時候內部類使用還是比較少的，這里只是舉個例子而已.內部類的用法還有很多，一般來說，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建它的外圍類的對象。所以可以認為內部類提供了某種進入其外圍類的窗口！
⑽ java內部類怎麼使用
1.內部類的方法可以訪問它所在的外部類中的所有域，包括私有型別的；
2.對於同一個包中的其它類它是隱藏的；
3. 匿名的內部類可以讓我們很方便的定義事件響應(call back)，這在GUI編程中很常見
interface OutInterface{ //定義一個介面 public void f(); } public class InterfaceInner { //主類 public static void main(String args[]){ OuterClass2 out=new OuterClass2(); OutInterface outinter=out.doit(); outinter.f(); } } class OuterClass2{ //定義一個內部類，並且介面OutInterface private class InnerClass implements OutInterface{ InnerClass(String s){ System.out.println(s); } public void f(){ System.out.println("訪問內部類中的f()方法"); } } public OutInterface doit(){ //方法返回介面 return new InnerClass("訪問內部類構造方法"); } }