getConstructor(String.class,int.class)中的引數是怎麼確定？為什麼就是String.class和int.class，引數型別為什麼又寫成(String.class,int.class)這種形式的呢？知道是通過getConstructor方法獲得Person類中的構造方法的，Person類中的構造方法是 Person（String name, int age）,假如現在不知道Person類中的有參構造方法中的引數有幾個呢？，Class是怎麼知道這個Person類中有參建構函式的引數個數的？

反射的本質就是將類中所有的類成分對映成對應的Class物件，這裡的Class物件其實可以看成一種型別。

Class 類的例項表示正在執行的 Java 應用程式中的類和介面。
基本的 Java 型別（boolean、byte、char、short、int、long、float 和 double）和關鍵字   void 也表示為 Class 物件。（形如int.class）
引數型別為什麼又寫成(String.class,int.class)這種形式的呢？？這個sun公司就是這麼定義的，你知道他表示什麼就行了，這是規則。
Constructor  getConstructor(Class<?>... parameterTypes) 
          返回一個 Constructor 物件，它反映此 Class 物件所表示的類的指定公共構造方法。
          Class<?>... parameterTypes指定建構函式的型別，當然如果你傳遞的是一個空參，那麼會呼叫預設建構函式。
如現在不知道Person類中的有參構造方法中的引數有幾個呢？，Class是怎麼知道這個Person類中有參建構函式的引數個數的？
第一：你可以這麼處理：
Constructor<?>  [] getConstructors() 
          返回一個包含某些 Constructor 物件的陣列，這些物件反映此 Class 物件所表示的類的所有公共構造方法 。Constructor<?>就表示你對應的構函不知道形參型別未知。
第二 ：遍歷Constructor，利用其提供的方法獲取對應構函的資訊
Type[]  getGenericParameterTypes() 
         按照宣告順序返回一組 Type 物件，這些物件表示此 Constructor 物件所表示的方法的形參型別。Type[]陣列自然會返回你的某個建構函式的引數個數
Class<?>[] getParameterTypes() 
          按照宣告順序返回一組 Class 物件，這些物件表示此 Constructor 物件所表示構造方法的形參型別。 

Constructor<?>[] constructors = clazz.getConstructor();
  for(Constructor<?>cons: constructors)
{
    Type[] types=cons.getGenericParameterTypes()
          System.out.println(cons.toString()+types.length);
}

public Constructor<?>[] getConstructors() throws SecurityException

返回一個包含某些 Constructor 物件的陣列，這些物件反映此 Class 物件所表示的類的所有公共構造方法。如果該類沒有公共構造方法，或者該類是一個數組類，或者該類反映一個基本型別或 void，則返回一個長度為 0 的陣列。 注意，此方法返回 Constructor<T> 物件的陣列（即取自此類構造方法的陣列）時，此方法的返回型別是 Constructor<?>[]，不是 預期的 Constructor<T>[]。此少量資訊的返回型別是必需的，因為從此方法返回之後，該陣列可能被修改以儲存不同類的 Constructor 物件，而這將違反 Constructor<T>[] 的型別保證。

這個方法，可以獲取到，所有的，公共的構造方法，打印出來，看看就知道有哪些了。

至於那個地方為什麼是？.class,  是因為反射機制的執行原理來決定的。反射就是通過解析這些Class檔案，知道里面有哪些類，哪些方法。

=================================================

public class EnumTest_6 {

	public static void main(String[] args) {
		System.out.println(TrafficLamp.RED);//當執行TrafficLamp.RED 時編譯器具體做了些什麼？
		System.out.println(TrafficLamp.GREEN);
		System.out.println(TrafficLamp.YELLOW);
	}

	public enum TrafficLamp {
	//如果TrafficLamp本身是一個類的話，那麼 RED，Green,YELLOW又是什麼呢，他們和TrafficLamp是什  麼關係呢？

		RED(30) {
			public TrafficLamp nextLamp() {
		// nextLamp()這個函式怎麼調運，他和 RED是怎麼一個關係
			return GREEN;
			}
		},

		GREEN(45) {
			public TrafficLamp nextLamp() {
			return YELLOW;
			}
		},

		YELLOW(5) {
			public TrafficLamp nextLamp() {
			return RED;
			}
		};
  
		public abstract TrafficLamp nextLamp();//這行程式碼有何作用，而且為何要定義成抽象的呢？而且註釋掉 ，沒有影響！

		private int time;
		private TrafficLamp(int time) {
			this.time = time;
		}
	}
}

