前兩天看到一道面試題，是關於內部類的知識，覺得很有意思。
這道題是這樣的：
根據註釋填寫(1)，(2)，(3)處的代碼
public class Test{
public static void main(String[] args){
// 初始化Bean1
(1)
bean1.I++;
// 初始化Bean2
(2)
bean2.J++;
//初始化Bean3
(3)
bean3.k++;
}
class Bean1{
public int I = 0;
}
static class Bean2{
public int J = 0;
}
}
public class Bean{
public class Bean3{
public int k = 0;
}
}
這其實就是實例化內部類對象的題。
從上面的題可以看出，Bean1爲非靜態內部類，Bean2爲靜態內部類，而Bean3則不是在Test類內部了，而是在一個外部類Bean的內部(是不是很拗口)，呵呵。現通過new和反射來詳細講解其產生原理。
1.new
我們知道，內部類分爲兩種，一種是靜態內部類，一種是非靜態內部類。前者不用產生外部類的實例化對象即可產生內部類的實例化對象，後者必須先產生外部類的實例化對象，才能產生內部類的實例化對象。
實例化靜態內部類對象的模板是： 外部類類名.內部類類名 xxx = new 外部類類名.內部類類名()
實例化非靜態內部類對象的模板是：外部類類名.內部類類名 xxx = 外部類對象名.new 內部類類名()
1>>實例化非靜態內部類Bean1
java代碼 ：
Test test = new Test();
Test.Bean1 b1 = test.new Bean1();
b1.I++;
總共3行代碼，是不是很簡單呢。
2>>實例化靜態內部類Bean2
java代碼：
Test.Bean2 b2 = new Test.Bean2();
b2.j++;
3>>實例化非靜態內部類Bean3
Bean bean = new Bean();
Bean.Bean3 b3 = bean.new Bean3();
System.out.println(b3.k++);
總結：通過new方式產生內部類的實例化對象實現起來比較簡單，也很容易理解，如果要深層次瞭解其產生，請用下面講解的方式，反射。
2.反射
1>>反射產生非靜態內部類Bean1的實例化對象
java代碼：
try {
Class<?> cla2 = Class.forName("com.lovo.nio.Test$Bean1");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
解析：我們知道，內部類的class文件是以"外部類$內部類.class"的形式存在的，所以獲取Class對象的時候，必須使用forName("包名+外部類$內部類")的形式才能得到Class對象
得到Class對象cla2後，肯定有人會說用下面的方法得到Bean1的實例化對象：
Bean1 b6 = (Bean1)cla2.newInstance();
運行上述代碼，出現異常：InstantiationException，查看Java API文檔，下面引用其原話：
當應用程序試圖使用 Class 類中的 newInstance 方法創建一個類的實例，而指定的類對象無法被實例化時，拋出該異常。實例化失敗有很多原因，包括但不僅限於以下原因：
- 類對象表示一個抽象類、接口、數組類、基本類型、
void - 類沒有非 null 構造方法
在這裏的原因是：Bean1的構造方法不公開，意思就是說，他的構造方法不是public的，不能通過newInstance()方式產生他的實例化對象。
那麼我們是否可以查看其是什麼訪問修飾符的構造方法呢？答案是可以的，可以通過以下方式得到：
Constructor<?>[] c = cla2.getDeclaredConstructors();
int i = c[0].getModifiers();
//得到訪問修飾符
String str = Modifier.toString(i);
System.out.println(str+" aaaaaaaaa"); //注意：此處的aaaaaaaaaaa僅表示有這個輸出
運行以上代碼，輸出“ aaaaaaaaa”,可以看出並沒有輸出str，實際上已經輸出了，就是default，default在Java中可以省略不寫的。現在該明白了吧！~
那要如何才能實例化他的內部類對象呢，剛纔我們說過，要實例化非靜態的內部類對象，必須先實例化外部類的對象，可是我們任然沒有實例化外部類的對象。我們查看JAVA PAI文檔，發現Constructor類有一個方法，newInstance(Object... initargs)，於是我們想到下面這種方式來構建：
//反射產生非靜態內部類Bean1的實例化對象
try {
Class<?> cla2 = Class.forName("com.lovo.nio.Test$Bean1");
// Bean1 b6 = (Bean1)cla2.newInstance();
// System.out.println(b6);
Constructor<?>[] c = cla2.getDeclaredConstructors();
int i = c[0].getModifiers();
//得到訪問修飾符
String str = Modifier.toString(i);
System.out.println(str+" aaaaaaaaa");
Bean1 bean1 = (Bean1)c[0].newInstance(new Test());
System.out.println(bean1.I++);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
運行以上代碼，正常。
2>>反射產生靜態內部類Bean2的實例化對象
Java代碼：
//反射產生靜態內部類Bean2的實例化對象
try {
// 初始化Bean2
Class<?> cla = null;
cla = Class.forName("com.lovo.nio.Test$Bean2");
Bean2 bean2 = (Bean2)cla.newInstance();
System.out.println(bean2.j++);
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
解析：
首先來看看static的相關知識：
static內部類意味着：
(1) 爲創建一個static內部類的對象，我們不需要一個外部類對象。
(2) 不能從static內部類的一個對象中訪問一個外部類對象.
倘若爲了創建內部類的對象而不需要創建外部類的一個對象，那麼可將所有東西都設爲static。爲了能正常工作，同時也必須將內部類設爲static。
此外,也可考慮用一個static內部類容納自己的測試代碼。
在這裏我們同樣可以使用上面的方法獲取他的構造方法的修飾符，也是default的，(靜態內部類是有構造方法的，而且是無參的構造方法).
java代碼：
try {
// 初始化Bean2
Class<?> cla = null;
cla = Class.forName("com.lovo.nio.Test$Bean2");
Bean2 bean2 = (Bean2)cla.newInstance();
Constructor<?>[] cs = cla.getDeclaredConstructors();
// Modifier.toString(cs[0]);
System.out.println("******************");
System.err.println(cs.length);
System.out.println(cs[0].getModifiers());
System.out.println("******************");
System.out.println(bean2.j++);
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
運行以上代碼，紅色部分代碼輸出：
******************
1
******************
可以看出，有一個默認的(方法修飾符沒寫的，不是沒有方法修飾符)構造方法。
如果我們要使用反射產生Bean2的實例化對象的話，只能用getDeclaredConstructors()方法。如上面的代碼所示。
3>>反射產生 外部類的內部類Bean3 的實例化對象
分析：要產生外部類的內部類的實例化對象，則要先產生外部類的實例化對象。再通過getClass()方法得到外部類的實例化對象的Class對象，再通過getClasses()方法得到外部類的所有公共類和接口，包括內部類。
Java代碼：
try {
Class<?> c3 = bean.getClass();
Class<?>[] cl = c3.getClasses();
// Bean3 b4 = (Bean3)c3.newInstance();
// System.out.println(b4);
//使用反射產生Bean3實例化對象
Constructor<?>[] cc = cl[0].getDeclaredConstructors();
//獲取構造方法的個數,用以判定其構造方法是否是公共的,如果直接通過c3.newInstance()方法來實例化Bean3的話，則會包異常:java.lang.ClassCastException
System.out.println(cc.length);
Bean3 bb = (Bean3)cc[0].newInstance(new Bean());
System.out.println(bb.k++);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
最後關於反射的一點點總結：
1.Java的反射是Java類的“自審”，可以通過反射探知類的結構，比如，獲得類的屬性，方法，修飾符，返回類型。是在程序運行時動態的生成的，那麼有人會問，既然可以的到類的屬性，方法等，那麼是否可以增加或者刪除它的屬性或者方法呢?答案是否定的，因爲Java是靜態語言，不是動態語言，那麼就不能修改類的屬性，方法，只能探知類的屬性，方法等。
2.既然可以通過反射得到類的屬性及其父類的屬性，方法等以及實現的接口的相關內容，那麼是否可以通過接口得到他的實現類的屬性，方法呢？答案是否定的，因爲在子類中有個關鍵字implements，是通過他得到類所實現的接口，但是如果要通過接口得到子類的相關內容，是行不通的，因爲在接口中沒有任何與實現類相關聯的代碼(比如關鍵字)。
不知道小弟所說是否正確，請大家指正，謝謝！