1.反射構造函數Constructor
package cn.base25.reflect;
import cn.base25.reflect.domain.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.junit.Test;
public class ReflectConstructor {
/*
* 反射構造函數
* 注: 1.使用getConstructor,只能反射public的構造方法
* 2.使用getDeclaredConstructor,可以反射所有的構造函數
*/
@Test
@SuppressWarnings({ "unchecked", "rawtypes", "unused" })
public void test1() {
try {
//1-1.根據類名取得Class對象(Person.class),會將Persona.class加載進來
Class clazz = Class.forName("cn.base25.reflect.domain.Person");
/*
//創建Class對象的實例
Person p = (Person) clazz.newInstance(); //注意: person類必須得有無參的構造函數,所以我們應該先反射其構造函數
*/
//1-2.反射構造函數,取到無參的構造函數
Constructor constructor = clazz.getConstructor(); //根據實際構造函數是否有參數,來獲取對應的構造函數
//1-3.由Constructor對象,來創建Person對象
Person p = (Person) constructor.newInstance();
constructor = clazz.getConstructor(int.class); //注意: 是int.class,千萬別寫成: Integer.class
p = (Person) constructor.newInstance(20);
//2.暴力反射private的構造函數
constructor = clazz.getDeclaredConstructor(String.class, int.class); //使用的是: getDeclaredConstructor
constructor.setAccessible(true); //設爲true,取消java語言訪問檢查
p = (Person) constructor.newInstance("rose", 18);
//3-1.列出Person類的所有構造函數(包括private)
Constructor[] cons = clazz.getDeclaredConstructors();
for(Constructor c : cons) {
System.out.println(c.toString());
}
//3-2.使用getConstructor,只能反射public的構造方法
System.out.println();
Constructor[] cons2 = clazz.getConstructors();
for(Constructor c : cons2) {
System.out.println(c.toString());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException ex) {
ex.printStackTrace();
} catch (IllegalAccessException ex) {
ex.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
2.反射方法Method
package cn.base25.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.junit.Test;
import cn.base25.reflect.domain.Person;
public class ReflectMethod {
/*
* 反射方法:
* 注意: 1.clazz.getMethod(String name, Object...obj)--只會得到具體某一個方法,而不是同名的所有方法!!
* 2.使用getMethod,可以反射父類的方法!!!!!
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void test1() {
try {
//0.加載Person類
Class clazz = Class.forName("cn.base25.reflect.domain.Person");
//1-1.使用getDeclaredMethod反射所有方法
Method[] methods = clazz.getDeclaredMethods(); //使用getDeclaredMethod,會將Person類自身的所有方法列出(不包括父類的方法)
for(Method m : methods) {
System.out.println(m.toGenericString());
}
System.out.println();
//1-2.使用getMethod反射所有方法
methods = clazz.getMethods(); //使用getMethod,會將所有public的方法列出(包括父類繼承而來的)
for(Method m : methods) {
System.out.println(m.toGenericString());
}
System.out.println();
//2-1.取得一個無參的Person對象
Person p = (Person) clazz.newInstance();
//2-2.通過反射,調用方法
Method m1 = clazz.getMethod("study"); //取得具體方法名的無參的method對象
//2-3.調用無參的study方法
m1.invoke(p); //invoke方法的調用需要: 對象和實際參數
//這邊也可以寫成: m1.invoke(p, null)
//3-1.取得帶一個int參數的"study"方法對象
Method m2 = clazz.getMethod("study", int.class);
//3-2.調用帶int參數的study方法
m2.invoke(p, 20);
//4.反射private的方法--使用getDeclaredMethod,並setAccessible(true)
Method m3 = clazz.getDeclaredMethod("study", int.class, String.class);
m3.setAccessible(true);
m3.invoke(p, 20, "sun");
//5.反射靜態方法
Method m4 = clazz.getMethod("study", String.class);
m4.invoke(p, "sta"); //這邊也可寫成: m4.invoke(null, "sta");
//6.反射main主函數
Method m5 = clazz.getMethod("main", String[].class); //注意: String[].class
m5.invoke(null, (Object)new String[]{"test"}); //這邊也可以寫成: m5.invoke(null, new Object[]{new String[]{"test2"}});
//7.反射Object的方法 //注意: 根據上面可以反射父類的方法知,可以反射那些方法
Method m6 = clazz.getMethod("hashCode");
System.out.println(m6.invoke(p));
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SecurityException e2) {
e2.printStackTrace();
} catch (NoSuchMethodException e2) {
e2.printStackTrace();
} catch (IllegalArgumentException e3) {
e3.printStackTrace();
} catch (IllegalAccessException e3) {
e3.printStackTrace();
} catch (InvocationTargetException e3) {
e3.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3.反射字段Field
package cn.base25.reflect;
import java.lang.reflect.Field;
import org.junit.Test;
import cn.base25.reflect.domain.Student;
public class ReflectField {
/*
* 反射字段:
* 注意: 1.使用getDeclaredFields,只會列出Student自身的字段(而不包括Person的),不能反射Person的字段!!!
* 2.一個Method/Field對象,對應一個具體方法/一個具體字段,但同時可以對應多個類對象的這一個方法/字段!!!
* 3.判斷出字段的類型!!!!
*/
@SuppressWarnings({ "rawtypes" })
@Test
public void test1() {
try {
//1.加載Student類
Class clazz = Class.forName("cn.base25.reflect.domain.Student");
//2-1.使用getDeclaredFileds,反射出所有的字段 //使用getDeclaredFields,只會列出Student自身的字段(而不包括Person的)
Field[] fields = clazz.getDeclaredFields();
for(Field f : fields) {
System.out.println(f.toGenericString());
}
System.out.println();
//2-2.使用getFileds,反射出所有的字段
Field[] fields2 = clazz.getFields(); //使用getMethods,只會列出public的Student字段
for(Field f : fields2) {
System.out.println(f.toGenericString());
}
//3.創建一個Student對象
Student stu = (Student) clazz.newInstance();
//4.設置public的"sName"字段的值,並取出,查看結果
Field field = clazz.getField("sName");
field.set(stu, "李四");
System.out.println(field.get(stu)); //打印stu對象的sName的值
//5.反射private的"name3"字段
Field field2 = clazz.getDeclaredField("name3"); //1.需要使用getDeclaredField
field2.setAccessible(true); //2.還要打開權限
field2.set(stu, "王偉");
System.out.println(field2.get(stu));
//6.取得"name3"字段的類型,判斷出其類型
Class cType = field2.getType();
if(String.class.equals(cType)) {
String s = (String) field2.get(stu);
System.out.println("\"name3\"字段的類型是 " + s.getClass() +", 值爲:" + s);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
附:
1.Person類:
package cn.base25.reflect.domain;
@SuppressWarnings("unused")
public class Person {
public String name="張三";
public int age;
//構造函數
public Person() {
System.out.println("person()");
}
public Person(int id) {
System.out.println("public person(int)");
}
private Person(String name, int id) {
System.out.println("private person(String, int)");
}
Person(int id, int j, int m) {
System.out.println("public person(int)");
}
protected Person(int id, int j) {
System.out.println("public person(int)");
}
//方法
public void study() {
System.out.println("public study()");
}
void study(int i, int j, String s) {
System.out.println("默認 study(int i, int j, String s)");
}
public void study(int i) {
System.out.println("public study(int i)");
}
protected void study(int i, int j) {
System.out.println("protected study(int i, int j)");
}
private void study(int i ,String s) {
System.out.println("private study(int i ,String s)");
}
public static void study(String s) {
System.out.println("public static study(String s)");
}
public static void main(String []args) {
System.out.println("reflect main() sucessful!");
}
}
2.Student類:
package cn.base25.reflect.domain;
@SuppressWarnings("unused")
public class Student {
public String sName;
String name1;
protected String name2;
private String name3;
public int age;
public static int id;
//構造函數
public Student() {
System.out.println("person()");
}
public Student(int id) {
System.out.println("public person(int)");
}
private Student(String name, int id) {
System.out.println("private person(String, int)");
}
Student(int id, int j, int m) {
System.out.println("public person(int)");
}
protected Student(int id, int j) {
System.out.println("public person(int)");
}
//方法
public void study() {
System.out.println("public study()");
}
void study(int i, int j, String s) {
System.out.println("default study(int i, int j, String s)");
}
public void study(int i) {
System.out.println("public study(int i)");
}
protected void study(int i, int j) {
System.out.println("protected study(int i, int j)");
}
private void study(int i ,String s) {
System.out.println("private study(int i ,String s)");
}
public static void study(String s) {
System.out.println("public static study(String s)");
}
public static void main(String []args) {
System.out.println("reflect main() sucessful!");
}
}