當前位置:首頁 » 編程語言 » 匿名類java

匿名類java

發布時間: 2025-01-30 16:02:52

『壹』 請問java中匿名內部類有什麼用,舉個例子,謝謝

匿名內部類的特點:

1,一個類用於繼承其他類或是實現介面,並不需要增加額外的方法,只是對繼承方法的事先或是覆蓋。
2,只是為了獲得一個對象實例,不需要知道其實際類型。
3,類名沒有意義,也就是不需要使用到。

public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){

}
public void outer_f2(){

}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
// outer_f2();//包括非靜態變數和非靜態方法
}
}

public void outer_f3(){
// 外部類訪問內部類的靜態成員:內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();

}
public static void main(String[] args) {
new Outer().outer_f3();
}

}

註:一個匿名內部類一定是在new的後面,用其隱含實現一個介面或實現一個類,沒有類名,根據多態,我們使用其父類名。因他是局部內部類,那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法,所以其使用范圍非常的有限。當需要多個對象時使用局部內部類,因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。

『貳』 java內部類與匿名內部類作用是什麼

Java 內部類
分四種:成員內部類、局部內部類、靜態內部類和匿名內部類。
1、成員內部類: 即作為外部類的一個成員存在,與外部類的屬性、方法並列。
注意:成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。
public class Outer{
private static int i = 1;
private int j=10;
private int k=20;
public static void outer_f1(){
//do more something
}
public void out_f2(){
//do more something
}

//成員內部類
class Inner{
//static int inner_i =100; //內部類中不允許定義靜態變數
int j=100;//內部類中外部類的實例變數可以共存
int inner_i=1;
void inner_f1(){
System.out.println(i);//外部類的變數如果和內部類的變數沒有同名的,則可以直接用變數名訪問外部類的變數
System.out.println(j);//在內部類中訪問內部類自己的變數直接用變數名
System.out.println(this.j);//也可以在內部類中用"this.變數名"來訪問內部類變數
//訪問外部類中與內部類同名的實例變數可用"外部類名.this.變數名"。
System.out.println(k);//外部類的變數如果和內部類的變數沒有同名的,則可以直接用變數名訪問外部類的變數
outer_f1();
outer_f2();
}
}
//外部類的非靜態方法訪問成員內部類
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}

//外部類的靜態方法訪問成員內部類,與在外部類外部訪問成員內部類一樣
public static void outer_f4(){
//step1 建立外部類對象
Outer out = new Outer();
//***step2 根據外部類對象建立內部類對象***
Inner inner=out.new Inner();
//step3 訪問內部類的方法
inner.inner_f1();
}

public static void main(String[] args){
outer_f4();
}
}
成員內部類的優點:
⑴ 內部類作為外部類的成員,可以訪問外部類的私有成員或屬性。(即使將外部類聲明為PRIVATE,但是對於處於其內部的內部類還是可見的。)
⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問許可權。
注意:內部類是一個編譯時的概念,一旦編譯成功,就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
2、局部內部類: 即在方法中定義的內部類,與局部變數類似,在局部內部類前不加修飾符public或private,其范圍為定義它的代碼塊。
注意:局部內部類中不可定義靜態變數,可以訪問外部類的局部變數(即方法內的變數),但是變數必須是final的。
public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k){
final int s = 200;
int i = 1;
final int j = 10;
class Inner{ //定義在方法內部
int s = 300;//可以定義與外部類同名的變數
//static int m = 20;//不可以定義靜態變數
Inner(int k){
inner_f(k);
}
int inner_i = 100;
void inner_f(int k){
System.out.println(out_i);//如果內部類沒有與外部類同名的變數,在內部類中可以直接訪問外部類的實例變數
System.out.println(k);//*****可以訪問外部類的局部變數(即方法內的變數),但是變數必須是final的*****
// System.out.println(i);
System.out.println(s);//如果內部類中有與外部類同名的變數,直接用變數名訪問的是內部類的變數
System.out.println(this.s);//用"this.變數名" 訪問的也是內部類變數
System.out.println(Outer.this.s);//用外部"外部類類名.this.變數名" 訪問的是外部類變數
}
}
new Inner(k);
}

public static void main(String[] args) {
//訪問局部內部類必須先有外部類對象
Outer out = new Outer();
out.f(3);
}

}

