什麼叫做代碼塊(Code Block)？用大括號把多行代碼封裝在一起，形成一個獨立的數據體，實現特定算法的代碼集合即為代碼塊，一般來說代碼快不能單獨運行的，必須要有運行主體。在Java中一共有四種類型的代碼塊：
我麼知道一個類中至少有一個構造函數(如果沒有，編譯器會無私的為其創建一個無參構造函數)，構造函數是在對象生成時調用的，那現在為你來了：構造函數和代碼塊是什麼關系，構造代碼塊是在什麼時候執行的？在回答這個問題之前，我們先看看編譯器是如何處理構造代碼塊的，看如下代碼：
1 public class Client36 {
2
3 {
4 // 構造代碼塊
5 System.out.println("執行構造代碼塊");
6 }
7
8 public Client36() {
9 System.out.println("執行無參構造");
10 }
11
12 public Client36(String name) {
13 System.out.println("執行有參構造");
14 }15 }
這是一段非常簡單的代碼，它包含了構造代碼塊、無參構造、有參構造，我們知道代碼塊不具有獨立執行能力，那麼編譯器是如何處理構造代碼塊的呢？很簡單，編譯器會把構造代碼塊插入到每個構造函數的最前端，上面的代碼等價於：
1 public class Client36 {
2
3 public Client36() {
4 System.out.println("執行構造代碼塊");
5 System.out.println("執行無參構造");
6 }
7
8 public Client36(String name) {
9 System.out.println("執行構造代碼塊");
10 System.out.println("執行有參構造");
11 }
12 }
每個構造函數的最前端都被插入了構造代碼塊，很顯然，在通過new關鍵字生成一個實例時會先執行構造代碼塊，然後再執行其他代碼，也就是說：構造代碼塊會在每個構造函數內首先執行（需要注意的是：構造代碼塊不是在構造函數之前運行的，它依托於構造函數的執行），明白了這一點，我們就可以把構造代碼塊應用到如下場景中：
以上兩個場景利用了構造代碼塊的兩個特性：在每個構造函數中都運行和在構造函數中它會首先運行。很好的利用構造代碼塊的這連個特性不僅可以減少代碼量，還可以讓程序更容易閱讀，特別是當所有的構造函數都要實現邏輯，而且這部分邏輯有很復雜時，這時就可以通過編寫多個構造代碼塊來實現。每個代碼塊完成不同的業務邏輯（當然了構造函數盡量簡單，這是基本原則），按照業務順序一次存放，這樣在創建實例對象時JVM就會按照順序依次執行，實現復雜對象的模塊化創建。
上一建議中我們提議使用構造代碼塊來簡化代碼，並且也了解到編譯器會自動把構造代碼塊插入到各個構造函數中，那我們接下來看看，編譯器是不是足夠聰明，能為我們解決真實的開發問題，有這樣一個案例，統計一個類的實例變量數。你可要說了，這很簡單，在每個構造函數中加入一個對象計數器補救解決了嘛？或者我們使用上一建議介紹的，使用構造代碼塊也可以，確實如此，我們來看如下代碼是否可行：
1 public class Client37 {
2 public static void main(String[] args) {
3 new Student();
4 new Student("張三");
5 new Student(10);
6 System.out.println("實例對象數量："+Student.getNumOfObjects());
7 }
8 }
9
10 class Student {
11 // 對象計數器
12 private static int numOfObjects = 0;
13
14 {
15 // 構造代碼塊，計算產生的對象數量
16 numOfObjects++;
17 }
18
19 public Student() {
20
21 }
22
23 // 有參構造調用無參構造
24 public Student(String stuName) {
25 this();
26 }
27
28 // 有參構造不調用無參構造
29 public Student(int stuAge) {
30
31 }
32 //返回在一個JVM中，創建了多少實例對象
33 public static int getNumOfObjects(){
34 return numOfObjects;
35 }
36 }
這段代碼可行嗎？能計算出實例對象的數量嗎？如果編譯器把構造代碼塊插入到各個構造函數中，那帶有String形參的構造函數就可能有問題，它會調用無參構造，那通過它生成的Student對象就會執行兩次構造代碼塊：一次是無參構造函數調用構造代碼塊，一次是執行自身的構造代碼塊，這樣的話計算就不准確了，main函數實際在內存中產生了3個對象，但結果確是4。不過真的是這樣嗎？我們運行之後，結果是：
實例對象數量：3；
實例對象的數量還是3，程序沒有問題，奇怪嗎？不奇怪，上一建議是說編譯器會把構造代碼塊插入到每一個構造函數中，但是有一個例外的情況沒有說明：如果遇到this關鍵字(也就是構造函數調用自身的其它構造函數時)，則不插入構造代碼塊，對於我們的例子來說，編譯器在編譯時發現String形參的構造函數調用了無參構造，於是放棄插入構造代碼塊，所以只執行了一次構造代碼塊。
那Java編譯器為何如此聰明？這還要從構造代碼塊的誕生說起，構造代碼塊是為了提取構造函數的共同量，減少各個構造函數的代碼產生的，因此，Java就很聰明的認為把代碼插入到this方法的構造函數中即可，而調用其它的構造函數則不插入，確保每個構造函數只執行一次構造代碼塊。
還有一點需要說明，大家千萬不要以為this是特殊情況，那super也會類似處理了，其實不會，在構造塊的處理上，super方法沒有任何特殊的地方，編譯器只把構造代碼塊插入到super方法之後執行而已。僅此不同。
注意：放心的使用構造代碼塊吧，Java已經想你所想了。
Java中的嵌套類(Nested Class)分為兩種：靜態內部類(也叫靜態嵌套類，Static Nested Class)和內部類(Inner Class)。本次主要看看靜態內部類。什麼是靜態內部類呢？是內部類，並且是靜態(static修飾)的即為靜態內部類，只有在是靜態內部類的情況下才能把static修飾符放在類前，其它任何時候static都是不能修飾類的。
靜態內部類的形式很好理解，但是為什麼需要靜態內部類呢？那是因為靜態內部類有兩個優點：加強了類的封裝和提高了代碼的可讀性，我們通過下面代碼來解釋這兩個優點。
1 public class Person {
2 // 姓名
3 private String name;
4 // 家庭
5 private Home home;
6
7 public Person(String _name) {
8 name = _name;
9 }
10
11 /* home、name的setter和getter方法略 */
12
13 public static class Home {
14 // 家庭地址
15 private String address;
16 // 家庭電話
17 private String tel;
18
19 public Home(String _address, String _tel) {
20 address = _address;
21 tel = _tel;
22 }
23 /* address、tel的setter和getter方法略 */
24 }
25 }
其中，Person類中定義了一個靜態內部類Home,它表示的意思是"人的家庭信息"，由於Home類封裝了家庭信息，不用再Person中再定義homeAddr,homeTel等屬性，這就使封裝性提高了。同時我們僅僅通過代碼就可以分析出Person和Home之間的強關聯關系，也就是說語義增強了，可讀性提高了。所以在使用時就會非常清楚它表達的含義。
public static void main(String[] args) {
// 定義張三這個人
Person p = new Person("張三");
// 設置張三的家庭信息
p.setHome(new Home("北京", "010"));
}
定義張三這個人，然後通過Person.Home類設置張三的家庭信息，這是不是就和我們真是世界的情形相同了？先登記人的主要信息，然後登記人員的分類信息。可能你由要問了，這和我們一般定義的類有神麼區別呢？又有什麼吸引人的地方呢？如下所示：
解釋了這麼多，大家可能會覺得外部類和靜態內部類之間是組合關系(Composition)了，這是錯誤的，外部類和靜態內部類之間有強關聯關系，這僅僅表現在"字面上"，而深層次的抽象意義則依類的設計.
那靜態類內部類和普通內部類有什麼區別呢？下面就來說明一下：
閱讀如下代碼，看上是否可以編譯：
public static void main(String[] args) {
List list1=new ArrayList();
List list2=new ArrayList(){};
List list3=new ArrayList(){{}};
System.out.println(list1.getClass() == list2.getClass());
System.out.println(list2.getClass() == list3.getClass());
System.out.println(list1.getClass() == list3.getClass());
}
注意ArrayList後面的不通點：list1變量後面什麼都沒有，list2後面有一對{},list3後面有兩個嵌套的{},這段程序能否編譯呢？若能編譯，那輸結果是什麼呢？
答案是能編譯，輸出的是3個false。list1很容易理解，就是生命了ArrayList的實例對象，那list2和list3代表的是什麼呢？
(1)、list2 = new ArrayList(){}：list2代表的是一個匿名類的聲明和賦值，它定義了一個繼承於ArrayList的匿名類，只是沒有任何覆寫的方法而已，其代碼類似於：
// 定義一個繼承ArrayList的內部類
class Sub extends ArrayList {
}
// 聲明和賦值
List list2 = new Sub();
(2)、list3 = new ArrayList(){{}}：這個語句就有點奇怪了，帶了兩對{}，我們分開解釋就明白了，這也是一個匿名類的定義，它的代碼類似於：
// 定義一個繼承ArrayList的內部類
class Sub extends ArrayList {
{
//初始化代碼塊
}
}
// 聲明和賦值
List list3 = new Sub();
看到了吧，就是多了一個初始化塊而已，起到構造函數的功能，我們知道一個類肯定有一個構造函數，而且構造函數的名稱和類名相同，那問題來了：匿名類的構造函數是什麼呢？它沒有名字呀！很顯然，初始化塊就是它的構造函數。當然，一個類中的構造函數塊可以是多個，也就是說會出現如下代碼：
List list4 = new ArrayList(){{} {} {} {} {}};
上面的代碼是正確無誤，沒有任何問題的，現在清楚了，匿名類雖然沒有名字，但也是可以有構造函數的，它用構造函數塊來代替構造函數，那上面的3個輸出就很明顯了：雖然父類相同，但是類還是不同的。
在上一建議中我們講到匿名類雖然沒有名字，但可以有一個初始化塊來充當構造函數，那這個構造函數是否就和普通的構造函數完全不一樣呢？我們來看一個例子，設計一個計算器，進行加減運算，代碼如下：
1 public class Calculator {
2 enum Ops {
3 ADD, SUB
4 };
5
6 private int i, j, result;
7
8 // 無參構造
9 public Calculator() {
10
11 }
12
13 // 有參構造
14 public Calculator(int _i, int _j) {
15 i = _i;
16 j = _j;
17 }
18
19 // 設置符號，是加法運算還是減法運算
20 protected void setOperator(Ops _ops) {
21 result = _ops.equals(Ops.ADD) ? i + j : i - j;
22 }
23
24 // 取得運算結果
25 public int getResult() {
26 return result;
27 }
28
29 }
代碼的意圖是，通過構造函數傳遞兩個int類型的數字，然後根據設置的操作符(加法還是減法)進行運算，編寫一個客戶端調用：
public static void main(String[] args) {
Calculator c1 = new Calculator(1, 2) {
{
setOperator(Ops.ADD);
}
};
System.out.println(c1.getResult());
}
這段匿名類的代碼非常清晰：接收兩個參數1和2，然後設置一個操作符號，計算其值，結果是3，這毫無疑問，但是這中間隱藏著一個問題：帶有參數的匿名類聲明時到底調用的是哪一個構造函數呢？我們把這段程序模擬一下：
//加法計算
class Add extends Calculator{
{
setOperator(Ops.ADD);
}
//覆寫父類的構造方法
public Add(int _i, int _j){
}
}
匿名類和這個Add類等價嗎？可能有人會說：上面只是把匿名類增加了一個名字，其它的都沒有改動，那肯定是等價了，毫無疑問 ，那好，編寫一個客戶端調用Add類的方法看看。代碼就略了，因為很簡單new Add，然後調用父類的getResult方法就可以了，經過測試，輸出結果為0（為什麼而是0？這很容易，有參構造沒有賦值）。這說明兩者不等價，不過，原因何在呢？
因為匿名類的構造函數特殊處理機制，一般類(也就是沒有顯示名字的類)的所有構造函數默認都是調用父類的無參構造函數的，而匿名類因為沒有名字，只能由構造代碼塊代替，也就無所謂有參和無參的構造函數了，它在初始化時直接調用了父類的同參數構造函數，然後再調用了自己的構造代碼塊，也就是說上面的匿名類和下面的代碼是等價的：
//加法計算
class Add extends Calculator{
{
setOperator(Ops.ADD);
}
//覆寫父類的構造方法
public Add(int _i, int _j){
super(_i,_j);
}
}
它會首先調用父類有兩個參數的構造函數，而不是無參構造，這是匿名類的構造函數與普通類的差別，但是這一點也確實鮮有人仔細琢磨，因為它的處理機制符合習慣呀，我傳遞兩個參數，就是希望先調用父類有兩個參數的構造，然後再執行我自己的構造函數，而Java的處理機制也正是如此處理的。
