java之內部類和匿名類（java匿名內部類寫法）

本文目錄一覽：

• 1、java內部類和匿名內部類的區別是什麼？
• 2、Java內部類和匿名內部類的區別
• 3、java內部類與匿名內部類作用是什麼？
• 4、java 內部類 匿名類
• 5、java內部類和匿名內部類的區別

java內部類和匿名內部類的區別是什麼？

//匿名內部類甚至沒有類名,(實際上有).

所以匿名內部類,只有一個實例,而且沒有引用.

如下面那個Thread類的匿名子類,你不能重複使用.

內部類,內部類有名字,但是他在類的內部.

他能訪問外部類的所有數據,包括private的.

甚至如果一個內部類,是在一個方法內的話,方法的局部變量,內部類也可以使用.

總體來說匿名內部類,和內部類效果差別不大.

在事件監聽和線程應用中經常使用.

//匿名內部類

public class T1 {

public static void main(String[] args) {

new Thread() {

public void run() {

System.out.println(“runing”);

}

}.start();

}

}

//內部嵌套類

public class T1 {

private static final class Thread1 extends Thread {

public void run() {

System.out.println(“runing”);

}

}

public static void main(String[] args) {

new Thread1().start();

}

}

Java內部類和匿名內部類的區別

內部類是一個class類中還有一個類並且是有引用的, 例如:

public class Test{

    public static void main(String[] args){

        A a = new A();

        a.toString();        //new一個內部類, 並賦值給A 變量, 可以繼續調用

         new A().toString();//這是匿名的, new出來以後沒有引用了

    }

    public class A{    

        public String toString(){

            System.out.println(“toString”);

            return “11”;

        }

    }

}

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 內部類 匿名類

內部類

一個類定義在另外一個類的內部，這個該類就被稱為內部類。內部類分為成員內部類(定義在外部類的成員位置)和局部內部類(定義在外部類的方法裡面)。

(1)成員內部類

class Outer{ class Inner { //成員內部類 }}

成員內部類的特點：

1、成員內部類可以直接訪問外部類的成員，包括私有的，也可以通過外部類名.this.成員名調用外部成員。

2、外部類訪問非靜態成員內部類的成員，必須要創建成員內部類對象；外部類可以通過類名直接訪問靜態內部類的靜態成員，包括私有的。

3、成員內部類和外部類不存在繼承關係

4、其他類中生成成員內部類的方式：Outer.Inner oi = new Outer().new Inner();

(2)局部內部類

class Outer{ public void method() { final int a = 10; class Inner { System.out.println(a); //局部內部類 } }}

局部內部類的特點：

1、可以直接訪問外部類的成員

2、在局部位置可以創建局部內部類對象，通過對象調用成員

注意：

局部內部類在訪問局部變量時，被訪問的變量必須用 final 修飾，這是因為局部變量隨着方法調用完畢就消失了，而內部類在堆內存中並不會立即消失，所以用 final 修飾，因為被 final 修飾的變量就成了常量，即使局部變量消失了，但數值並不會消失。

java內部類和匿名內部類的區別

內部類包含匿名內部類,

內部類:匿名內部類,成員內部類,方法內部類.

其實只要你區分一下匿名內部類和其他內部類的寫法對於他們的區別就很直觀了.

匿名內部類:class outer{

Thread t1=new Thread(){//這就是匿名內部類,沒有名字的內部類,寫於類以內,繼承或者實現一個方法,不可以被外部繼承(沒有名字怎麼繼承)

//代碼

}

}

方法內部類是寫於方法內部,可以被繼承,但是方法內部類只能引用方法里的常量.

成員內部類,寫於類中的,當做成員對待,屬於類的內部類,至於繼承和實現方面是最常用的.