注意:
在類外不可直接生成局部內部類(保證局部內部類對外是不可見的)。要想使用局部內部類時需要生成對象,對象調用方法,在方法中才能調用其局部內部類。通過內部類和介面達到一個強制的弱耦合,用局部內部類來實現介面,並在方法中返回介面類型,使局部內部類不可見,屏蔽實現類的可見性。

3、靜態內部類: 靜態內部類定義在類中,任何方法外,用static定義。
注意:靜態內部類中可以定義靜態或者非靜態的成員
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){

}
public void outer_f2(){

}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
// outer_f2();//包括非靜態變數和非靜態方法
}

}

public void outer_f3(){
// 外部類訪問內部類的靜態成員:內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();

}
public static void main(String[] args) {
new Outer().outer_f3();
}

}

注意:*******生成(new)一個靜態內部類不需要外部類成員:這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成:
Outer.Inner in=new Outer.Inner();
而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******

例子:
對於兩個類,擁有相同的方法:
class People
{
run();
}
class Machine{
run();
}
此時有一個robot類:
class Robot extends People implement Machine.
此時run()不可直接實現。
注意:當類與介面(或者是介面與介面)發生方法命名沖突的時候,此時必須使用內部類來實現。用介面不能完全地實現多繼承,用介面配合內部類才能實現真正的多繼承。

4、匿名內部類
匿名內部類是一種特殊的局部內部類,它是通過匿名類實現介面。
IA被定義為介面。
IA I=new IA(){};

匿名內部類的特點:

1,一個類用於繼承其他類或是實現介面,並不需要增加額外的方法,只是對繼承方法的事先或是覆蓋。
2,只是為了獲得一個對象實例,不需要知道其實際類型。
3,類名沒有意義,也就是不需要使用到。

public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){

}
public void outer_f2(){

}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
// outer_f2();//包括非靜態變數和非靜態方法
}
}

public void outer_f3(){
// 外部類訪問內部類的靜態成員:內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();

}
public static void main(String[] args) {
new Outer().outer_f3();
}

}

註:一個匿名內部類一定是在new的後面,用其隱含實現一個介面或實現一個類,沒有類名,根據多態,我們使用其父類名。因他是局部內部類,那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法,所以其使用范圍非常的有限。當需要多個對象時使用局部內部類,因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。

________________________________________________________________________________

內部類總結:
1.首先,把內部類作為外部類的一個特殊的成員來看待,因此它有類成員的封閉等級:private ,protected,默認(friendly),public
它有類成員的修飾符: static,final,abstract
2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此,它可以訪問外部類的一切資源(當然包括private)
外部類訪問內部類的成員,先要取得內部類的對象,並且取決於內部類成員的封裝等級。
非靜態內部類不能包含任何static成員.
3.靜態內部類:static inner class,不再包含外部類的this指針,並且在外部類裝載時初始化.
靜態內部類能包含static或非static成員.
靜態內部類只能訪問外部類static成員.
外部類訪問靜態內部類的成員,循一般類法規。對於static成員,用類名.成員即可訪問,對於非static成員,只能
用對象.成員進行訪問

4.對於方法中的內部類或塊中內部類只能訪問塊中或方法中的final變數。

類成員有兩種static , non-static,同樣內部類也有這兩種
non-static 內部類的實例,必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),並且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用
static 內部類的實例, 直接創建即可,沒有對外部類實例的引用。
內部類不管static還是non-static都有對外部類的引用
non-static 內部類不允許有static成員

方法中的內部類只允許訪問方法中的final局部變數和方法的final參數列表,所以說方法中的內部類和內部類沒什麽區別。但方法中的內部類不能在方法以外訪問,方法中不可以有static內部類
匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

『叄』 java匿名內部類具體概念是什麼,在什麼地方用到

java匿名內部類一定是在new的後面,用其隱含實現一個介面或實現一個類,沒有類名,根據多態,我們使用其父類名。因他是局部內部類,那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法,所以其使用范圍非常的有限。當需要多個對象時使用局部內部類,因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。

示例如下:

