反射的深入研究
1、操作类
package invokeDemo;
public interface China {
public static final String NATIONAL = "China";//定义全局常量
public static final String AUTHOR = "yue";//定义全局常量
public void sayChina();//无参的，没有返回值类型的
public String sayHello(String name,int age);//定义有两个参数的方法，并返回内容
}
package invokeDemo;
public class Per implements China{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Per() { //无参构造
}
public Per(String name) { //设置name属性
this.name = name;
}
public Per(String name,int age) { //
this.name = name;
this.age = age;
}
@Override
public void sayChina() {
System.out.println("作者：" + AUTHOR + ",国籍：" + NATIONAL);
}
@Override
public String sayHello(String name,int age) {
return name + ",你好！我今年：" + age + "岁了！";
}
}
2、通过反射调用类中的方法
在正常情况下，一个类的对象功能产生之后，就可以直接调用类中的方法了，如果想要调用的话，则肯定必须清楚的知道要调用的方法名称是什么，之后通过Class类中的
public Method getMethod(String name,
Class<?>... parameterTypes)
throws NoSuchMethodException,
SecurityException
方法，得到一个方法的Method对象，之后通过此Method对象来执行方法，但是在方法执行调用的时候，因为会牵扯到方法的参数问题，所以通过getMethod方法取得的时候，必须设置好需要的参数类型。
调用sayChina方法，因为没有参数
执行调用的方法：
public Object invoke(Object obj,
Object... args)
throws IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
执行的时候，还需要传递参数进去，并且需要实例化对象
如果要调用的方法中存在参数，则必须设置参数的类型及内容
没有参数：
package invokeDemo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InvokeSaychinademo {
public static void main(String[] args) {
Class<?> c1 = null;
try {
c1 = Class.forName("invokeDemo.Per");//实例化Class对象
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
Method met = c1.getMethod("sayChina");//找到sayChina方法
met.invoke(c1.newInstance());//调用方法
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
有参数：
package invokeDemo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InvokeSayHellodemo2 {
public static void main(String[] args) {
Class<?> c1 = null;
try {
c1 = Class.forName("invokeDemo.Per");//实例化Class对象
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
Method met = c1.getMethod("sayHello",String.class,int.class);//找到sayHello方法
String rv = null;
rv = (String)met.invoke(c1.newInstance(),"yue",17);//调用方法
System.out.println(rv);
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、通过反射调用类setter及getter
setter及getter方法是一个标准化的属性的访问方法，如果一个类的属性被封装，则必须通过setter及getter方法设置和取得，实际上此方法的操作之所以要这样规定，主要原因是由于反射机制可以给予支持的。
通过反射可以调用setter即getter
package invokeDemo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InvokeSetgetdemo {
public static String initStr(String old) { //将单词的首字母大写
String str = old.substring(0,1).toUpperCase() + old.substring(1);
return str;
}
/*
* object obj：要操作的对象，
* String att：要操作的属性
* Object value：要设置的属性
* Class<?> type：要设置的属性类型
* */
public static void setter(Object obj,String att,Object value,Class<?> type) {
try {
Method met = obj.getClass().getMethod("set"+initStr(att), type);//得到setter方法
met.invoke(obj, value);//设置setter内容
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void getter(Object obj,String att) {
try {
Method met = obj.getClass().getMethod("get"+initStr(att));//找到getter方法
System.out.println(met.invoke(obj));//调用getter方法
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
Class<?> c1 = null;
Object obj = null;
try {
c1 = Class.forName("invokeDemo.Per");//实例化Class对象
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
obj = c1.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
setter(obj,"name","yue",String.class);
setter(obj,"age",17,int.class);
System.out.println("姓名： ");
getter(obj,"name");
System.out.println("年龄： ");
getter(obj,"age");
}
}
以上的操作，在日后的开发中用户也许不会直接涉及到具体的代码开发，但其操作原理必须清楚。
4、通过反射操作属性
如果现在假设要操作一个类中的属性，则也可以通过Filed完成，而不必麻烦的通过setter和getter完成
得到公共属性
public Field getField(String name)
throws NoSuchFieldException,
SecurityException
得到公共属性：
public Field getDeclaredField(String name)
throws NoSuchFieldException,
SecurityException
取得属性
public Object get(Object obj)
throws IllegalArgumentException,
IllegalAccessException
设置属性：
public void set(Object obj,
Object value)
throws IllegalArgumentException,
IllegalAccessException
在访问私有属性时，必须让属性可见
public void setAccessible(boolean flag)
throws SecurityException
将其内容设置成true即可
package invokeDemo;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InvokeFileddemo {
public static void main(String[] args) throws Exception{
Class<?> c1 = null;
Object obj = null;
c1 = Class.forName("invokeDemo.Per");//实例化Class对象
obj = c1.newInstance();
Field nameField = null;
Field ageField = null;
nameField = c1.getDeclaredField("name");
ageField = c1.getDeclaredField("age");
//设置属性可见：
nameField.setAccessible(true);
ageField.setAccessible(true);
//设置属性：
nameField.set(obj, "yue");
ageField.set(obj, 17);
//得到属性
System.out.print("姓名：");
System.out.println(nameField.get(obj));
System.out.print("年龄：");
System.out.println(ageField.get(obj));
}
}
但是，观察，以上的操作中是否需要类的setter和getter方法支持呢？证明以上的操作调用与setter即getter无关，但是为了保证程序的安全性，还是要通过setter即getter方法完成调用。
5、通过反射操作数组
反射机制不光只能用在类中，也可以应用在任意的引用数据类型上，当然，这就包含了数组，数组使用Array类完成。
在Class类中存在以下的方法：
public Class<?> getComponentType()
得到数组指定下标的内容
public static Object get(Object array,
int index)
throws IllegalArgumentException,
ArrayIndexOutOfBoundsException
修改内容：
public static void set(Object array,
int index,
Object value)
throws IllegalArgumentException,
ArrayIndexOutOfBoundsException
开辟新数组：
public static Object newInstance(Class<?> componentType,
int... dimensions)
throws IllegalArgumentException,
NegativeArraySizeException
取得数组信息，并修改信息
package invokeDemo;
import java.lang.reflect.Array;
public class InvokeArraydemo {
public static void main(String[] args) throws Exception{
int temp[] = {1,2,3};//声明一个整型数组
Class<?> c = temp.getClass().getComponentType();//取得数组的Class对象
System.out.println("类型："+ c.getName());
System.out.println("长度："+Array.getLength(temp));
System.out.println("第一个内容：" + Array.get(temp, 0));
Array.set(temp, 0, 4);
System.out.println("第一个内容：" + Array.get(temp, 0));
}
}
使用Array类可以修改数组大小
修改的过程实际就是一个创建的过程，创建一个新的数组，所以还要把旧的内容拷贝到新的数组之中去。
package invokeDemo;
import java.lang.reflect.Array;
public class ChangeArraydemo {
public static void main(String[] args) throws Exception{
int temp[] = {1,2,3};//声明一个整型数组
int newType[] = (int [])arrayInc(temp, 5);//重新开辟空间
print(newType);
System.out.println("------------------");
String t[] = {"ww","pp","ll","zz"};
String nt[] = (String [])arrayInc(t, 6);
print(nt);
}
//开辟一个长度为len的数组，然后将原数组的值加进去
//相当于给原来的数组加空间
public static Object arrayInc(Object obj,int len) {
Class<?> c = obj.getClass();
Class<?> arr = c.getComponentType();//得到数组
Object newo = Array.newInstance(arr, len);//开辟新的大小
int co = Array.getLength(obj);
System.arraycopy(obj, 0, newo, 0, co);//拷贝内容
return newo;
}
public static void print(Object obj) {
Class<?> c = obj.getClass();
if(c.isArray()) {//判断是否是数组
Class<?> c1 = c.getComponentType();
//c1.getName()类型
System.out.println(c1.getName()+" "+ Array.getLength(obj));//输出数组信息
for(int i = 0;i<Array.getLength(obj);i++) {
System.out.println(Array.get(obj,i));//通过Array输出
}
}else {
return;
}
}
}
总结：
1.重点理解setter即getter方法的调用问题，原理，代码最好可以清楚的掌握
2.使用反射机制不建议直接使用属性操作，破坏封装性
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
