java反射創建帶參數對象

① java中反射的三種方法是

java中反射的三種方法：
1. 通過Object類的getClass方法來獲取
java.lang.Object中定義有getClass方法：public final Class getClass()
所有Java對象都具備這個方法，該方法用於返回調用該方法的對象的所屬類關聯的Class對象，例如：
Date date1 = new Date();
Date date2 = new Date();
Class c1 = date1.getClass();
Class c2 = date2.getClass();
System.out.println(c1.getName());
// java.util.Date
System.out.println(c1 == c2);
// true
上面的代碼中，調用Date對象date1的getClass方法將返回用於封裝Date類信息的Class對象。
這里調用了Class類的getName方法：public String getName()，這個方法的含義很直觀，即返回所封裝的類的名稱。
需要注意的是，代碼中的date1和date2的getClass方法返回了相同的Class對象（c1==c2的值為true）。這是因為，對於相同的類，JVM只會載入一次，而與該類對應的Class對象也只會存在一個，無論該類實例化了多少對象。
另外，需要強調的是，當一個對象被其父類的引用或其實現的介面類型的引用所指向時，getClass方法返回的是與對象實際所屬類關聯的Class對象。例如：
List list = new ArrayList();
System.out.println(list.getClass().getName()); // java.util.ArrayList
上面的代碼中，語句list.getClass()方法返回的是list所指向對象實際所屬類java.util.ArrayList對應的 Class對象而並未java.util.List所對應的Class對象。有些時候可以通過這個方法了解一個對象的運行時類型，例如：
HashSet set = new HashSet();
Iterator it = set.iterator();
System.out.println(it.getClass().getName()); //java.util.HashMap$KeyIterator
從代碼可以看出，HashSet的iterator方法返回的是實現了Iterator介面的HashMap內部類（KeyIterator）對象。
因為抽象類和介面不可能實例化對象，因此不能通過Object的getClass方法獲得與抽象類和介面關聯的Class對象。
2. 使用.class的方式
使用類名加「.class」的方式即會返回與該類對應的Class對象。例如：
Class clazz = String.class;
System.out.println(clazz.getName()); // java.lang.String
這個方法可以直接獲得與指定類關聯的Class對象，而並不需要有該類的對象存在。
3. 使用Class.forName方法
Class有一個著名的static方法forName：public static Class forName(String className) throws ClassNotFoundException
該方法可以根據字元串參數所指定的類名獲取與該類關聯的Class對象。如果該類還沒有被裝入，該方法會將該類裝入JVM。
該方法聲明拋出ClassNotFoundException異常。顧名思義，當該方法無法獲取需要裝入的類時（例如，在當前類路徑中不存在這個類），就會拋出這個異常。
例如，如果當前類路徑中存在Foo類：
package org.whatisjava.reflect;
public class Foo {
public Foo() {
System.out.println("Foo()");
}
static {
System.out.println("Foo is initialized");
}
}
運行下面的代碼：
Class clazz = Class.forName("org.whatisjava.reflect.Foo");
控制台會有如下輸出：
Foo is initialized
Class.forName("org.whatisjava.reflect.Foo")首先會將reflection.Foo類裝入JVM，並返回與之關聯的Class對象。JVM裝入Foo類後對其進行初始化，調用了其static塊中的代碼。需要注意的是：forName方法的參數是類的完 整限定名（即包含包名）。
區別於前面兩種獲取Class對象的方法：使用Class.forName方法所要獲取的與之對應的Class對象的類可以通過字元串的方式給定。該方法通常用於在程序運行時根據類名動態的載入該類並獲得與之對應的Class對象。
通過上面的文章相信你對java的反射機制有了一定的認識,同時也對java中Class類的用法有了比較清晰的理解,在我們實際工作的過程中,我們不斷的運用java知識來解決實際生活中的問題的時候我們就能對java反射機制有一個更深入的理解!

二、代碼示例
1.ClassTest.java

[java] view plain
/**
* java中Class類的使用
*/
import java.io.*;
import java.lang.reflect.*;
public class ClassTest1 {
public ClassTest1(){

}
public static void main(String[] args) throws Exception{
ClassTest1 test=new ClassTest1();
ClassTest1 test1=test.getClass().newInstance();
//test1=test;
test.printMessage();
test1.printMessage();
System.out.println(test.hashCode());
System.out.println(test1.hashCode());

Method[] method=test1.getClass().getMethods();

for(Method m :method){
System.out.println(m.getDeclaringClass());
System.out.println(m.getName());
}
}
public void printMessage(){
System.out.println("Created successful!");
}
}
運行結果：

[plain] view plain
Created successful!
Created successful!
14576877
12677476
class ClassTest1
printMessage
class ClassTest1
main
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
hashCode
class java.lang.Object
getClass
class java.lang.Object
equals
class java.lang.Object
toString
class java.lang.Object
notify
class java.lang.Object
notifyAll
2.TestClass.java

