Java反射

反射

需掌握获取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("苹果");
    }
}