首先建立一個類,裏面有各種各樣的方法的字段,然後用反射來調用,調用的時候用junit來測試
package com.fts.reflect;
import java.io.InputStream;
import java.util.List;
public class Person {
public String name="first test";
private int passwd=123;
private static int age=100;
public Person(){
System.out.println("person");
}
public Person(String name){
System.out.println("person name:"+name);
}
public Person(String name,int passwd){
System.out.println("person name:"+name+" passwd:"+passwd);
}
private Person(List list){
System.out.println("list");
}
public void test(){
System.out.println("test");
}
public void test(String name,int passwd){
System.out.println("test:"+name+" :"+passwd);
}
public Class[] test(String name,int[] passwd){
return new Class[]{String.class};
}
private void test(InputStream in){
System.out.println(in);
}
public static void test(int num){
System.out.println(num);
}
public static void main(String[] args){
System.out.println("main method");
}
}
反射,加載類的三種方法
package com.fts.reflect;
public class Demo1 {
/**
* 反射,加載類,獲得類的字節碼
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException {
// TODO Auto-generated method stub
//方法一
Class clazz=Class.forName("com.fts.reflect.Person");
//方法二
Class clazz1=new Person().getClass();
//方法三
Class clazz2=Person.class;
System.out.println(clazz==clazz1);
System.out.println(clazz1==clazz2);
}
}
反射出構造函數
package com.fts.reflect;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
/*
* 解剖構造函數,創建類的對象
*/
public class Demo2 {
//反射構造函數 public Person(){}
@Test
public void test1() throws Exception{
//將類加載進內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//解剖構造函數
Constructor c=clazz.getConstructor(null);
//創建一個對象
Person p=(Person) c.newInstance(null);
System.out.println(p.name);
}
//反射構造函數 public Person(string name){}
@Test
public void test2() throws Exception{
//將類加載進內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//解剖構造函數
Constructor c=clazz.getConstructor(String.class);
//創建一個對象
Person p=(Person) c.newInstance("my name");
System.out.println(p.name);
}
//反射構造函數 public Person(string name,int passwd){}
@Test
public void test3() throws Exception{
//將類加載進內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//解剖構造函數
Constructor c=clazz.getConstructor(String.class,int.class);
//創建一個對象
Person p=(Person) c.newInstance("my name",888888);
System.out.println(p.name);
}
//反射構造函數 private Person(List list){}
@Test
public void test4() throws Exception{
//將類加載進內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//解剖構造函數
Constructor c=clazz.getDeclaredConstructor(List.class);
c.setAccessible(true);//暴力強暴打開
//創建一個對象
Person p=(Person) c.newInstance(new ArrayList());
System.out.println(p.name);
}
//創建對象的另一種形式
@Test
public void test5() throws Exception{
//將類加載進內存中
Class clazz=Class.forName("com.fts.reflect.Person");
Person p=(Person) clazz.newInstance();
System.out.println(p);
}
}
反射類的其它方法
package com.fts.reflect;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;
import org.junit.Test;
//反射類的方法
public class Demo3 {
//反射類的方法 public void test(){}
@Test
public void test1() throws Exception{
Person p=new Person();
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getMethod("test",null);
method.invoke(p, null);
}
//反射類的方法 public void test(String name,int passwd){}
@Test
public void test2() throws Exception{
Person p=new Person();
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getMethod("test",String.class,int.class);
method.invoke(p, "fengtansong",100);
}
//反射類的方法 public Class[] test(String name,int[] passwd)
@Test
public void test3() throws Exception{
Person p=new Person();
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getMethod("test",String.class,int[].class);
Class cs[]=(Class[]) method.invoke(p, "fengtansong",new int[]{1,2,3});
System.out.println(cs[0]);
}
//反射類的方法 private void test(InputStream in)
@Test
public void test4() throws Exception{
Person p=new Person();
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getDeclaredMethod("test",InputStream.class);
method.setAccessible(true);
method.invoke(p,new FileInputStream("c:\\1.txt"));
}
//反射類的方法 public static void test(int num)
@Test
public void test5() throws Exception{
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getMethod("test",int.class);
//靜態方法調用不需要對象
method.invoke(null,1000);
}
//反射類的方法 public static void main(String[] args)
@Test
public void test6() throws Exception{
//將類加載在內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//加載類的方法
Method method=clazz.getMethod("main",String[].class);
//靜態方法調用不需要對象
//method.invoke(null,new Object[]{new String[]{"1"}});
method.invoke(null,(Object)new String[]{"1"});
}
}
反射出字段
package com.fts.reflect;
import java.lang.reflect.Field;
import org.junit.Test;
//反射字段
public class Demo4 {
//反射字段public String name="first test";
@Test
public void test1() throws Exception{
Person p=new Person();
//將類加載到內存中
Class clazz=Class.forName("com.fts.reflect.Person");
Field f=clazz.getField("name");
//String name=(String) f.get(p);
//System.out.println(name);
// Class type=f.getType();
// System.out.println(type);
//獲取字段的值
Object value=f.get(p);
//獲取字段的類型
Class type=f.getType();
if(type.equals(String.class)){
String svalue=(String) value;
System.out.println(svalue);
}
//設置字段的值
f.set(p,"xxxxxxxxxx");
System.out.println(p.name);
}
//反射字段private int passwd=123;
@Test
public void test2() throws Exception{
Person p=new Person();
//將類加載到內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//獲得對象
Field f=clazz.getDeclaredField("passwd");
f.setAccessible(true);
System.out.println(f.get(p));
}
//反射字段private static int age=100;
@Test
public void test3() throws Exception{
Person p=new Person();
//將類加載到內存中
Class clazz=Class.forName("com.fts.reflect.Person");
//獲得對象
Field f=clazz.getDeclaredField("age");
f.setAccessible(true);
System.out.println(f.get(p));
}
}
通過以上的例子簡單理解了反射的應用
在JDK中,主要由以下類來實現Java反射機制,這些類都位於java.lang.reflect包中:
Class類:代表一個類。
Field 類:代表類的成員變量(成員變量也稱爲類的屬性)。
Method類:代表類的方法。
Constructor 類:代表類的構造方法。
Array類:提供了動態創建數組,以及訪問數組的元素的靜態方法。
一、通過Class類獲取成員變量、成員方法、接口、超類、構造方法等
在java.lang.Object 類中定義了getClass()方法,因此對於任意一個Java對象,都可以通過此方法獲得對象的類型。Class類是Reflection API 中的核心類,它有以下方法
getName():獲得類的完整名字。
getFields():獲得類的public類型的屬性。
getDeclaredFields():獲得類的所有屬性。
getMethods():獲得類的public類型的方法。
getDeclaredMethods():獲得類的所有方法。
getMethod(String name, Class[] parameterTypes):獲得類的特定方法,name參數指定方法的名字,parameterTypes 參數指定方法的參數類型。
getConstructors():獲得類的public類型的構造方法。
getConstructor(Class[] parameterTypes):獲得類的特定構造方法,parameterTypes 參數指定構造方法的參數類型。
newInstance():通過類的不帶參數的構造方法創建這個類的一個對象。