1.當執行TrafficLamp.RED 時編譯器具體做了些什麼？
編譯器呼叫了TrafficLamp這個列舉的RED元素，並自動實現toString方法。
2.如果TrafficLamp本身是一個類的話，那麼 RED，Green,YELLOW又是什麼呢，他們和TrafficLamp是什麼關係呢？
（1）如果TrafficLamp中沒有抽象方法，那麼RED，Green,YELLOW就是TrafficLamp的例項物件。
（2）如果TrafficLamp中有抽象方法，那麼TrafficLamp不能直接例項化，只有實現了該抽象方法的子類才能例項化，此時RED，Green,YELLOW就是TrafficLamp子類的例項物件。他們和TrafficLamp就是類與物件的關係，抽象與具體的關係。
3. nextLamp()這個函式怎麼調運，他和 RED是怎麼一個關係。
燈之間的交替關係是聯絡實際，先確定下來。RED——>GREEN——>YELLOW——>RED這樣迴圈往復。然後通過程式來實現。這個問題，可是使用If——else語句來完成，但這樣很麻煩，就用抽象方法 public abstract TrafficLamp nextLamp();來代替，它將大量的if-else語句變成一個個獨立的類封裝到每個元素中，使結構清晰，易於理解。
4.  public abstract TrafficLamp nextLamp();這行程式碼有何作用，而且為何要定義成抽象的呢？，而且註釋掉 ，沒有影響！
作用：它將大量的if-else語句變成一個個獨立的類封裝到每個元素中，使結構清晰，易於理解。同時這也使用了多型技術，呼叫時只與基類介面通訊，提高程式的擴充套件性。

=================================================

常量池

常量池在java用於儲存在編譯期已確定的，已編譯的class檔案中的一份資料。它包括了關於類，方法，介面等中的常量，也包括字串常量，如String s = "java"這種申明方式；當然也可擴充，執行器產生的常量也會放入常量池，故認為常量池是JVM的一塊特殊的記憶體空間。

Java是一種動態連結的語言，常量池的作用非常重要，常量池中除了包含程式碼中所定義的各種基本型別（如int、long等等）和物件型（如String及陣列）的常量值外，還包含一些以文字形式出現的符號引用，比如：
　　類和介面的全限定名；
　　欄位的名稱和描述符；
　　方法和名稱和描述符。

在C語言中，如果一個程式要呼叫其它庫中的函式，在連結時，該函式在庫中的位置（即相對於庫檔案開頭的偏移量）會被寫在程式中，在執行時，直接去這個地址呼叫函式；
而在Java語言中不是這樣，一切都是動態的。編譯時，如果發現對其它類方法的呼叫或者對其它類欄位的引用的語句，記錄進class檔案中的只能是一個文字形式的符號引用，在連線過程中，虛擬機器根據這個文字資訊去查詢對應的方法或欄位。
所以，與Java語言中的所謂“常量”不同，class檔案中的“常量”內容很非富，這些常量集中在class中的一個區域存放，一個緊接著一個，這裡就稱為“常量池”。
具體結構　在Java程式中，有很多的東西是永恆的，不會在執行過程中變化。比如一個類的名字，一個類欄位的名字/所屬型別，一個類方法的名字/返回型別/引數名與所屬型別，一個常量，還有在程式中出現的大量的字面值。

拘留字串物件
原始碼中所有相同字面值的字串常量只可能建立唯一 一個拘留字串物件。 實際上JVM是通過一個記錄了拘留字串引用的內部資料結構來維持這一特性的。在Java程式中，可以呼叫String的intern()方法來使得一個常規字串物件成為拘留字串物件。
(1)String s=new String("Hello world"); 編譯成class檔案後的指令(在myeclipse中檢視):
事實上，在執行這段指令之前，JVM就已經為"Hello world"在堆中建立了一個拘留字串( 值得注意的是：如果源程式中還有一個"Hello world"字串常量，那麼他們都對應了同一個堆中的拘留字串)。然後用這個拘留字串的值來初始化堆中用new指令創建出來的新的String物件，區域性變數s實際上儲存的是new出來的堆物件地址。
(2)String s="Hello world";
這跟(1)中建立指令有很大的不同，此時區域性變數s儲存的是早已建立好的拘留字串的堆地址。

java常量池技術 java中的常量池技術，是為了方便快捷地建立某些物件而出現的，當需要一個物件時，就可以從池中取一個出來（如果池中沒有則建立一個），則在需要重複建立相等變數時節省了很多時間。常量池其實也就是一個記憶體空間，不同於使用new關鍵字建立的物件所在的堆空間。

　　String類也是java中用得多的類，同樣為了建立String物件的方便，也實現了常量池的技術。
　　測試程式碼如下:

public class Test{
	public static void main(String[] args){

	//s1,s2分別位於堆中不同空間
	String s1=new String("hello");
	String s2=new String("hello");
	System.out.println(s1==s2);//輸出false
　
	//s3,s4位於池中同一空間
	String s3="hello" String s4="hello";
	System.out.println(s3==s4);//輸出true
	}
}

用new String（）建立的字串不是常量，不能在編譯期就確定，所以new String（）建立的字串不放入常量池中，他們有自己的地址空間。
String 物件（記憶體）的不變性機制會使修改String字串時，產生大量的物件，因為每次改變字串，都會生成一個新的String。 java 為了更有效的使用記憶體，常量池在編譯期遇見String 字串時，它會檢查該池內是否已經存在相同的String 字串，如果找到，就把新變數的引用指向現有的字串物件，不建立任何新的String 常量物件，沒找到再建立新的。所以對一個字串物件的任何修改，都會產生一個新的字串物件，原來的依然存在，等待垃圾回收。

