反射
需掌握获取Class实例,创建运行时类的对象,调用运行时类的指定结构
* 关于java.lang.Class类的理解
* 1.类的加载过程:
* 程序经过javac.exe命令以后,会生成一个或多个.class文件,接着使用java.exe命令对某个字节码文件进行解释运行
* 相当于将某个字节码文件加载到内存中,此过程就称为类的加载。加载到内存中的类,我们就称为运行时类,此运行时类,就作为Class的一个实例
*
* Class的实例对应着一个运行时类
* 加载到内存中的运行时类,会缓存一定的时间,在这段时间可以通过不同的方式来获取此运行时类
获取Class的实例的方式
public void test3() throws ClassNotFoundException {
//方式一:调用运行时类的属性
Class c = Person.class;
System.out.println(c);
//方式二:通过运行时类的对象
Person p1 = new Person();
Class c2 = p1.getClass();
System.out.println(c2);
//方式三(常用):调用Class静态方法:forName(String classPath)
Class c3 = Class.forName("Person");
System.out.println(c3);
System.out.println(c == c2);
//方式四(了解):使用类的加载器
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class c4 = classLoader.loadClass("Person");
System.out.println(c4);
}
创建运行时类的对象
* newInstance():创建对应的运行时类的对象,内部调用了运行时类的空参构造器
* 要求:1.运行时类必须提供空参构造器
* 2.要有空参构造器的访问权限,通常为public
体现反射的动态性
public void test2() throws Exception{
int num = new Random().nextInt(3);
String classPath = "";
switch (num){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "Person";
break;
}
Object obj = getInstance(classPath);
System.out.println(obj);
}
//创建一个指定类的对象,classPath:指定类的全类名
public Object getInstance(String classPath) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class c = Class.forName(classPath);
return c.newInstance();
}
调用运行时类的指定结构
操作运行时类的指定属性:
public void testField1() throws Exception, IllegalAccessException {
Class c = Person.class;
//创建运行时类的对象
Person p = (Person) c.newInstance();
//1.获取运行时类中指定变量名的属性
Field name = c.getDeclaredField("name");
//2.保证当前属性可访问
name.setAccessible(true);
//3.获取,设置指定对象的属性值
name.set(p, "qw");
System.out.println(name.get(p));
}
操作运行时类的指定方法:
public void testMethod() throws Exception{
Class c = Person.class;
Person p = (Person) c.newInstance();
//1.获取指定的某个方法:getDeclaredMethod():参数1:获取方法的名称,参数2:获取方法的形参列表
Method showNation = c.getDeclaredMethod("showNation", String.class);
//2.保证当前方法可访问
showNation.setAccessible(true);
//3.invoke():参数1:方法的调用者,参数二:给方法形参赋值的实参
//invoke()的返回值即为对应类中调用的方法的返回值
Object invokeReturn = showNation.invoke(p, "中国");
System.out.println(invokeReturn);
}
调用运行时类的指定构造器(少用):
public void test() throws Exception{
Class c = Person.class;
//获取指定构造器,参数:指明构造器的参数列表(变量类型)
Constructor constructor = c.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
//创建运行时类的对象
Person p = (Person) constructor.newInstance("asd");
System.out.println(p);
}
动态代理
interface Human{
String getBelief();
void eat(String food);
}
//被代理类
class SuperMan implements Human{
@Override
public String getBelief() {
return "Health and CEO";
}
@Override
public void eat(String food) {
System.out.println(food);
}
}
//代理类
class ProxyFactory{
//调用此方法返回一个代理类对象
public static Object getProxyInstance(Object obj){//obj:被代理类对象
MyInvocationHandler handler = new MyInvocationHandler();
handler.bind(obj);
Object o = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
return o;
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj;
public void bind(Object obj){
this.obj = obj;
}
//通过代理类对象调用方法a时,会自动调用invoke()方法
//将被代理类要执行的方法a的功能声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method:代理类和被代理类对象调用的方法
//obj:被代理类对象
Object invoke = method.invoke(obj, args);
return invoke;
}
}
public class ProxyTest {
public static void main(String[] args) {
SuperMan superMan = new SuperMan();
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan); //proxyInstance:代理类对象
//通过代理类对象调用方法时,会自动调用被代理类中同名方法
String belief = proxyInstance.getBelief();
System.out.println(belief);
proxyInstance.eat("苹果");
}
}