使用反射实例对象
使用反射机制,我们可以在运行时动态加载类并且实例化对象,操作对象的方法、改变类成员的值,甚至还可以改变私有(private)成员的值。
我们可以用 Class 的 newInstance() 方法来实例化一个对象,实例化的对象是以 Object 传回的,例如:
Class c = Class.forName(className);
Object obj = c.newInstance();
下面范例动态加载list接口的类:
package CoreJava.day_2;
import java.util.List;
/**
* @author 李智
* @date 2016/12/5
*/
public class NewInstanceDemo {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
List list = (List) c.newInstance();
for (int i = 0; i < 5; i++) {
list.add("element " + i);
}
for (Object o : list.toArray()) {
System.out.println(o);
}
} catch (ClassNotFoundException e) {
System.out.println("找不到指定的类");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
输出:
java CoreJava.day_2.NewInstanceDemo java.util.ArrayList
element 0
element 1
element 2
element 3
element 4
实际上如果想要使用反射来动态加载类,通常是对对象的接口或类别都一无所知,也就无法像上面对 newInstance() 传回的对象进行接口转换。
如果加载的类中具备无参数的构造方法,则可以无参数的 newInstance() 来构造一个不指定初始化的引用,如果要在动态加载及生成对象时指定对象的引用,则要先指定参数类型、取得 Constructor 对象、使用 Constructor 的 newInstance() 并指定参数。
可以用一个例子来说明,先定义一个student类:
package CoreJava.day_2;
/**
* @author 李智
* @date 2016/12/05
*/
public class Student {
private String name;
private int score;
public Student() {
name = "N/A";
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public void setName(String name) {
this.name = name;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public String toString() {
return name + ":" + score;
}
}
我们可以用 Class.forName() 来加载 Student ,并使用第二个有参数的构造方法来构造Student 实例:
package CoreJava.day_2;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author 李智
* @date 2016/12/5
*/
public class NewInstanceDemo2 {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
// 指定参数
Class[] params = new Class[2];
// 第一个是String
params[0] = String.class;
// 第二个是int
params[1] = Integer.TYPE;
// 取得对应的构造方法
Constructor constructor =
c.getConstructor(params);
// 指定引用内容
Object[] argObjs = new Object[2];
argObjs[0] = "caterpillar";
argObjs[1] = new Integer(90);
// 给定引用并初始化
Object obj = constructor.newInstance(argObjs);
// toString()查看
System.out.println(obj);
} catch (ClassNotFoundException e) {
System.out.println("找不到类");
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
System.out.println("没有所指定的方法");
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
输出:
java NewInstanceDemo2 CoreJava.day_2.Student
caterpillar:90
调用方法
使用反射可以取回类上方法的对象代表,方法的物件代表是 java.lang.reflect.Method 的实例,我们可以使用它的 invoke() 方法來动态调用指定的方法,例如调用上面 Student 上的 setName() 等方法:
package CoreJava.day_2;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author 李智
* @date 2016/12/5
*/
public class InvokeMethodDemo {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
// 使用无参构造方法实例对象
Object targetObj = c.newInstance();
// 设置参数类型
Class[] param1 = {String.class};
// 根据参数取回方法
Method setNameMethod = c.getMethod("setName", param1);
// 设置引用
Object[] argObjs1 = {"caterpillar"};
// 给引用调用指定对象的方法方法
setNameMethod.invoke(targetObj, argObjs1);
Class[] param2 = {Integer.TYPE};
Method setScoreMethod =
c.getMethod("setScore", param2);
Object[] argObjs2 = {new Integer(90)};
setScoreMethod.invoke(targetObj, argObjs2);
// 显示类描述
System.out.println(targetObj);
} catch (ClassNotFoundException e) {
System.out.println("找不到类");
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
System.out.println("没有这个方法");
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
我们可以指定加载 Student 类并生成实例,接着可以动态调用 setName() 和 setScore() 方法,由于调用setName() 和 setScore() 所设置的参数是 “caterpillar” 和90。
在很少的情況下,我们需要突破 Java 的存取限制来调用受保护的(protected)或私有(private)的方法(例如我们拿到一个组件(Component),但我们没法修改它的原始码来改变某个私有方法的权限,而我们又一定要调用某个私有方法),这时我们可以使用反射机制來达到目的,一个存取私有方法的例子如下:
Method privateMethod =
c.getDeclaredMethod("somePrivateMethod", new Class[0]);
privateMethod.setAccessible(true);
privateMethod.invoke(targetObj, argObjs);
使用反射来动态调用方法的实例例子之一是在 JavaBean 的设定,例如在 JSP/Servlet 中,可以根据使用者的请求名和 JavaBean 的属性自动对比,将请求值设置到指定的 JavaBean 上,并自动根据参数类型转换。
下面是一个map的小例子:
package CoreJava.day_2;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;
/**
* @author 李智
* @date 2016/12/5
*/
public class CommandUtil {
public static Object getCommand(Map requestMap,
String commandClass)
throws Exception {
Class c = Class.forName(commandClass);
Object o = c.newInstance();
return updateCommand(requestMap, o);
}
// 使用reflection自动找出要更新的属性
public static Object updateCommand(
Map requestMap,
Object command)
throws Exception {
Method[] methods =
command.getClass().getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
// 略过private、protected成员
// 且找出必须是set开头的方法
if (!Modifier.isPrivate(methods[i].getModifiers()) &&
!Modifier.isProtected(methods[i].getModifiers()) &&
methods[i].getName().startsWith("set")) {
// 取得不包括set方法
String name = methods[i].getName()
.substring(3)
.toLowerCase();
// 如果setter名称键值对相同
// 调用对应的setter并给值
if (requestMap.containsKey(name)) {
String param = (String) requestMap.get(name);
Object[] values = findOutParamValues(
param, methods[i]);
methods[i].invoke(command, values);
}
}
}
return command;
}
// 转换对应类型
private static Object[] findOutParamValues(
String param, Method method) {
Class[] params = method.getParameterTypes();
Object[] objs = new Object[params.length];
for (int i = 0; i < params.length; i++) {
if (params[i] == String.class) {
objs[i] = param;
} else if (params[i] == Short.TYPE) {
short number = Short.parseShort(param);
objs[i] = new Short(number);
} else if (params[i] == Integer.TYPE) {
int number = Integer.parseInt(param);
objs[i] = new Integer(number);
} else if (params[i] == Long.TYPE) {
long number = Long.parseLong(param);
objs[i] = new Long(number);
} else if (params[i] == Float.TYPE) {
float number = Float.parseFloat(param);
objs[i] = new Float(number);
} else if (params[i] == Double.TYPE) {
double number = Double.parseDouble(param);
objs[i] = new Double(number);
} else if (params[i] == Boolean.TYPE) {
boolean bool = Boolean.parseBoolean(param);
objs[i] = new Boolean(bool);
}
}
return objs;
}
public static void main(String[] args) throws Exception {
Map<String, String> request =
new HashMap<String, String>();
request.put("name", "caterpillar");
request.put("score", "90");
Object obj = CommandUtil.getCommand(request, args[0]);
System.out.println(obj);
}
}
CommandUtil 可以自动根据方法上的参数类型,将Map 中的value转换成相应的类型,目前它可以转换基本类型和 String。
输出:
java CommandUtilDemo CoreJava.day_2.Student
caterpillar:90
当然也可以修改成员变量,尽管直接读取类的成员属性(Field)是不被鼓励的,但我们仍是可以直接存取公共的(public)成员属性的,而我们甚至也可以通过反射机制来读取私用成员变量,以一个例子来说明:
package CoreJava.day_2;
/**
* @author 李智
* @date 2016/12/5
*/
public class TestField {
public int testInt;
public String testString;
public String toString() {
return testInt + ":" + testString;
}
}
然后利用反射机制动态的读取成员变量:
package CoreJava.day_2;
import java.lang.reflect.Field;
/**
* @author 李智
* @date 2016/12/5
*/
public class AssignFieldDemo {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
Object targetObj = c.newInstance();
Field testInt = c.getField("testInt");
testInt.setInt(targetObj, 99);
Field testString = c.getField("testString");
testString.set(targetObj, "caterpillar");
System.out.println(targetObj);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("没有指定类");
} catch (ClassNotFoundException e) {
System.out.println("找不到指定的类");
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
System.out.println("找不到指定的成员变量");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
输出:
java AssignFieldDemo CoreJava.day_2.TestField
99:caterpillar
如果有必要的话,也可以通过反射机制来读取私有的成员变量,例如:
Field privateField = c.getDeclaredField("privateField");
privateField.setAccessible(true);
privateField.setInt(targetObj, 99);
数组
在 Java 中数组也是一个对象,也会有一个 Class 实例来表示它,我们用几个基本类型和String来进行测试:
package CoreJava.day_2;
/**
* @author 李智
* @date 2016/12/5
*/
public class ArrayDemo {
public static void main(String[] args) {
short[] sArr = new short[5];
int[] iArr = new int[5];
long[] lArr = new long[5];
float[] fArr = new float[5];
double[] dArr = new double[5];
byte[] bArr = new byte[5];
boolean[] zArr = new boolean[5];
String[] strArr = new String[5];
System.out.println("short 数组:" + sArr.getClass());
System.out.println("int 数组:" + iArr.getClass());
System.out.println("long 数组:" + lArr.getClass());
System.out.println("float 数组:" + fArr.getClass());
System.out.println("double 数组:" + dArr.getClass());
System.out.println("byte 数组:" + bArr.getClass());
System.out.println("boolean 数组:" + zArr.getClass());
System.out.println("String 数组:" + strArr.getClass());
}
}
输出:
short 数组:class [S
int 数组:class [I
long 数组:class [J
float 数组:class [F
double 数组:class [D
byte 数组:class [B
boolean 数组:class [Z
String 数组:class [Ljava.lang.String;
Process finished with exit code 0
要使用反射机制动态生成数组的话,也可以这样:
package CoreJava.day_2;
import java.lang.reflect.Array;
/**
* @author 李智
* @date 2016/12/5
*/
public class NewArrayDemo {
public static void main(String[] args) {
Class c = String.class;
Object objArr = Array.newInstance(c, 5);
for (int i = 0; i < 5; i++) {
Array.set(objArr, i, i + "");
}
for (int i = 0; i < 5; i++) {
System.out.print(Array.get(objArr, i) + " ");
}
System.out.println();
String[] strs = (String[]) objArr;
for (String s : strs) {
System.out.print(s + " ");
}
}
}
Array.newInstance() 的第一个参数是指定参数类型,而第二个参数是用来指定数组长度的,结果如下:
0 1 2 3 4
0 1 2 3 4
如果是二维数组,也是一样的:
package CoreJava.day_2;
import java.lang.reflect.Array;
/**
* @author 李智
* @date 2016/12/5
*/
public class NewArrayDemo2 {
public static void main(String[] args) {
Class c = String.class;
// 打算建立一個3*4陣列
int[] dim = new int[]{3, 4};
Object objArr = Array.newInstance(c, dim);
for (int i = 0; i < 3; i++) {
Object row = Array.get(objArr, i);
for (int j = 0; j < 4; j++) {
Array.set(row, j, "" + (i + 1) * (j + 1));
}
}
for (int i = 0; i < 3; i++) {
Object row = Array.get(objArr, i);
for (int j = 0; j < 4; j++) {
System.out.print(Array.get(row, j) + " ");
}
System.out.println();
}
}
}
输出结果:
1 2 3 4
2 4 6 8
3 6 9 12
如果想要知道数组元素的类型,可以在取得数组的 Class 实例之后,使用 Class 实例的 getComponentType() 方法,所取回的是元素的 Class 实例,例如:
int[] iArr = new int[5];
System.out.println(iArr.getClass().getComponentType());
对反射的总结差不多就写到这里了,查阅了很多资料,网络上写的也是参差不齐的,在手写的几十个demo支撑下,得出的一点关于反射的东西,肯定不能说全部正确,但是还是可以提供一些帮助的 -。-