|
正文 final
final域使得確保初始化安全性（initialization safety）成為可能，初始化安全性讓不可變形對象不需要同步就能自由地被訪問和共享
作用在類上 則為final類，final類不能被繼承。一般用于工具類時，同時把工具類構造函數(shù)聲明為私有，暴露靜態(tài)共有方法
作用在成員變量上 則視為常量。此時賦值方式有三種：（1）聲明時賦值（2）構造函數(shù)中賦值（3）代碼塊中賦值。 即不管哪種方式都要保證在使用該變量之前要確保已經(jīng)有值。使用該特性，可以強制賦值。final變量因為不可變，所以可以安全的存在于多線程中。
作用在方法上 作用在方法上可以保證該方法不能被重寫
作用在參數(shù)上 保證在方法體內部參數(shù)值不會被再次賦值，一般好的編程習慣應該把參數(shù)值視為final，不管有沒有顯示使用final(重構)
static
static關鍵字是隸屬于類而非對象。這也就意味著不管聲明了幾個對象，static關鍵字所修飾的空間只占用一份。改變了之后，所有的引用它的都會發(fā)生變化。靜態(tài)成員變量為所有類的對象共享。不像對象之間的變量是無影響的。所以對于static修飾的成員變量或者靜態(tài)代碼塊是在類加載的時候已經(jīng)裝載。這種特性可以做一些初始化的工作而且保證只初始化了一次。
作用在包上 （import static（注意這里不是static import） com…..ClassName.* 靜態(tài)導包）這種以后再使用包里面的靜態(tài)方法或者成員變量時會比較方便。eg：
import static java.lang.Integer.*;
int max_value = MAX_VALUE;
toHexString(max_value);
這樣就導入了Integer類下面所有的靜態(tài)方法和成員變量。在使用的時候就可以省去Integer，直接使用。
作用在類上 修飾類則為靜態(tài)類。只能作為靜態(tài)內部類，如果直接修飾類，則不能通過編譯。
作用在方法上 修飾方法則為靜態(tài)方法。靜態(tài)方法中不能使用非靜態(tài)變量。因為靜態(tài)方法中不能確定該方法是否有被初始化。但是非靜態(tài)方法可以引用靜態(tài)變量。
作用在變量上 作用在變量上則為靜態(tài)變量。靜態(tài)成員變量一般聲明為final的。因為隸屬于該類所有對象，可更改存在著危險。
代碼塊
代碼塊分為普通代碼塊和構造代碼塊
普通代碼塊：在方法或語句中出現(xiàn)的{}，用的比較少。執(zhí)行順序是按聲明順序執(zhí)行。eg:
1 public static void main(String[] args) {
2 {
3 System.out.println('普通代碼塊-先聲明');
4 }
5 System.out.println('函數(shù)普通');
6 {
7 System.out.println('普通代碼塊-后聲明');
8 }
9 }
程序輸出結果如下：
普通代碼塊-先聲明
函數(shù)普通
普通代碼塊-后聲明
構造代碼塊：直接在類中定義且沒有static關鍵字的代碼塊，比較常用。執(zhí)行順序是在構造函數(shù)執(zhí)行之前執(zhí)行，每聲明一個對象都會執(zhí)行一次。
1 public class CodeBlock {
2 {
3 System.out.println('構造代碼塊-先聲明-執(zhí)行');
4 }
5 public CodeBlock(){
6 System.out.println('構造器執(zhí)行');
7 }
8 {
9 System.out.println('構造代碼塊-后聲明-執(zhí)行');
10 }
11 public void plainFunc(){
12 System.out.println('普通方法執(zhí)行');
13 }
14 public static void main(String[] args) {
15 System.out.println('main方法');
16 CodeBlock cb1 = new CodeBlock();
17 cb.plainFunc();
18 CodeBlock cb2 = new CodeBlock();
19 }
20 }
程序輸出結果如下：
main方法
構造代碼塊-先聲明-執(zhí)行
構造代碼塊-后聲明-執(zhí)行
構造器執(zhí)行
普通方法執(zhí)行
構造代碼塊-先聲明-執(zhí)行
構造代碼塊-后聲明-執(zhí)行
構造器執(zhí)行
結論：
執(zhí)行順序：main方法->構造代碼塊->構造函數(shù)->普通方法
每實例化一個對象，則執(zhí)行一次構造代碼塊
靜態(tài)代碼塊
在java中使用static關鍵字聲明的代碼塊。靜態(tài)塊用于初始化類，為類的屬性初始化。每個靜態(tài)代碼塊只會執(zhí)行一次。由于JVM在加載類時會執(zhí)行靜態(tài)代碼塊，所以靜態(tài)代碼塊先于主方法執(zhí)行。
如果類中包含多個靜態(tài)代碼塊，那么將按照'先定義的代碼先執(zhí)行，后定義的代碼后執(zhí)行'。
注意：1 靜態(tài)代碼塊不能存在于任何方法體內。2 靜態(tài)代碼塊不能直接訪問靜態(tài)實例變量和實例方法，需要通過類的實例對象來訪問。
1 class Code{
2 {
3 System.out.println('Code的構造塊');
4 }
5
6 static{
7 System.out.println('Code的靜態(tài)代碼塊');
8 }
9
10 public Code(){
11 System.out.println('Code的構造方法');
12 }
13 }
14 public class CodeBlock{
15 {
16 System.out.println('CodeBlock的構造塊');
17 }
18
19 static{
20 System.out.println('CodeBlock的靜態(tài)代碼塊');
21 }
22
23 public CodeBlock03(){
24 System.out.println('CodeBlock的構造方法');
25 }
26
27 public static void main(String[] args){
28 System.out.println('CodeBlock的主方法');
29 new Code();
30 new Code();
31 new CodeBlock();
32 new CodeBlock();
33 }
34 }
CodeBlock的靜態(tài)代碼塊
CodeBlock的主方法 //這里還沒有加載Code，所以先執(zhí)行主方法，再執(zhí)行Code的靜態(tài)代碼塊
Code的靜態(tài)代碼塊
Code的構造塊
Code的構造方法
Code的構造塊
Code的構造方法
CodeBlock的構造塊
CodeBlock的構造方法
內部類
⒈成員內部類⒉靜態(tài)內部類⒊局部內部類⒋匿名內部類
定義
將一個類的定義放在另一個類的定義內部，這就是內部類
初見內部類
內部類的創(chuàng)建就和定義的一樣，把一個類定義在另一個類的內部（java語法規(guī)定一個類中只能有一個是public的，所以內部類不能用public修飾）
1 public class Parcel2 {
2 class Contents {
3 private int i = 11;
4 public int value() { return i; }
5 }
6 class Destination {
7 private String label;
8 Destination(String whereTo) {
9 label = whereTo;
10 }
11 String readLabel() { return label; }
12 }
13 public Destination to(String s) {
14 return new Destination(s);
15 }
16 public Contents contents() {
17 return new Contents();
18 }
19 public void ship(String dest) {
20 Contents c = contents();
21 Destination d = to(dest);
22 System.out.println(d.readLabel());
23 }
24 public static void main(String[] args) {
25 Parcel2 p = new Parcel2();
26 p.ship('Tasmania');
27 Parcel2 q = new Parcel2();
28 // Defining references to inner classes:
29 Parcel2.Contents c = q.contents();
30 Parcel2.Destination d = q.to('Borneo');
31 }
32 }
這里在類Parcel2中創(chuàng)建了兩個內部類Contents和Destination。同時每個內部類對應的創(chuàng)建了一個外部類方法，該方法用來返回一個指向內部類對象的引用。這種方式很常用！如果不提供指向內部類對象引用的函數(shù)，需要借助“.new”來創(chuàng)建內部類對象（后面會有用法）。如果想從外部類的非靜態(tài)方法之外的任意位置創(chuàng)建某個內部類對象，那么必須像上述main（）方法那樣，具體指明這個對象的類型：OutClassName.InnerClassName(eg:Parcel2.Contents),為什么要這么做呢？
注意：非靜態(tài)內部類對象有著指向外部類對象的引用。
這可以至少解釋兩個問題：
1、內部類擁有外部類的所有元素的訪問權（因為當生成內部類時內部類自動產生了指向外部類對象的引用，該引用可以訪問外部類的所有成員）
2、創(chuàng)建內部類對象時，需要指明對象類型，即：
OutClassName out = new OutClassName();
OutClassName.InnerClassName=out.new InnerClassName();
使用 .this 和 .new
如果需要生成對外部類對象的引用，可以使用外部類的名字后面緊跟原點和this。如果需要生成內部類對象，可以使用外部類對象后面緊跟原點和this。
外部類引用：
public class DotThis {
void f() { System.out.println('DotThis.f()'); }
public class Inner {
public DotThis outer() {
return DotThis.this;
// A plain 'this' would be Inner's 'this'
}
}
public Inner inner() { return new Inner(); }
public static void main(String[] args) {
DotThis dt = new DotThis();
DotThis.Inner dti = dt.inner();
dti.outer().f();
}
}
注意：上面代碼DotThis.this返回外部類對象引用，如果直接使用this,則是內部類Inner對象引用，不能通過編譯。
創(chuàng)建內部類對象：
public class DotNew {
public class Inner {}
public static void main(String[] args) {
DotNew dn = new DotNew();
DotNew.Inner dni = dn.new Inner();
}
}
內部類語法
一、成員內部類（非靜態(tài)）：
1、可以訪問外部類所有元素
2、創(chuàng)建對象兩種方式：（1）在外部類中聲明方法返回內部類對象的引用（2）通過內部類對象后跟原點和new的方式（eg:DotNew dn = new DotNew(); DotNew.Inner dni = dn.new Inner();）
3、成員內部類中不能包含靜態(tài)數(shù)據(jù)（成員變量和方法）
二、靜態(tài)內部類：
1、不能訪問外部類的非靜態(tài)元素和方法。（因為靜態(tài)內部類沒有指向外部類對象的引用，只能直接通過類名來調用）
2、創(chuàng)建方式比較簡單
Outer.Inner inner = new Outer.Inner();
inner.func();
三、局部內部類
局部內部類就是可以定義在方法體內，比較少用
四、匿名內部類
interface content{
int func();
}
System.out.println(new content(){
@Override
public int func() {
return 1;
}
}.func());
1、可以訪問外部類所有元素
2、隱藏性好，只有本類可操作
3、可以解決C 里面的多繼承問題。怎么解決？
我們知道，Java不支持多繼承（即一個類同時繼承兩個或多個類），只支持多重繼承（即A繼承B，B繼承C，那么A間接繼承了C），利用Java的內部類機制可以做到多重繼承的效果。可以聲明多個內部類分別繼承相應的類，然后對于外部類來說，就同時擁有了相應內部類的功能。
代碼執(zhí)行順序
1、父類靜態(tài)代碼塊->父類靜態(tài)成員變量初始化->子類靜態(tài)代碼塊->子類靜態(tài)成員變量初始化->（父類代碼塊->父類成員變量初始化）(這兩個誰先聲明誰在前面)->子類代碼塊->子類成員變量初始化->父類構造函數(shù)->子類構造函數(shù)->...
- 靜態(tài)先于非靜態(tài)執(zhí)行
- 代碼塊可以當做成員變量來看，對于靜態(tài)代碼塊，類加載的時候執(zhí)行；對于非靜態(tài)代碼塊，構造函數(shù)之前執(zhí)行，可以想成是在成員變量初始化的時候執(zhí)行
- 父類優(yōu)先于子類執(zhí)行（因為子類涉及到對父類的重寫等操作，只有父類初始完畢了，子類重寫和引用才有意義）
參考文章：
1、《java編程思想》
2、http://www.cnblogs.com/sophine/p/3531282.html
|
