『壹』 java 中 newInstance 方法和 new 的區別是什麼
1.new可以調用帶參數的構造函數，newInstance不可以。
2.new 是 java 的關鍵字，用來構造一個類的實例。而 newInstance 是 Class 的一個方法，不過兩個寫法的效果一樣。
3.newInstance: 弱類型。低效率。只能調用無參構造。new: 強類型。相對高效。能調用任何public構造。
4.new是關鍵字,用來生產對象,可以調用類的公開任何構造方法而newInstance是反射時用的,只能調用無參數的構造方法,如果想調用有參數的構造方法,可以用Constructor的newInstance(Object... initargs) 方法。
newInstance()是實現IOC、反射、面對介面編程 和 依賴倒置 等技術方法的必然選擇，new 只能實現具體類的實例化，不適合於介面編程。
『貳』 java中如何通過反射獲取類的屬性
簡單的方法如下：
Class<?> cls=Class.forName(className);////////////////////////通過類的名稱反射類
Object obj=cls.newInstance();//////////////////////對象實例化
Field field=cls.getField(fieldName);/////這個對應的是屬回性
fieldValue=field.get(obj);////這個就是屬性的值答
『叄』 Java中為什麼反射機制中的屬性的類型是Class類型的 方式機制中那麼哪些東西是Class類型的呢
不是類型，Class在java.lang 同過不同的方法（4種）來動態的獲取你所需要的類或介面，動態也就是說事先你並不清楚要使用哪個類，而且提供路徑（String類型參數）可以獲得任何類或介面。返回一個Class類型，最後返回你想要的類型，常見與資料庫連接工廠Class c=Class.forName(name);DBConnection con=(DBConnection) c.newInstance();下面詳細的介紹一下 JAVA反射機制
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。
Java反射機制主要提供了以下功能： 在運行時判斷任意一個對象所屬的類；在運行時構造任意一個類的對象；在運行時判斷任意一個類所具有的成員變數和方法；在運行時調用任意一個對象的方法；生成動態代理。
1. 得到某個對象的屬性
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2 Class ownerClass = owner.getClass();
3
4 Field field = ownerClass.getField(fieldName);
5
6 Object property = field.get(owner);
7
8 return property;
9 }
Class ownerClass = owner.getClass()：得到該對象的Class。
Field field = ownerClass.getField(fieldName)：通過Class得到類聲明的屬性。
Object property = field.get(owner)：通過對象得到該屬性的實例，如果這個屬性是非公有的，這里會報IllegalAccessException。
2. 得到某個類的靜態屬性
1 public Object getStaticProperty(String className, String fieldName)
2 throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Field field = ownerClass.getField(fieldName);
6
7 Object property = field.get(ownerClass);
8
9 return property;
10 }
Class ownerClass = Class.forName(className) ：首先得到這個類的Class。
Field field = ownerClass.getField(fieldName)：和上面一樣，通過Class得到類聲明的屬性。
Object property = field.get(ownerClass) ：這里和上面有些不同，因為該屬性是靜態的，所以直接從類的Class里取。
3. 執行某對象的方法
1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3 Class ownerClass = owner.getClass();
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先還是必須得到這個對象的Class。
5～9行：配置參數的Class數組，作為尋找Method的條件。
Method method = ownerClass.getMethod(methodName, argsClass)：通過Method名和參數的Class數組得到要執行的Method。
method.invoke(owner, args)：執行該Method，invoke方法的參數是執行這個方法的對象，和參數數組。返回值是Object，也既是該方法的返回值。
4. 執行某個類的靜態方法
1 public Object invokeStaticMethod(String className, String methodName,
2 Object[] args) throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(null, args);
14 }
基本的原理和實例3相同，不同點是最後一行，invoke的一個參數是null，因為這是靜態方法，不需要藉助實例運行。
5. 新建實例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3 Class newoneClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Constructor cons = newoneClass.getConstructor(argsClass);
12
13 return cons.newInstance(args);
14
15 }
這里說的方法是執行帶參數的構造函數來新建實例的方法。如果不需要參數，可以直接使用newoneClass.newInstance()來實現。
Class newoneClass = Class.forName(className)：第一步，得到要構造的實例的Class。
第5～第9行：得到參數的Class數組。
Constructor cons = newoneClass.getConstructor(argsClass)：得到構造子。
cons.newInstance(args)：新建實例。
6. 判斷是否為某個類的實例
1 public boolean isInstance(Object obj, Class cls) {
2 return cls.isInstance(obj);
3 }
7. 得到數組中的某個元素
1 public Object getByArray(Object array, int index) {
2 return Array.get(array,index);
3 }
『肆』 Java高級開發必須懂的反射是什麼樣的
理解反射對學習Java框架有很大的幫助，如Spring框架的核心就是使用Java反射實現的，而且對做一些Java底層的操作會很有幫助。
一、Class類的使用
1、萬事萬物皆對象，（當然，基本數據類型，靜態成員不是面向對象（屬於類的）），所以我們創建的每一個類也都是對象，即類本身是java.lang.Class類的實例對象，但是這些對象都不需要new出來，因為java.lang.Class類的構造方法是私有的
2、任何一個類都是Class類的實例對象，這個實例對象有三種表示方式：(我們新建一個Student類)（上海尚學堂java全程老師面授＋實戰教學）
①Classc1=Student.class;//實際告訴我們任何一個類都有一個隱含的靜態成員變數class（知道類名時用）
②Classc2=stu.getClass();//已知該類的對象通過getClass方法（知道對象時用）
③Classc3=Class.forName("類的全名");//會有一個ClassNotFoundException異常
官網解釋說：c1,c2表示了Student類的類類型（）classtype)，萬事萬物皆對象，類也是對象，是Class類的實例對象，這個對象我們成為該類的類類型（有點亂，但是慢慢捋一下還是能理解的）
這里有一點值得注意，當我們執行System.out.println(c1==c2);語句，結果返回的是true，這是為什麼呢？原因是不管c1還是c2都代表了Student類的類類型，一個類可能是Class類的一個實例對象。
我們完全可以通過類的類類型創建該類的對象實例，即通過c1或c2創建Student的實例。
Studentstu=(Student)c1.newInstance();//前提是必須要有無參的構造方法，因為該語句會去調用其無參構造方法。該語句會拋出異常。
二、動態載入類
1、編譯時載入類是靜態載入類，
new創建對象是靜態載入類，在編譯時刻就需要載入所有可用使用到的類，如果有一個用不了，那麼整個文件都無法通過編譯
2、運行時載入類是動態載入類
Classc=Class.forName("類的全名")，不僅表示了類的類型，還表示了動態載入類，編譯不會報錯，在運行時才會載入，使用介面標准能更方便動態載入類的實現。功能性的類盡量使用動態載入，而不用靜態載入。沙河電腦培訓發現
很多軟體比如QQ,360的在線升級，並不需要重新編譯文件，只是動態的載入新的東西。
『伍』 java反射機制詳解
在Java運行時刻，能否知道一個類的屬性方法並調用改動之？對於任意一個對象，能否知道他的所屬類，並調用他的方法？答案是肯定的。這種動態的獲取信息及動態調用方法的機制在Java中稱為「反射」（reflection）。
Java反射機制主要提供以下功能：
在運行時判斷任意一個對象所屬的類；
在運行時構造任意一個類的對象；
在運行時判斷任意一個類所具有的成員變數和方法；
在運行時調用任意一個對象的方法。
Reflection 是Java被視為動態（或准動態）語言的一個關鍵性質。這個機制允許程序在運行時透過Reflection APIs取得任何一個已知名稱的class的內部信息，包括其modifiers（諸如public, static 等等）、superclass（例如Object）、實現之interfaces（例如Serializable），也包括fields和methods 的所有信息，並可於運行時改變fields內容或調用methods。
一般而言，開發者社群說到動態語言，大致認同的一個定義是：「程序運行時，允許改變程序結構或變數類型，這種語言稱為動態語言」。
在JDK中，主要由以下類來實現Java反射機制，這些類都位於java.lang.reflect包中：
Class類：代表一個類；
Field 類：代表類的成員變數（成員變數也稱為類的屬性）；
Method類：代表類的方法；
Constructor 類：代表類的構造方法；
Array類：提供了動態創建數組，以及訪問數組的元素的靜態方法；
至於全部的你可以看看參考資料。我看這個資料不錯
『陸』 java反射中的newInstance的使用
其實類就是一個對象么。object就是對象的意思。
object就是泛指所有的類，而我們常用的 A a = new A();這種寫法就是具體化了。其實也可以寫成Object ojb = new A();
newIntance()就是對象的實例化，返回的一個對象，如果知道具體對象的時很么的話，也可以直接用該對象來接受 A a = c.newInstance()