java通常是先有类再有对象,有对象我就可以调用方法或者属性。
反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理。
如何获得Class对象:
- 通过一个对象获得完整的包名和类名
package Reflect;
/**
- 通过一个对象获得完整的包名和类名
- */
class Demo{
//other codes...
}
class hello{
public static void main(String[] args) {
Demo demo=new Demo();
System.out.println(demo.getClass().getName());
}
}
【运行结果】:Reflect.Demo
-
通过类名实例化Class类对象(两种方式)
package Reflect;
class Demo{
//other codes...
}
class hello{
public static void main(String[] args) {
Class<?> demo1=null;
Class<?> demo2=null;
Class<?> demo3=null;
try{
//一般尽量采用这种形式
demo1=Class.forName("Reflect.Demo");
}catch(Exception e){
e.printStackTrace();
}
demo2=new Demo().getClass();
demo3=Demo.class;System.out.println("类名称 "+demo1.getName()); System.out.println("类名称 "+demo2.getName()); System.out.println("类名称 "+demo3.getName());
}
}
【运行结果】:
类名称 Reflect.Demo
类名称 Reflect.Demo
类名称 Reflect.Demo
Class与Object区分:
Class是类的类类型。类类型就是指类的Class类型。
在java中类,接口,数组 ,都可以抽象称为一个Class的对象。该Class对象代表运行时的组件。并且采用了泛型的技术来表述所代表的类型。
Object是所有类的父类。
Class获取类信息的常用方法
package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import org.omg.CORBA.PUBLIC_MEMBER;
/**
- 五个函数:(public static void)
- ClassUtil.printClassMessage(Object obj);
- ClassUtil.printFieldMessage(Object obj);
- ClassUtil.printConstructorMessage(Object obj);
- ClassUtil.printInterfacesMessage(Object obj);
- ClassUtil.printSuperclassMessage(Object obj);
- @author sargeles
*/
public class ClassUtil {
/**- 打印类的信息,包括五个函数。
- @param obj
-
/
public static void printClassMessage(Object obj) {
// 要获取类的信息,首先要获取类的类类型
Class c = obj.getClass();// 传递的是哪个子类的对象,c就是该子类的类类型
// 获取类的名称
System.out.println("类的名称是:" + c.getName());
System.out.println("类的成员方法有:");
/- Method类,方法对象 一个成员方法就是一个Method对象
- getMethods()方法获取的是所有的public的方法,包括从父类继承而来的
- getDeclareMethods()获取的是所有该类自己声明的方法,不问访问权限
*/
Method[] ms = c.getMethods();
for (Method m : ms) {
// public int getModifiers()方法是公有的,可以获取修饰符信息,将其包装成一个int。
int mo = m.getModifiers();
// Modifier封装了解读带有修饰符信息的int的方法。这些方法都是静态的。可以直接用。
System.out.print(Modifier.toString(mo) + " ");
// 得到方法返回值类型的类类型
Class returnType = m.getReturnType();
System.out.print(returnType.getName() + " ");
// 得到方法的名称
System.out.print(m.getName() + "(");
// 获取参数类型--->得到的是参数列表的类型的类类型
Class[] paramTypes = m.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
if (i > 0)
System.out.print(",");
System.out.print(paramTypes[i].getName());
}
System.out.println(")");
}
}
/**
- 获取成员变量的信息(自己声明的)
- @param obj
/
public static void printFieldMessage(Object obj) {
// 要获取类的信息,首先要获取类的类类型
Class c = obj.getClass();// 传递的是哪个子类的对象,c就是该子类的类类型
System.out.println("类的名称是:" + c.getName());
System.out.println("类的成员变量有:");
/- 成员变量也是对象 java.lang.reflect.Field Field类封装了关于成员变量的操作
- getFields()方法获取的是所有public的成员变量的信息
- getDeclaredFields()获取的是该类自己声明的成员变量的信息
*/
Field[] fs = c.getDeclaredFields();
for (Field field : fs) {
// 获得成员变量的类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
// 得到成员变量的名字
String fieldName = field.getName();
System.out.println(typeName + " " + fieldName);
}
}
/**
- 获取类的构造函数信息
- @param obj
/
public static void printConstructorMessage(Object obj) {
Class c = obj.getClass();
System.out.println("类的名称是:" + c.getName());
System.out.println("类的构造函数有:");
/- 构造函数也是对象 java.lang.Constructor中封装了构造函数的信息
- getConstructors获取所有的public的构造函数 getDeclaredConstructors得到所有的构造函数
*/
Constructor[] cs = c.getDeclaredConstructors();
for (Constructor constructor : cs) {
// java.lang.Class.getModifiers()方法是公有本地的,可以获取修饰符信息,将其包装成一个int。
int mo = constructor.getModifiers();
// Modifier封装了解读带有修饰符信息的int的方法。这些方法都是静态的。可以直接用。
System.out.print(Modifier.toString(mo) + " ");
System.out.print(constructor.getName() + "(");
// 获取构造函数的参数列表--->得到的是参数列表的类类型
Class[] paramTypes = constructor.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
if (i > 0)
System.out.print(",");
System.out.print(paramTypes[i].getName());
}
System.out.println(")");
}
}
/**
- 类的接口信息
- @param obj
/
public static void printInterfacesMessage(Object obj) {
Class c = obj.getClass();
System.out.println("类的名称是:" + c.getName());
System.out.println("类实现的接口有:");
/- 接口类也是对象,因为接口也是类类型的一种,所以是Class的泛型。
*/
Class[] intes = c.getInterfaces();
for (Class classes : intes) {
// 获取每个接口的名字,然后输出。
System.out.println(classes.getName());
}
}
/**
- 接口类也是对象,因为接口也是类类型的一种,所以是Class的泛型。
- 类的父类信息
- @param obj
/
public static void printSuperclassMessage(Object obj) {
Class c = obj.getClass();
System.out.println("类的名称是:" + c.getName());
System.out.print("类的父类是:");
/- 父类只可能有一个,所以不用遍历,单根继承。
*/
Class superclass = c.getSuperclass();
System.out.println(superclass.getName());
}
}
- 父类只可能有一个,所以不用遍历,单根继承。
关于invoke的基本用法,可以看下面的例子:
public class InvokeDemo {
private String st="invoke";
int[] i={1,5,6,9,8,2};
public void add1(int a, int b) {
System.out.println(a + b);
}
public static void add2(int a, int b) {
System.out.println(a + b);
}
}
public class InvokeTest {
public static void main(String[] args) {
try {
//获取测试样例的类类型和测试实例
Class<?> c = Class.forName("reflect.InvokeDemo");
Object obj = c.newInstance();
//反射调用
Method m = c.getMethod("add1",int.class,int.class);
int[] i={1,2};
m.invoke(obj,i[1],i[0]);
//没有必要通过反射调用的static方法
InvokeDemo.add2(1, 3);
//反射修改属性
Field field = c.getDeclaredField("st")
//使得这个属性可以被修改,无论它是否是私有,甚至final。
field.setAccessible(true);
field.set(obj, "男");
System.out.println(field.get(obj));
} catch (Exception e) {
e.printStackTrace();
}
}
}
【输出】:
3
4
男
如果没有在获取Field之前调用setAccessible(true)方法,会抛出异常:
java.lang.IllegalAccessException:
Class com.test.accessible.Main
can not access
a member of class com.test.accessible.AccessibleTest
with modifiers "private"
利用反射还可以做到更多的事情:
public class InvokeTest2 {
public static void main(String[] args) {
String str = "I'm not changed!";
change(str);
System.out.println(str);
}
static void change(String str){
try {
Class<?> clazz = str.getClass();
Field field = clazz.getDeclaredField("value");
field.setAccessible(true);
Object obj = field.get(str);
char[] charValue = (char [] )obj;
charValue = new char [str.length()];
String st = "I'm changed!";
charValue = st.toCharArray();
field.set(str, charValue);
} catch (Exception e) {
e.printStackTrace();
}
}
}
这段代码违背了“java中只有副本传递”和“String类的值不可变”两个原则,可见反射真的是个很神奇也很好用的东西。但相对的,也会使代码安全性降低。