java內部類作用

Ⅰ java 內部類和外部類的區別

1. Java項目一般從src目錄開始有com...A.java這樣的目錄結構。這就是包結構。所以一般編譯後的結構是跟包結構一模一樣的，這樣的結構保證了import時能找到正確的class引用包訪問許可權就是指同包下的類可見。
import 一般加上全路徑，並且使用.*時只包含當前目錄的所有類文件，不包括子目錄。
2. 外部類只有public和default兩種修飾，要麼全局可訪問，要麼包內可訪問。
3. 內部類可以有全部訪問許可權，因為它的概念就是一個成員變數，所以訪問許可權設置與一般的成員變數相同。
非靜態內部類是外部類的一個成員變數，只跟外部類的實例有關。
靜態內部類是獨立於外部類存在的一個類，與外部類實例無關，可以通過外部類.內部類直接獲取Class類型。
想要了解更多可以跟我一起討論哦

Ⅱ Java 靜態內部類作用

1、變值許可權修飾作用，在定義內部類的時候，可以在其前面加上一個許可權修飾符static。此時這個內部類就變為了靜態內部類。

2、在某些特殊的情況下，少了這個靜態內部類還真是不行。如在進行代碼程序測試的時候，如果在每一個Java源文件中都設置一個主方法(主方法是某個應用程序的入口，必須具有)，那麼會出現很多額外的代碼。

3、最主要的時這段主程序的代碼對於Java文件來說，只是一個形式，其本身並不需要這種主方法。但是少了這個主方法又是萬萬不行的。在這種情況下，就可以將主方法寫入到靜態內部類中，從而不用為每個Java源文件都設置一個類似的主方法。

這對於代碼測試是非常有用的。在一些中大型的應用程序開發中，則是一個常用的技術手段。

(2)java內部類作用擴展閱讀

例如：

對於兩個類，擁有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此時有一個robot類：

class Robot extends People implement Machine.

此時run()不可直接實現。

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");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

Ⅲ java裡面的內部類和外部類是什麼_

外部類：
最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類
內部類：
內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下：
1、內部原理的區別：
靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別：
創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()
通常來說，我們一般都會為了方便，會選擇使用靜態內部類。

Ⅳ 誰能解釋一下Java中內部類的作用啊.....謝謝了哦......

去看看JAVA中的那幾種內部類吧，不同的內部類有著不同的用處。不能問JAVA的類是用來幹嘛的，只能說在何種情況下回用到內不同。這個其實跟程序的設計有關。比方說Map.Entity，這個Entity就是MAP中的一個靜態內部類，它就是屬於Map的幾個子集。當然也可以將Entity拿出來單獨作為一個類。寫了內部類就不用新寫一個源文件。而對於匿名內部類，通常用於在面向介面編程時的一種回調

Ⅳ JAVA里為什麼使用內部類

JAVA內部類
內部類，內部類可以讓程序員更清楚的了解類的方法，類的結構。
舉例，Servlet
是繼承了
HttpServlet
那麼
Servlet這個類中的方法是怎麼來的？
在
Eclipse
中可以按
Ctrl+1
鍵
看內部代碼
Servlet中的方法是怎麼實現的
簡單的說這么多吧

Ⅵ 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 語言中使用內部類有什麼好處

一個類，要實現兩個介面，分別是介面A和介面B，介面A和介面B都有一個名字一樣的方法f（）；
此時就可以使用內部類實現介面B，外部類實現介面A。寫程序的時候內部類使用還是比較少的，這里只是舉個例子而已.內部類的用法還有很多，一般來說，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建它的外圍類的對象。所以可以認為內部類提供了某種進入其外圍類的窗口！

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

匿名內部類，看起來非常奇怪。因為它太簡潔了，但這也帶來一個好處，用匿名內部類寫出來的代碼通常比較簡潔啦！