publicclassOuter{
privatestaticinti=1;
privateintj=10;
publicstaticvoidouter_f1(){

}
publicvoidouter_f2(){

}
//靜態內部類可以用public,protected,private修飾
//靜態內部類中可以定義靜態或者非靜態的成員
staticclassInner{
staticintinner_i=100;
intinner_j=200;
staticvoidinner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
voidinner_f2(){
//System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
//outer_f2();//包括非靜態變數和非靜態方法
}
}

publicvoidouter_f3(){
//外部類訪問內部類的靜態成員:內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
//外部類訪問內部類的非靜態成員:實例化內部類即可
Innerinner=newInner();
inner.inner_f2();

}
publicstaticvoidmain(String[]args){
newOuter().outer_f3();
}

}

『肆』 java內部類與匿名內部類作用分別是什麼

Java 內部類 x0dx0a分四種:成員內部類、局部內部類、靜態內部類和匿名內部類。 x0dx0a1、成員內部類: 即作為外部類的一個成員存在,與外部類的屬性、方法並列。x0dx0a注意:成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。x0dx0apublic class Outer{x0dx0aprivate static int i = 1;x0dx0aprivate int j=10;x0dx0aprivate int k=20;x0dx0apublic static void outer_f1(){x0dx0a //do more somethingx0dx0a}x0dx0apublic void out_f2(){x0dx0a //do more somethingx0dx0a}x0dx0ax0dx0a//成員內部類x0dx0aclass Inner{x0dx0a//static int inner_i =100; //內部類中不允許定義靜態變數x0dx0aint j=100;//內部類中外部類的實例變數可以共存x0dx0aint inner_i=1;x0dx0avoid inner_f1(){x0dx0a System.out.println(i);//外部類的變數如果和內部類的變數沒有同名的,則可以直接用變數名訪問外部類的變數x0dx0a System.out.println(j);//在內部類中訪問內部類自己的變數直接用變數名x0dx0a System.out.println(this.j);//也可以在內部類中用"this.變數名"來訪問內部類變數x0dx0a //訪問外部類中與內部類同名的實例變數可用"外部類名.this.變數名"。x0dx0a System.out.println(k);//外部類的變數如果和內部類的變數沒有同名的,則可以直接用變數名訪問外部類的變數x0dx0a outer_f1();x0dx0a outer_f2();x0dx0a}x0dx0a}x0dx0a//外部類的非靜態方法訪問成員內部類x0dx0apublic void outer_f3(){x0dx0a Inner inner = new Inner();x0dx0a inner.inner_f1();x0dx0a}x0dx0ax0dx0a//外部類的靜態方法訪問成員內部類,與在外部類外部訪問成員內部類一樣x0dx0apublic static void outer_f4(){x0dx0a //step1 建立外部類對象x0dx0a Outer out = new Outer();x0dx0a //***step2 根據外部類對象建立內部類對象***x0dx0a Inner inner=out.new Inner();x0dx0a //step3 訪問內部類的方法x0dx0a inner.inner_f1();x0dx0a}x0dx0ax0dx0apublic static void main(String[] args){x0dx0a outer_f4();x0dx0a}x0dx0a}x0dx0a成員內部類的優點:x0dx0a⑴ 內部類作為外部類的成員,可以訪問外部類的私有成員或屬性。(即使將外部類聲明為PRIVATE,但是對於處於其內部的內部類還是可見的。)x0dx0a⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問許可權。x0dx0a注意:內部類是一個編譯時的概念,一旦編譯成功,就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。x0dx0a2、局部內部類: 即在方法中定義的內部類,與局部變數類似,在局部內部類前不加修飾符public或private,其范圍為定義它的代碼塊。x0dx0a注意:局部內部類中不可定義靜態變數,可以訪問外部類的局部變數(即方法內的變數),但是變數必須是final的。x0dx0apublic class Outer {x0dx0a private int s = 100;x0dx0a private int out_i = 1;x0dx0a public void f(final int k){x0dx0a final int s = 200;x0dx0a int i = 1;x0dx0a final int j = 10;x0dx0a class Inner{ //定義在方法內部x0dx0a int s = 300;//可以定義與外部類同名的變數x0dx0a //static int m = 20;//不可以定義靜態變數x0dx0a Inner(int k){x0dx0a inner_f(k);x0dx0a }x0dx0a int inner_i = 100;x0dx0a void inner_f(int k){x0dx0a System.out.println(out_i);//如果內部類沒有與外部類同名的變數,在內部類中可以直接訪問外部類的實例變數x0dx0a System.out.println(k);//*****可以訪問外部類的局部變數(即方法內的變數),但是變數必須是final的*****x0dx0a// System.out.println(i);x0dx0a System.out.println(s);//如果內部類中有與外部類同名的變數,直接用變數名訪問的是內部類的變數x0dx0a System.out.println(this.s);//用"this.變數名" 訪問的也是內部類變數x0dx0a System.out.println(Outer.this.s);//用外部"外部類類名.this.變數名" 訪問的是外部類變數x0dx0a }x0dx0a }x0dx0a new Inner(k);x0dx0a }x0dx0ax0dx0a public static void main(String[] args) {x0dx0a //訪問局部內部類必須先有外部類對象x0dx0a Outer out = new Outer();x0dx0a out.f(3);x0dx0a }x0dx0ax0dx0a}x0dx0ax0dx0a注意:x0dx0a在類外不可直接生成局部內部類(保證局部內部類對外是不可見的)。要想使用局部內部類時需要生成對象,對象調用方法,在方法中才能調用其局部內部類。通過內部類和介面達到一個強制的弱耦合,用局部內部類來實現介面,並在方法中返回介面類型,使局部內部類不可見,屏蔽實現類的可見性。x0dx0ax0dx0a3、靜態內部類: 靜態內部類定義在類中,任何方法外,用static定義。x0dx0a注意:靜態內部類中可以定義靜態或者非靜態的成員x0dx0apublic class Outer {x0dx0a private static int i = 1;x0dx0a private int j = 10;x0dx0a public static void outer_f1(){x0dx0a x0dx0a }x0dx0a public void outer_f2(){x0dx0a x0dx0a }x0dx0a// 靜態內部類可以用public,protected,private修飾x0dx0a// 靜態內部類中可以定義靜態或者非靜態的成員x0dx0a static class Inner{x0dx0a static int inner_i = 100;x0dx0a int inner_j = 200;x0dx0a static void inner_f1(){x0dx0a System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員x0dx0a outer_f1();//包括靜態變數和靜態方法x0dx0a }x0dx0a void inner_f2(){x0dx0a// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員x0dx0a// outer_f2();//包括非靜態變數和非靜態方法x0dx0a } x0dx0a x0dx0a }x0dx0a x0dx0a public void outer_f3(){x0dx0a// 外部類訪問內部類的靜態成員:內部類.靜態成員x0dx0a System.out.println(Inner.inner_i);x0dx0a Inner.inner_f1();x0dx0a// 外部類訪問內部類的非靜態成員:實例化內部類即可x0dx0a Inner inner = new Inner();x0dx0a inner.inner_f2();x0dx0a x0dx0a }x0dx0a public static void main(String[] args) {x0dx0a new Outer().outer_f3();x0dx0a }x0dx0ax0dx0a}x0dx0ax0dx0a注意:*******生成(new)一個靜態內部類不需要外部類成員:這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成:x0dx0aOuter.Inner in=new Outer.Inner();x0dx0a而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******x0dx0ax0dx0a例子:x0dx0a對於兩個類,擁有相同的方法:x0dx0aclass Peoplex0dx0a{x0dx0a run();x0dx0a}x0dx0aclass Machine{x0dx0a run();x0dx0a}x0dx0a此時有一個robot類:x0dx0aclass Robot extends People implement Machine.x0dx0a此時run()不可直接實現。x0dx0a注意:當類與介面(或者是介面與介面)發生方法命名沖突的時候,此時必須使用內部類來實現。用介面不能完全地實現多繼承,用介面配合內部類才能實現真正的多繼承。x0dx0ax0dx0a4、匿名內部類 x0dx0a匿名內部類是一種特殊的局部內部類,它是通過匿名類實現介面。x0dx0aIA被定義為介面。x0dx0aIA I=new IA(){};x0dx0ax0dx0a匿名內部類的特點:x0dx0ax0dx0a1,一個類用於繼承其他類或是實現介面,並不需要增加額外的方法,只是對繼承方法的事先或是覆蓋。x0dx0a2,只是為了獲得一個對象實例,不需要知道其實際類型。x0dx0a3,類名沒有意義,也就是不需要使用到。x0dx0ax0dx0apublic class Outer {x0dx0a private static int i = 1;x0dx0a private int j = 10;x0dx0a public static void outer_f1(){x0dx0a x0dx0a }x0dx0a public void outer_f2(){x0dx0a x0dx0a }x0dx0a// 靜態內部類可以用public,protected,private修飾x0dx0a// 靜態內部類中可以定義靜態或者非靜態的成員x0dx0a static class Inner{x0dx0a static int inner_i = 100;x0dx0a int inner_j = 200;x0dx0a static void inner_f1(){x0dx0a System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員x0dx0a outer_f1();//包括靜態變數和靜態方法x0dx0a }x0dx0a void inner_f2(){x0dx0a// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員x0dx0a// outer_f2();//包括非靜態變數和非靜態方法x0dx0a }x0dx0a }x0dx0a x0dx0a public void outer_f3(){x0dx0a// 外部類訪問內部類的靜態成員:內部類.靜態成員x0dx0a System.out.println(Inner.inner_i);x0dx0a Inner.inner_f1();x0dx0a// 外部類訪問內部類的非靜態成員:實例化內部類即可x0dx0a Inner inner = new Inner();x0dx0a inner.inner_f2();x0dx0a x0dx0a }x0dx0a public static void main(String[] args) {x0dx0a new Outer().outer_f3();x0dx0a }x0dx0ax0dx0a}x0dx0ax0dx0a註:一個匿名內部類一定是在new的後面,用其隱含實現一個介面或實現一個類,沒有類名,根據多態,我們使用其父類名。因他是局部內部類,那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法,所以其使用范圍非常的有限。當需要多個對象時使用局部內部類,因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面,那麼其運行的類型為實現這個介面的類。x0dx0ax0dx0a________________________________________________________________________________x0dx0ax0dx0a內部類總結:x0dx0a1.首先,把內部類作為外部類的一個特殊的成員來看待,因此它有類成員的封閉等級:private ,protected,默認(friendly),publicx0dx0a 它有類成員的修飾符: static,final,abstractx0dx0a2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此,它可以訪問外部類的一切資源(當然包括private)x0dx0a 外部類訪問內部類的成員,先要取得內部類的對象,並且取決於內部類成員的封裝等級。x0dx0a 非靜態內部類不能包含任何static成員.x0dx0a3.靜態內部類:static inner class,不再包含外部類的this指針,並且在外部類裝載時初始化.x0dx0a 靜態內部類能包含static或非static成員.x0dx0a 靜態內部類只能訪問外部類static成員.x0dx0a 外部類訪問靜態內部類的成員,循一般類法規。對於static成員,用類名.成員即可訪問,對於非static成員,只能x0dx0a 用對象.成員進行訪問x0dx0ax0dx0a4.對於方法中的內部類或塊中內部類只能訪問塊中或方法中的final變數。x0dx0ax0dx0a類成員有兩種static , non-static,同樣內部類也有這兩種x0dx0anon-static 內部類的實例,必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),並且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用x0dx0astatic 內部類的實例, 直接創建即可,沒有對外部類實例的引用。x0dx0a內部類不管static還是non-static都有對外部類的引用x0dx0anon-static 內部類不允許有static成員x0dx0ax0dx0a方法中的內部類只允許訪問方法中的final局部變數和方法的final參數列表,所以說方法中的內部類和內部類沒什麽區別。但方法中的內部類不能在方法以外訪問,方法中不可以有static內部類x0dx0a匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數 x0dx0a匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

熱點內容
des加密畢業論文 發布:2025-01-31 02:57:01 瀏覽:710
ip跨網段訪問 發布:2025-01-31 02:44:42 瀏覽:708
演算法帶頭人 發布:2025-01-31 02:42:25 瀏覽:551
方舟上傳數據 發布:2025-01-31 02:42:25 瀏覽:835
鈴木uy比uu多了什麼配置 發布:2025-01-31 02:34:11 瀏覽:676
蝦米音樂緩存文件夾 發布:2025-01-31 02:34:04 瀏覽:886
主播用什麼我的世界啟動器玩伺服器 發布:2025-01-31 02:32:37 瀏覽:643
做電腦硬體需要哪些配置 發布:2025-01-31 02:30:53 瀏覽:439
小米智能門鎖驗證密碼是多少 發布:2025-01-31 02:30:50 瀏覽:533
oracle和sql區別 發布:2025-01-31 02:27:40 瀏覽:241