reflect
1,反射机制
2,动态编译
3,动态执行javascript代码
4,动态字节码操作
动态语言:程序运行的时候仍然能够改变程序的结构或变量的类型
反射机制:
1>运行时加载,探知,使用编译期间完全未知的类
2>程序在运行状态中,可以动态加载一个只有名称的类,对于任意一个已经加载的类,都能够知道这个类的所有属性和方法,对于任何一个对象,都能够调用他的任意一个方法和属性
Class c =Class.forName(“com.bjsxt.test.User”);
3>加载完类之后,在对内存中,就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类结构信息。我们可以通过这个对象看到类结构。这个对象就像一面镜子,透过这个镜子可以看到类的结构,所以,我们成为:反射
测试各种获取java.lang.Class对象的获取方式
package study;
/**
* 测试java.lang.Class对象的获取方式
*
* @author http://blog.csdn.net/thewaiting/
*
*/
public class ReflectionDome {
public static void main(String[] args) {
String path = "study2.User";
try {
Class clazz = Class.forName(path);
System.out.println(clazz);
Class strClazz = String.class;
Class strClazz2 = path.getClass();
Class intClazz = int.class;
int[] arr01 = new int[10];
int[] arr02 = new int[30];
int[][] arr03 = new int[10]不一样
System.out.println(arr01.getClass().hashCode());//一样
System.out.println(arr02.getClass().hashCode());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
package study2;
public class User {
private int id;
private int age;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User() {
}
public User(int id, int age, String name) {
super();
this.id = id;
this.age = age;
this.name = name;
}
}
应用反射获取类的信息(类的名字,属性,方法,构造器)
package study;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 应用反射获取类的信息(类的名字,属性,方法,构造器)
*
* @author http://blog.csdn.net/thewaiting/
*
*/
public class ReflectionDome {
public static void main(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
String path = "study2.User";
try {
Class clazz = Class.forName(path);
System.out.println(clazz);
//获取包名+类名
System.out.println(clazz.getName());
//获得类名
System.out.println(clazz.getSimpleName());
//获得属性
Field[] fields=clazz.getDeclaredFields();//获得所有field
Field[] fields2 = clazz.getFields();//获得public的field
Field field = clazz.getDeclaredField("name");//获得单个
//获得方法
Method[] method = clazz.getDeclaredMethods();//获得全部方法信息
Method method2 = clazz.getDeclaredMethod("getName", null);
Method method3 = clazz.getDeclaredMethod("setName", String.class);//区分重载的方法
//获得构造器
Constructor[] constructors = clazz.getDeclaredConstructors();//获取所有构造器
Constructor constructor = clazz.getConstructor(null);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
通过反射动态的操作:构造器,方法,属性
package study;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import study2.User;
/**
* 通过反射动态的操作:构造器,方法,属性
* @author http://blog.csdn.net/thewaiting/
*
*/
public class ReflectionDome {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
String path = "study2.User";
try {
Class clazz = Class.forName(path);
// 通过动态调用构造的方法,构造方法
// 无参
User user = (User) clazz.newInstance();// 其实是调用了无参构造器
// javabean必须要有无参构造的与纳音
// 有参
Constructor<User> constructor = clazz.getDeclaredConstructor(int.class, int.class, String.class);
User user2 = constructor.newInstance(10, 21, "Tom");
// 测试
System.out.println(user2.getName());
// 通过反射调用普通方法
User user3 = (User) clazz.newInstance();
Method method = clazz.getDeclaredMethod("setName", String.class);
method.invoke(user3, "Jack");// 激活
System.out.println(user3.getName());
// 通过反射操作属性
User user4 = (User) clazz.newInstance();
Field field = clazz.getDeclaredField("name");
field.setAccessible(true);//这个属性不需要做安全检查了,可以直接访问
field.set(user4, "Amy");
System.out.println(user4.getName());
System.out.println(field.get(user4));//反射调用
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}