正常情况下，单纯的做开发是接触不到反射机制的（额，当然并不排除例外的情况了）。下面我就对我学到的反射方面的知识做一个小小的总结，旨在复习和以后的查看。
原理分析：
所谓反射就是将一个类当做我们研究的对象，进行分解，获取其中的内容的过程。其核心就是Class类，他是所有类的研究的对象，基于Class我们就可以获取一个类的字节码，进而获取想要的值。
目标类（待解刨的类）
package reflect;
public class Person {
public Person(){}
private String name;
public int address;
public int getAddress() {
return address;
}
public void setAddress(int address) {
this.address = address;
}
public void setName(String name) {
this.name = name;
}
public Person(String name ){
this.name = name;
}
public String getName(){
return this.name;
}
private Person(int name){
System.out.println("这里是私有的带有参数的构造方法！");
}
public void eat(){
System.out.println("吃饭！");
}
public void drink(String name){
System.out.println("正在喝 ："+ name);
}
public void purchase(String address ,int [] number , String [] item){
System.out.println("这个人在 " + address +" 买了 "+item +" 分别 "+ number+" 个！");
}
private String flay(String tool){
return "I Can Flay By "+ tool;
}
public static String spend(String money){
System.out.println("我只能够花费 "+money +"钱！");
return "你造吗？";
}
public static void main(String[] args) {
System.out.println(args[0]);
}
}
反射构造方法小例子
package reflect;
import java.lang.reflect.Constructor;
import org.junit.Test;
public class ReflectConstructor {
/**
* 反射得到无参的构造函数的方法
* @throws Exception
*/
@Test
public void reflect1() throws Exception{
Class cls = Class.forName("reflect.Person");
Constructor c = cls.getConstructor(null);
Person person = (Person) c.newInstance(null);
System.out.println("反射得到的结果是："+ person.toString());
}
/**
* 反射出带有参数的构造方法
* @throws Exception
*/
@Test
public void reflect2() throws Exception {
Class cls = Class.forName("reflect.Person");
Constructor c = cls.getConstructor(String.class);
Person person = (Person) c.newInstance("Name");
System.out.println("反射获得的有参的结果是："+ person.getName());
}
/**
* 反射出私有的带有参数的构造方法
* @throws NoSuchMethodException
* @throws Exception
*/
@Test
public void reflect3() throws NoSuchMethodException, Exception {
Class cls = Class.forName("reflect.Person");
Constructor c = cls.getDeclaredConstructor(int.class);
//java语言默认私有的方法是不能被外界访问的到的，但要进行强制的访问需要加上一层权限
c.setAccessible(true);
Person person = (Person) c.newInstance(201492115);
System.out.println("反射出私有的带有参数的构造方法！"+ person.toString());
}
}
反射所有方法的小例子
package reflect;
import java.lang.reflect.Method;
import org.junit.Test;
public class ReflectMethods {
/**
* 反射测试一个无参的方法
* public void eat()
* @throws Exception
*/
@Test
public void feflect1() throws Exception {
Class cls = Class.forName("reflect.Person");
Method method =cls.getMethod("eat", null);
System.out.println(method.toString());
method.invoke(new Person(), null);
method.invoke(cls.newInstance(), null);
}
/**
* 反射测试一个带有参数的方法
* public void drink(String name)
* @throws Exception
*/
@Test
public void reflect2() throws Exception {
Class cls = Class.forName("reflect.Person");
Method method =cls.getMethod("drink", String.class);
System.out.println(method.toString());
method.invoke(new Person(), "中国凉茶");
method.invoke(cls.newInstance(), "中国凉茶");
}
/**
* 反射测试含有多个复杂类型的参数的方法
* public void purchase(String address ,int [] number , String [] item)
* @throws Exception
*/
@Test
public void reflect3() throws Exception {
Class cls = Class.forName("reflect.Person");
Method method = cls.getMethod("purchase", String.class,int[].class,String[].class);
method.invoke(cls.newInstance(), "大连",new int[]{1,2,3},new String[]{"鱿鱼","贝壳","螃蟹"});
}
/**
* 反射测试一个带有返回值的不含参数的方法
* public String getName()
* @throws Exception
*/
@Test
public void reflect4() throws Exception {
Class cls = Class.forName("reflect.Person");
Method method = cls.getMethod("getName", null);
String result = (String) method.invoke(cls.newInstance(), null);
System.out.println("测试带有返回值的无参的方法，所得的结果是： "+result);
}
/**
* 反射测试私有含参数的方法
* private String flay(String tool)
*/
@Test
public void reflect5() throws Exception {
Class cls = Class.forName("reflect.Person");
//对于私有的方法只能通过getDeclaredMethod方式得到
Method method = cls.getDeclaredMethod("flay", String.class);
//记得强制将访问*限提升起来到"可以访问的到"
method.setAccessible(true);
String result = (String) method.invoke(cls.newInstance(), "蝙蝠侠的风衣！");
System.out.println("反射测试私有的含参数的方法的结果是： "+ result);
}
/**
* 反射测试私有的含参数的静态的方法
* public static String spend(String money)
*/
@Test
public void reflect6() throws Exception {
Class cls = Class.forName("reflect.Person");
//对于静态的方法只能通过getDeclaredMethod方式得到
Method method = cls.getDeclaredMethod("spend", String.class);
String result = (String) method.invoke(cls.newInstance(), "100000000000000元人民币！");
System.out.println("反射测试私有的含参数的方法的结果是： "+ result);
}
/**
* 反射测试主方法
* public static void main(String[] args)
* @throws Exception
*/
@Test
public void reflect7() throws Exception {
Class cls = Class.forName("reflect.Person");
Method method = cls.getMethod("main",String[].class);
method.invoke(null, (Object)new String[]{"A","B","C"});
}
}
反射字段值的小例子
package reflect;
import java.lang.reflect.Field;
import org.junit.Test;
public class ReflectField {
/**
* 反射测试字段（属性）的值
* public int address
* @throws Exception
*/
@Test
public void reflect1 () throws Exception {
Class cls = Class.forName("reflect.Person");
Field field = cls.getField("address");
String result = field.getName();
System.out.println("反射所得的字段的结果是："+result);
}
/**
* 反射测试私有的属性（字段）的结果
* private String name
* @throws Exception
*/
@Test
public void reflect2() throws Exception {
Class cls = Class.forName("reflect.Person");
Field field = cls.getDeclaredField("name");
field.setAccessible(true);
String result = field.getName();
System.out.println("反射测试所得的私有的字段（属性）的值为："+ result);
}
}
我的总结
- 全部的反射方法均交给JUnit测试通过，并没有发现出错的地方
- 反射是一个比较灵活的方式，具体情况一定要灵活的变通
- 对于私有的变量或者方法，要想访问到其值，就必须打开访问的权限即设置为setAccessable(true)；
- 对于框架的运行，需要给出一个类的完整名称（包含完整的包名）,这样才不会出错！