[java] view plain
/**
*
*/
public class TestClass {
public static void main(String[] args)
{
try {
// 測試Class.forName()
Class testTypeForName = Class.forName("TestClassType");
System.out.println("testForName---" + testTypeForName);
// 測試類名.class
Class testTypeClass = TestClassType.class;
System.out.println("testTypeClass---" + testTypeClass);
// 測試Object.getClass()
TestClassType testGetClass = new TestClassType();
System.out.println("testGetClass---" + testGetClass.getClass());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

class TestClassType {
// 構造函數
public TestClassType() {
System.out.println("----構造函數---");
}
// 靜態的參數初始化
static {
System.out.println("---靜態的參數初始化---");
}
// 非靜態的參數初始化
{
System.out.println("----非靜態的參數初始化---");
}
}
運行結果:
[plain] view plain
---靜態的參數初始化---
testForName---class TestClassType
testTypeClass---class TestClassType
----非靜態的參數初始化---
----構造函數---
testGetClass---class TestClassType
分析：根據結果可以發現，三種生成的Class對象一樣的，並且三種生成Class對象只列印一次「靜態的參數初始化」。

② java 反射 類的帶參數實例化

把參數裡面的int改成Integer public Person(String name, Integer age) 這種
/**
* 得到帶構造的類的實例
* */
public static Object newInstance(String className, Object[] args) throws Exception {
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}

③ JAVA創建對象有哪幾種方式

JAVA創建對象的四種方式：

有4種顯式地創建對象的方式：

1.用new語句創建對象，這是最常用的創建對象的方式。

2.運用反射手段，調用Java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。

3.調用對象的clone()方法。

4.運用反序列化手段，調用java.io.ObjectInputStream對象的readObject()方法.

下面演示了用前面3種方式創建對象的過程。

4.當Java虛擬機載入一個類時，會隱含地創建描述這個類的Class實例.

④ 如何通過java 反射 調用一個 含有 可變參數的 方法呢

java反射調用可變參數的方法的方式是傳入objects參數，如下代碼：

publicclassReflect{

publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Single.class;
Singlesingle=(Single)clazz.newInstance();
List<String>list=newArrayList<String>(){
=1L;
{
add("fuck");
add("ni");
add("mei");
}
};

//獲取method兩種方式，在method中數組的的空間大小是可以隨便寫的不一定使用0
/*1*/
Methodmethod=clazz.getDeclaredMethod("method",Array.newInstance(Object.class,0).getClass());
/*2*/
method=clazz.getDeclaredMethod("method",(newObject[0]).getClass());//初始化參數
/*1*/
Objectobjs=Array.newInstance(Object.class,2);
Array.set(objs,0,list);
Array.set(objs,1,"23");
method.invoke(single,objs);

/*2*/
Object[]objects={1,"fuck",list};
method.invoke(single,newObject[]{objects});
}
}

classSingle{
publicvoidmethod(Object...objs){
System.out.println(Arrays.deepToString(objs));
}
}

結果:
[[fuck,ni,mei],23]
[1,fuck,[fuck,ni,mei]]

⑤ JAVA反射中通過Class.forname()如何帶參數的方法怎麼賦值和調用呀

forName()是java.lang.Class類的一個方法， 如下
static Class forName(String className) :

返回與帶有給定字元串名的類或介面相關聯的 Class 對象 。
這句話說的太繞專口了，舉屬個例子吧：

Class t = Class.forName("java.lang.Thread")
執行完這句話，Thread類將被虛擬機載入了
類載入以後就可以創建實例，調用屬性和方法嘍。

⑥ JAVA反射中通過Class.forname()如何帶參數的方法怎麼賦值和調用呀

用Class.forName方法動態載入構造方法帶參數的類。

⑦ 如何利用java的反射機制動態創建對象

Java反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為Java語言的反射機制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。當然反射本身並不是一個新概念，它可能會使我們聯想到光學中的反射概念，盡管計算機科學賦予了反射概念新的含義，但是，從現象上來說，它們確實有某些相通之處，這些有助於我們的理解。
Java反射機制主要提供下面幾種用途：
在運行時判斷任意一個對象所屬的類
在運行時構造任意一個類的對象
在運行時判斷任意一個類所具有的成員變數和方法
在運行時調用任意一個對象的方法

以下，我們就以動態創建對象為例，通過代碼來解釋一下反射：
public class ReflectionTest {
public static void main(String[] args) throws Exception {
// 建立學生對象
Student student = new Student();
// 為學生對象賦值
student.setStuName("Wanggc");
student.setStuAge(24);
// 建立拷貝目標對象
Student destStudent = (Student) Bean(student);
// 輸出拷貝結果
System.out.println(destStudent.getStuName() + ":"
+ destStudent.getStuAge());
}
/**
* 拷貝學生對象信息。
*
* @param from
拷貝源對象
* @param dest
拷貝目標對象
* @throws Exception
例外
*/
private static Object Bean(Object from) throws Exception {
// 取得拷貝源對象的Class對象
Class<?> fromClass = from.getClass();
// 取得拷貝源對象的屬性列表
Field[] fromFields = fromClass.getDeclaredFields();
// 取得拷貝目標對象的Class對象
Object ints = fromClass.newInstance();
for (Field fromField : fromFields) {
// 設置屬性的可訪問性
fromField.setAccessible(true);
// 將拷貝源對象的屬性的值賦給拷貝目標對象相應的屬性
fromField.set(ints, fromField.get(from));
}
return ints;
}
}