简单了解反射和代理

反射

反射允许对成员变量,成员方法和构造方法的信息进行编程访问。

1.创建对象的三种方式:

package com.itheima.MyReflect.ReflectDemo1;
​
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
        * 获取class对象的三种方式
        * 1.Class.forname("全类名")
        * 2.类名.class
        * 3.对象.getClass
        *
        * */
​
        //1.第一种方式
        Class clazz1 = Class.forName("com.itheima.MyReflect.ReflectDemo1.Student");
​
        //2.第二种方式
        Class clazz2 = Student.class;
​
        //3.第三种方式
        Student s = new Student();
        Class clazz3 = s.getClass();
​
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);
    }
}

2.反射获取构造方法

package com.itheima.MyReflect.ReflectDemo2;
​
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;
​
public class ReflectTest1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1.获取Class字节码文件对象
        Class clazz = Class.forName("com.itheima.MyReflect.ReflectDemo2.Student");
​
        //2.获取构造方法
        //获取到public修饰的构造方法
​
        Constructor[] constructors = clazz.getConstructors();
​
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
​
        //获取所有
        Constructor[] dcs = clazz.getDeclaredConstructors();
        for (Constructor dc : dcs) {
            System.out.println(dc);
        }
​
        //获取单个(空参)
        Constructor dc1 = clazz.getDeclaredConstructor();
        System.out.println(dc1);
​
        //获取单个(string参数)
        Constructor dc2 = clazz.getDeclaredConstructor(String.class);
        System.out.println(dc2);
​
        //获取单个(int参数)
        Constructor dc3 = clazz.getDeclaredConstructor(int.class);
        System.out.println(dc3);
​
        //获取权限修饰符
        Constructor dc4 = clazz.getDeclaredConstructor(String.class, int.class);
        int modifiers = dc4.getModifiers();//返回值是权限修饰符所对应的整数
        System.out.println(modifiers);
​
        //获取构造方法的参数
        Parameter[] parameters = dc4.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }
​
        //暴力反射
        //临时取消权限校验,使用private修饰的方法创建对象
        dc4.setAccessible(true);
        //强转成student类型
        Student stu1 = (Student) dc4.newInstance("张三", 23);
​
        System.out.println(stu1);
    }
}

3.反射获取成员变量

package com.itheima.MyReflect.ReflectDemo3;
​
import java.lang.reflect.Field;
​
public class ReflectTest1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //1.获取class字节码文件的对象
        Class clazz = Class.forName("com.itheima.MyReflect.ReflectDemo3.Student");
​
        //2.获取成员变量(public)
        Field[] fields = clazz.getFields();
​
        for (Field field : fields) {
            System.out.println(field);
        }
        //3.获取成员变量(全部)
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
​
        //4.获取单个成员变量
        Field gender = clazz.getField("gender");
        System.out.println(gender);
​
        //5.获取单个私有成员变量
        Field name = clazz.getDeclaredField("name");
        System.out.println(name);
​
        //获取权限修饰符(返回权限修饰符所对应的整数)
        int modifiers = name.getModifiers();
        System.out.println(modifiers);
​
        //获取成员变量的类型
        Class type = name.getType();
        System.out.println(type);
​
        //获取成员变量记录的值
        Student s = new Student("张三",23,"男");
        name.setAccessible(true);
        Object value = name.get(s);
        System.out.println(value);
​
        //修改对象里面记录的值
        name.set(s,"lisi");
        System.out.println(s);
    }
}

4.反射获取成员方法

package com.itheima.MyReflect.ReflectDemo4;
​
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
​
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.获取字节码文件对象
        Class clazz = Class.forName("com.itheima.MyReflect.ReflectDemo4.Student");
        //2.获取里面所有公共的方法对象(包含父类的公共方法)
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //3.获取所有方法对象(包括私有的,不含父类)
        Method[] dms = clazz.getDeclaredMethods();
        for (Method dm : dms) {
            System.out.println(dm);
        }
​
        //4.获取指定的单个方法
        Method m = clazz.getDeclaredMethod("eat",String.class,int.class);
        System.out.println(m);
​
​
        //5.获取修饰符
        int modifiers = m.getModifiers();
        System.out.println(modifiers);
​
        //6.获取形参
        Parameter[] parameters = m.getParameters();
​
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }
​
        //7.获取方法抛出的异常
        Class[] exceptionTypes = m.getExceptionTypes();
        for (Class exceptionType : exceptionTypes) {
            System.out.println(exceptionType);
        }
​
​
        //8.方法运行
        Student s = new Student();
        m.setAccessible(true);
        //参数一:表示方法的调用者
        //参数二表示调用方法时传递的实际参数
        String result = (String) m.invoke(s, "吃汉堡包", 24);
        System.out.println(result);
​
​
​
    }
}

总结

动态代理