String a = “test”;
String b = “test”;
String b = b+"java";

a，b同時指向常量池中的常量值"test"，b=b+"java"之後，b原先指向一個常量，內容為"test”，通過對b進行+"java" 操作後，b之前所指向的那個值沒有改變，但此時b不指向原來那個變數值了，而指向了另一個String變數，內容為”text java“。原來那個變數還存在於記憶體之中，只是b這個變數不再指向它了。

八種基本型別的包裝類和物件池　

Java中基本型別的包裝類的大部分都實現了常量池技術，這些類是Byte,Short,Integer,Long,Character,Boolean,另外兩種浮點數型別的包裝類則沒有實現。另外Byte,Short,Integer,Long,Character這5種整型的包裝類也只是在對應值小於等於127時才可使用物件池，也即物件不負責建立和管理大於127的這些類的物件。 一些對應的測試程式碼：

public class Test{ 
	public static void main(String[] args){

	//5種整型的包裝類Byte,Short,Integer,Long,Character的物件，
	//在值小於127時可以使用常量池
	Integer i1 = 127;
	Integer i2 = 127;
	System.out.println(i1==i2); //輸出true

	//值大於127時，不會從常量池中取物件
	Integer i3 = 128;
	Integer i4 = 128;
	System.out.println(i3==i4); //輸出false
	
	//Boolean類也實現了常量池技術
	Boolean bool1 = true;
	Boolean bool2 = true;
	System.out.println(bool1==bool2); //輸出true

	//浮點型別的包裝類沒有實現常量池技術
	Double d1 = 1.0;
	Double d2 = 1.0;
	System.out.println(d1==d2); //輸出false
	}
}

//對Integer物件的程式碼補充
public static Integer valueOf(int i) {

	final int offset = 128;
	if (i >= -128 && i <= 127) {
		return IntegerCache.cache[i + offset];
	}
	return new Integer(i);
}

當你直接給一個Integer物件一個int值的時候，其實它呼叫了valueOf方法，然後你賦的這個值很特別，是128，那麼沒有進行cache方法，相當於new了兩個新物件。所以問題中定義a、b的兩句程式碼就類似於：
　　Integer a = new Integer(128);
　　Integer b = new Integer(128);
這個時候再問你，輸出結果是什麼？你就知道是false了。如果把這個數換成127，再執行：
　　Integer a = 127;
　　Integer b = 127;
　　System.out.println(a == b);
　　結果就是：true
進行物件比較時最好還是使用equals，便於按照自己的目的進行控制。這裡引出equals()和==，equals比較的是字串字面值即比較內容，==比較引用。

看一下IntegerCache這個類裡面的內容：

private static class IntegerCache {
　　
	private IntegerCache() { }

	static final Integer cache[] = new Integer[-(-128) + 127 + 1];

	static {
		for (int i = 0; i < cache.length; i++)
			cache[i] = new Integer(i - 128);
　　	}
}

由於cache[]在IntegerCache類中是靜態陣列，也就是隻需要初始化一次，即static{......}部分，所以，如果Integer物件初始化時是-128~127的範圍，就不需要再重新定義申請空間，都是同一個物件---在IntegerCache.cache中，這樣可以在一定程度上提高效率。

針對String方面的補充
在同包同類下,引用自同一String物件.
在同包不同類下,引用自同一String物件.
在不同包不同類下,依然引用自同一String物件.

在編譯成.class時能夠識別為同一字串的,自動優化成常量,所以也引用自同一String物件.
在執行時建立的字串具有獨立的記憶體地址,所以不引用自同一String物件.

String的intern()方法會查詢在常量池中是否存在一份equal相等的字串,
如果有則返回一個引用,沒有則新增自己的字串進入常量池，注意：只是字串部分。
所以這時會存在2份拷貝，常量池的部分被String類私有並管理，自己的那份按物件生命週期繼續使用。

返回字串物件的規範化表示形式
一個初始值為空的字串池，它由類 String 私有地維護。

當呼叫 intern 方法時，如果池已經包含一個等於此 String 物件的字串（該物件由 equals(Object) 方法確定），則返回池中的字串。否則，將此 String 物件新增到池中，並且返回此 String 物件的引用。
它遵循對於任何兩個字串 s 和 t，當且僅當 s.equals(t) 為 true 時，s.intern() == t.intern() 才為 true。
所有字面值字串和字串賦值常量表達式都是內部的。

------------------------------------程式碼演示補充-------------------------------------

String s0= "java";
String s1=new String("java");
String s2=new String("java");
s1.intern();
s2=s2.intern(); //把常量池中"java"的引用賦給s2
System.out.println( s0==s1);//false “ intern返回的引用沒有引用變數接收~ s1.intern();等於廢程式碼.”
System.out.println( s0==s1.intern() );//true
System.out.println( s0==s2 );//true

String s1=new String("java");
String s2=s1.intern();//s1 檢查常量池，發現沒有就拷貝自己的字串進去
//s2 引用該字串常量池的地址
System.out.println(s2 == s1);//false
System.out.println( s2==s1.intern());//true
System.out.println( s1==s1.intern());// false