❶ java 靜態內部類的使用
Java語言允許在類中再定義類，這種在其它類內部定義的類就叫內部類。內部類又分為：常規內部類、局部內部類、匿名內部類和靜態嵌套類四種。
1、靜態內部類定義
靜態內部類，定義在類中，任何方法外，用static定義；靜態內部類只能訪問外部類的靜態成員。
生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：Outer.Inner in=new Outer.Inner()；而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。可以定義私有靜態內部類。
2、java實現靜態內部類注意事項
將某個內部類定義為靜態類，跟將其他類定義為靜態類的方法基本相同，引用規則也基本一致。不過其細節方面仍然有很大的不同。具體來說，主要有如下幾個地方要引起注意。
1）一般情況下，如果一個內部類不是被定義成靜態內部類，那麼在定義成員變數或者成員方法的時候，是不能夠被定義成靜態成員變數與靜態成員方法的。也就是說，在非靜態內部類中不可以聲明靜態成員
2）一般非靜態外部類可以隨意訪問其外部類的成員變數以及方法（包括聲明為private的方法），但是如果一個內部類被聲明為static，則其在訪問包括自身的外部類會有諸多的限制。靜態內部類不能訪問其外部類的非靜態成員變數和方法
3）在一個類中創建非靜態成員內部類的時候，有一個強制性的規定，即內部類的實例一定要綁定在外部類的實例中。然後要在一個外部類中定義一個靜態的內部類，不需要利用關鍵字new來創建內部類的實例。即在創建靜態類內部對象時，不需要其外部類的對象
3、靜態內部類示例
java在實現LinkedList時使用了如下內部類：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
........
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
........
}
這里即靜態內部類的典型用法
❷ java中static的作用
static標示變數為靜態變數，每個對象共享一個靜態變數
單例模式是一種設計模式，只允許一個類的實例存在，可以用靜態方法來實現單例模式，可以參考網路啊。。
❸ java中的靜態內部類有什麼特點
特點：
1、靜態內部類無需依賴於外部類，它可以獨立於外部對象而存在。
2、靜態內部類，多個外部類的對象可以共享同一個內部類的對象。
3、使用靜態內部類的好處是加強了代碼的封裝性以及提高了代碼的可讀性。
4、普通內部類不能聲明static的方法和變數，注意這里說的是變數，常量（也就是final static修飾的屬性）還是可以的，而靜態內部類形似外部類，沒有任何限制。
有問題歡迎提問，滿意請採納，謝謝！
❹ Java內部類的修飾符有哪些
一、內部類可以為四種：
⒈ 靜態內部類
⒉ 成員內部類
⒊ 局部內部類
⒋
匿名內部類幾種內部類的共性：
A、內部類仍然是一個獨立的類，在編譯之後會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類命和$符號。
B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。
1、靜態嵌套類：從技術上講，靜態嵌套類不屬於內部類。因為內部類與外部類共享一種特殊關系，更確切地說是對實例的共享關系。而靜態嵌套類則沒有上述關系。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它。靜態嵌套類不能訪問外部類的成員和方法。 class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }
2、成員內部類：形式如下
class Outer { class Inner{} }
編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。成員內部類內不允許有任何靜態聲明！下面代碼不能通過編譯。
class Inner{ static int a = 10;
}能夠訪問成員內部類的唯一途徑就是通過外部類的對象！
A、從外部類的非靜態方法中實例化內部類對象。 class Outer { private
int i = 10; public void makeInner(){ Inner in = new Inner();
in.seeOuter(); } class Inner{ public void seeOuter(){
System.out.print(i); } }
}表面上，我們並沒有創建外部類的對象就實例化了內部類對象，和上面的話矛盾。事實上，如果不創建外部類對象也就不可能調用makeInner()方法，所以到頭來還是要創建外部類對象的。可能試圖把makeInner()方法修飾為靜態方法，即static
public void
makeInner()。這樣不創建外部類就可以實例化外部類了！但是在一個靜態方法里能訪問非靜態成員和方法嗎？顯然不能。它沒有this引用。沒能跳出那條規則！但是如果在這個靜態方法中實例化一個外部類對象，再用這個對象實例化外部類完全可以！也就是下一條的內容。
B、從外部類的靜態方法中實例化內部類對象。
class Outer { private int i = 10; class Inner{ public void seeOuter(){
System.out.print(i);
} } public static void main(String[] args) { Outer out = new Outer();
Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new
Inner(); in.seeOuter(); }
}被注釋掉的那行是它上面兩行的合並形式，一條簡潔的語句。對比一下：在外部類的非靜態方法中實例化內部類對象是普通的new方式：Inner in =
new Inner();在外部類的靜態方法中實例化內部類對象，必須先創建外部類對象：Outer.Inner
in = new Outer().new
Inner();
C、內部類的this引用。普通的類可以用this引用當前的對象，內部類也是如此。但是假若內部類想引用外部類當前的對象呢？用「外部類名」.this；的形式,如下例的Outer.this。
class Outer { class Inner{ public void seeOuter(){
System.out.println(this); System.out.println(Outer.this); } }
}
D、成員內部類的修飾符。對於普通的類，可用的修飾符有final、abstract、strictfp、public和默認的包訪問。但是成員內部類更像一個成員變數和方法。可用的修飾符有：final、abstract、public、private、protected、strictfp和static。一旦用static修飾內部類，它就變成靜態內部類了。
3、方法內部類：顧名思義，把類放在方法內。
class Outer { public void doSomething(){ class Inner{ public void
seeOuter(){ } } }
}
A、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。
B、方法內部類對象不能使用該內部類所在方法的非final局部變數。因為方法的局部變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變數成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變數內。正因為不能保證局部變數的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。下面是完整的例子：
class Outer { public void doSomething(){ final int a =10; class Inner{
public void seeOuter(){ System.out.println(a); } } Inner in = new
Inner(); in.seeOuter(); } public static void main(String[] args) { Outer
out = new Outer(); out.doSomething(); }
}
C、方法內部類的修飾符。與成員內部類不同，方法內部類更像一個局部變數。可以用於修飾方法內部類的只有final和abstract。
D、靜態方法內的方法內部類。靜態方法是沒有this引用的，因此在靜態方法內的內部類遭受同樣的待遇，即：只能訪問外部類的靜態成員。
4、匿名內部類：顧名思義，沒有名字的內部類。表面上看起來似乎有名字，實際那不是名字。
A、繼承式的匿名內部類。
class Car { public void drive(){ System.out.println("Driving a car!"); }
} class Test{ public static void main(String[] args) { Car car = new
Car(){ public void drive(){ System.out.println("Driving another car!"); }
}; car.drive(); } }結果輸出了：Driving another
car!
Car引用變數不是引用Car對象，而是Car匿名子類的對象。建立匿名內部類的關鍵點是重寫父類的一個或多個方法。再強調一下，是重寫父類的方法，而不是創建新的方法。因為用父類的引用不可能調用父類本身沒有的方法！創建新的方法是多餘的。簡言之，參考多態。B、介面式的匿名內部類。
interface Vehicle { public void drive(); } class Test{ public static
void main(String[] args) { Vehicle v = new Vehicle(){
public void drive(){ System.out.println("Driving a car!"); } };
v.drive(); }
}上面的代碼很怪，好像是在實例化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面。
C、參數式的匿名內部類。class
Bar{ void doStuff(Foo f){}}interface Foo{ void foo();}class Test{
static void go(){ Bar b = new Bar();
b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); }
});
}}
二、許可權修飾符：public、protected、default、private。
修飾符：abstract、static、final。
public 使用對象：最廣，類、介面、變數、方法。
protected使用對象：變數、方法 注意：不能修飾類（外部類）。
default 使用對象：類、介面、變數、方法。（即預設，什麼也不寫）。
private 使用對象：變數、方法 注意：不能修飾類（外部類）。
abstract使用對象：類、介面、方法。
static 使用對象：類、變數、方法、初始化函數（注意：修飾類時只能修飾 內部類 ）。
final 使用對象：類、變數、方法。
transient：告訴編譯器，在類對象序列化的時候，此變數不需要持久保存
volatile：指出可能有多個線程修改此變數，要求編譯器優化以保證對此變數的修改能夠被正確的處理。
native：用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。
synchronized：修飾方法，多線程的支持。
❺ 一個java內部類有幾個分類
共枝裂手有四種內部類，源孫分別是:
1.常規內部類
2.靜態內部類
3.局部內部類
4.匿名內部類
❻ 深入淺析Java中Static Class及靜態內部類和非靜態內部類的不同
。在java中我們可以有靜態實例變數、靜態方法、靜態塊。類也可以是靜態的。
java允許我們在一個類裡面定義靜態類。比如內部類（nested class）。把nested class封閉起來的類叫外部類。在java中，我們不能用static修飾頂級類（top level class）。只有內部類可以為static。
靜態內部類和非靜態內部類之間到底有什麼不同呢？下面是兩者間主要的不同。
（1）內部靜態類不需要有指向外部類的引用。但非靜態內部類需要持有對外部類的引用。
（2）非靜態內部類能夠訪問外部類的靜態和非靜態成員。靜態類不能訪問外部類的非靜態成員。他只能訪問外部類的靜態成員。
（3）一個非靜態內部類不能脫離外部類實體被創建，一個非靜態內部類可以訪問外部類的數據和方法，因為他就在外部類裡面。
❼ java中的靜態內部類的特點是什麼
需要了解2個概念：內部類和靜態修飾符static1）首先，用內部類是因為內部類與所在外部類有一定的關系，往往只有謹核該外部類調用此內部類。所以沒有必要專門用一個Java文晌鎮件存放這個類。2）靜態都是用來修飾類的內部成員的。比如靜態方法，靜態成員變數，靜態常量。
它唯一的作用就是隨著類的載入（而不是隨著對象的產生）而產生，以致可以用類名+靜態成員名直接獲得。這樣靜態內部類就宴晌粗可以理解了，因為這個類沒有必要單獨存放一個文件，它一般來說只被所在外部類使用。
並且它可以直接被用 外部類名+內部類名 獲得。以下舉例說明怎麼使用：Student類有個叫School的內部類（非靜態）Student stu = new Student();stu.School sch = new stu.School();sch就是School的一個對象。假如School是內部靜態類：Student.School sch = new Student.School()。
❽ java中靜態內部類和內部類的區別
1. 嵌套類的對象，並不需要其外圍類的對象。 即它可以不依賴於外部類實例被實例化。
2. 不能從嵌套類的對象中訪問非靜態的外圍類對象。 這是由Java語法中"靜態方法不能直接訪問非靜態成員"所限定
3. 外部類訪問內部類的的成員有些特別, 不能直接訪問, 但可以通過內部類實例來訪問, 這是因為靜態嵌套內的所有成員和方法默認為靜態的了.同時注意, 內部靜態類Person只在類StaticTest 范圍內可見, 若在其它類中引用或初始化, 均是錯誤的.
4 . 靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。
5. 靜態內部類的非靜態成員可以訪問外部類的靜態變數，而不可訪問外部類的非靜態變數；
6 . 非靜態內部類的非靜態成員可以訪問外部類的非靜態變數。
生成一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類(正常情況下，你不能在介面內部放置任何代碼，但嵌套類可以作為介面的一部分，因為它是static 的。只是將嵌套類置於介面的命名空間內，這並不違反介面的規則）
❾ 為什麼JAVA中內部類前面要加static
Java中可以有靜態內部類也可沒有。靜態內部類是是要加static的。
外部類可以直回接 用 . 來調用靜答態內部類 方法和屬性，這樣會非常方便和便捷。
但是靜態內部類，可指向不了外部的，所以你訪問不了外部的屬性和方法。