java修飾類

A. 在java中能用private修飾類嗎

一般的類是不能用private修飾，類的可見性最少是包可見的，也就是默認的，不加任何修飾。
但是有一種特殊的情況，內部類是可以用private修飾的！不讓類以外的其他類訪問！這個問題在《java核心技術》里有講！

Java的外部類為什麼不能使用private、protected進行修飾？

對於頂級類(外部類)來說，只有兩種修飾符：public和默認(default)。因為外部類的上一單元是包，所以外部類只有兩個作用域：同包，任何位置。

因此，只需要兩種控制許可權：包控制許可權和公開訪問許可權，也就對應兩種控制修飾符：public和默認(default)。

如果類使用了private修飾符，說明是個內部類。內部類的上一級是外部類，那麼對應的有四種訪問控制修飾符：本類(private)，同包(default)，父子類(protected)，任何位置(public)。

當一個內部類使用了private修飾後，只能在該類的外部類內部使用。可以想一下，一個java項目是不可能在一個class裡面完成的。

mvc模式中，是把類分為三層，一層層調用類。如果定義為私有的和受保護的就無法調用。換句話說，對於一個java文件，要麼就是自己單獨運行，要麼就是被其他程序作為庫調用。

如果一個java文件的類被private修飾，那麼是不是其他的程序或是類是無法使用它的，那麼他作為一個單獨的文件就沒啥用了。

如果它作為單個文件運行，類載入怎麼找到它呢，因為它對外不可見。同時，也失去了類的存在意義。因此，類只有public和默認修飾符。

B. 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：修飾方法，多線程的支持。

C. Java中的public修飾類有什麼意義

public修飾類允許其他類可以訪問這個函數。

D. Java中final修飾的類有什麼作用

Java中，final關鍵字可以用來修飾類、方法和變數（包括成員變數和局部變數）。下面就從這三個方面來了解一下final關鍵字的基本用法。x0dx0a1.修飾類x0dx0a當用final修飾一個類時，表明這個類不能被繼承。也就是說，如果一個類你永遠不會讓他被繼承，就可以用final進行修飾。final類中的成員變數可以根據需要設為final，但是要注意final類中的所有成員方法都會被隱式地指定為final方法。x0dx0ax0dx0a在使用final修飾類的時候，要注意謹慎選擇，除非這個類真的在以後不會用來繼承或者出於安全的考慮，盡量不要將類設計為final類。x0dx0a2.修飾方法x0dx0a下面這段話摘自《Java編程思想》第四版第143頁：x0dx0a「使用final方法的原因有兩個。第一個原因是把方法鎖定，以防任何繼承類修改它的含義；第二個原因是效率。在早期的Java實現版本中，會將final方法轉為內嵌調用。但是如果方法過於龐大，可能看不到內嵌調用帶來的任何性能提升。在最近的Java版本中，不需要使用final方法進行這些優化了。「x0dx0a因此，如果只有在想明確禁止 該方法在子類中被覆蓋的情況下才將方法設置為final的。x0dx0a註：類的private方法會隱式地被指定為final方法。x0dx0a3.修飾變數x0dx0a修飾變數是final用得最多的地方，也是本文接下來要重點闡述的內容。首先了解一下final變數的基本語法：x0dx0a對於一個final變數，如果是基本數據類型的變數，則其數值一旦在初始化之後便不能更改；如果是引用類型的變數，則在對其初始化之後便不能再讓其指向另一個對象。

E. 在Java中，final修飾的類有什麼特點

1、final修飾的類不能被復繼承。

2、Sting就是一制個被final修飾的類，我們只能用，不用繼承。

3、final不僅可以修飾類，還可以修飾變數，被final修飾的變數就是一個常量，只能賦值一次。

4、注意final和finally的區別，final是修飾類或者變數，finally是在異常處理中使用，如：

try{ }catch（）{}finally{}中，finally的作用一般用於必須處理的事情，如關閉連接。