反射

反射基本介绍

反射可以通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的 ocp 原则(开闭原则：不修改源码，扩容功能)
反射机制：

反射机制允许程序在执行期借助于 ReflectionAPI 取得任何类的内部信息(比如成员变量，构造器，成员方法等)，并能操作对象的属性及方法，反射在设计模式和框架底层都会用到

加载完类之后，就在堆中产生了一个Class类型的对象(一个类中只有一个Class对象)，这个对象包含了类的完整结构信息，通过这个对象得到类的结构
反射机制可以完成：

(1)在运行时判断任意一个对象所属的类

(2)在运行时构造任意一个类的对象

(3)在运行时得到任意一个类所具有的成员变量和方法

(4)在运行时调用任意一个对象的成员变量和方法

(5)生成动态代理
反射相关的类：

(1)java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象

(2)java.lang.reflect.Method：代表类的方法

(3)java.lang.reflect.Field：代表类的成员变量

(4)java.lang.reflect.Constructor：代表类的构造方法

这些类在java.lang.reflection包中
反射可以动态的创建和使用对象，使用灵活，但使用繁盛基本是解释执行，对执行速度有影响
反射调用优化：

(1)Method 和 Field、Constructor 对象都有 setAccessible() 方法

(2)setAccessible作用是启动和禁用访问安全检查的开关

(3)参数值为true表示反射的对象在使用时取消访问检查，提高反射效率，参数值为false则表示反射的对象执行访问检查

Class类

Class类

(1)Class 也是类，因此继承 Object 类

(2)Class类对象不是 new 出来的，而是系统创建的

(3)对于某个类的 Class 类对象，在内存中只有一份，因为类只加载一次

(4)每个类的实例都会记得自己是由哪个 Class 实例所产生

(5)通过 Class 可以完整地得到一个类的完整结构，通过一系列 API

(6)Class 对象是存放在堆的

(7)类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码，变量名，方法名，访问权限等)

Class类常用方法

/**
 * 演示Class类常用方法
 */
public class ClassMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        String classAllPath = "class_.Car";
        //1.获取到Car类对应的对象
        Class<?> cls = Class.forName(classAllPath);
        System.out.println(cls);//显示cls对象  class_.Car
        System.out.println(cls.getClass());//输出cls运行类型 java.lang.Class
        //2.得到包名
        System.out.println(cls.getPackage().getName());
        //3.得到全类名
        System.out.println(cls.getName());
        //4.通过cls创建对象实例
        Object o = cls.newInstance();//可以创建的是Object对象
        Car car = (Car)cls.newInstance();//也可以创建Car对象
        System.out.println(car);//car.toString()
        //5.通过反射获取数据
        Field f = cls.getField("brand");
        System.out.println(f.get(car));//不能访问私有属性
        //6.通过反射给属性赋值
        f.set(car,"奔驰");
        System.out.println(f.get(car));
        //8.得到所有属性
        Field[] fields = cls.getFields();
        for (Field field : fields){
            System.out.println(field.getName());
        }
    }
}

获取Class对象的六种方式

/**
 * 演示得到Class对象的方式
 */
public class GetClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取
        //应用场景：多用于配置文件，读取类全路径，加载类
        String classAllPath = "class_.Car";
        Class cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2.若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高
        //应用场景：多用于参数传递，比如通过反射得到对应构造器对象
        Class cls2 = Car.class;
        System.out.println(cls2);

        //3.已知某个类的实例，调用该实例的getClass()方法获取Class对象
        //应用场景：通过创建好的对象，获取Class对象
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);

        //4.类加载器得到Class对象
        //(1)得到类加载器
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1,cls2,cls3,cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //其它方式
        //5.基本数据类型得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        System.out.println(integerClass);//输出int  底层有自动装箱和拆箱过程

        //6.基本数据类型对应的包装类，可以通过.TYPE得到Class对象
        Class<Double> type = Double.TYPE;
        System.out.println(type);//输出double
        
        Class<Integer> type1 = Integer.TYPE;

        //下面输出的hashCode是同一个
        System.out.println(integerClass.hashCode());
        System.out.println(type1.hashCode());
    }
}

哪些类型有Class对象

(1)外部类，成员内部类，静态内部类，局部内部类，匿名内部类

(2)interface：接口

(3)数组

(4)枚举

(5)annotation：注解

(6)基本数据类型

(7)void

(8)Class本身

类加载

类加载：反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载

(1)静态加载：编译时加载相关的类，如果没有则报错，依赖性太强

(2)动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
类加载时机：

(1)当创建对象时(new) (静态加载)

(2)当子类被加载时 (静态加载)

(3)调用类中的静态成员时 (静态加载)

(4)通过反射 (动态加载)
类加载阶段：

(1)加载(Loading)：

JVM在该阶段主要是将字节码从不同的数据源(可能是 class 文件、也可能是 jar 包，甚至是网络)转化为二进制字节流加载到内存中，并生成一个代表该类的 java.lang.Class对象

(2)连接阶段(Linking)：

1)验证(verification)：目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全；包括文件格式验证(是否以魔数 oxcafebabe开头)，元数据验证，字节码验证和符号引用验证；可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间

2)准备(Perparation)：JVM 会在该阶段对静态变量(由static final共同修饰的不算)，分配内存并初始化(对应数据类型的默认初始值，如0，null，false等)，这些变量所使用的内存都将在方法区中进行匹配

3)解析(Resolution)：虚拟机将常量池内的符号引用替换为直接引用的过程

(3)初始化(initialization)：到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行<clinit>()方法的过程；<clinit>()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并；虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其它线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕

反射相关操作

通过反射获取类的结构信息

public class ReflectionUtils {
    @Test
    //第一组  java.lang.Class类
    public void api_01() throws ClassNotFoundException {
        Class<?> personCls = Class.forName("reflection.Person");
        //1.得到全类名
        System.out.println(personCls.getName());//reflection.Person
        //2.得到简单类名
        System.out.println(personCls.getSimpleName());//Person
        //3.获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field :fields) {
            System.out.println(field);
        }
        //4.获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field field :declaredFields) {
            System.out.println(field.getName());
        }
        //5.获取所有public修饰的方法，包含本类以及父类的
        Method[] methods = personCls.getMethods();
        for (Method method :methods) {
            System.out.println(method.getName());
        }
        //6.获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method method :declaredMethods) {
            System.out.println(method.getName());
        }
        //7.获取所有public修饰的构造器，本类的，不包括父类
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor constructor :constructors) {
            System.out.println(constructor.getName());
        }
        //8.获取本类所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor constructor :declaredConstructors) {
            System.out.println(constructor.getName());
        }
        //9.以Package形式返回包信息
        System.out.println(personCls.getPackage());
        //10.以Class形式返回父类信息
        System.out.println(personCls.getSuperclass());
        //11.以Class[]形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class aClass :interfaces) {
            System.out.println(aClass.getName());
        }
        //12.以Annotation[]形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation :annotations) {
            System.out.println(annotation);
        }
    }

    @Test 
    public void api_02() throws ClassNotFoundException {
        Class<?> personCls = Class.forName("reflection.Person");
        //第二组  java.lang.reflect.Field类
        //获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field field :declaredFields) {
            //getName返回属性名
            //getModifiers以int形式返回修饰符
            //默认修饰符是0，public是1，private是2，protected是4，static是8，final是16
            //getType以Class形式返回类型
            System.out.println(field.getName() +
            " 该属性的修饰符值" + field.getModifiers()
            +" 该属性的类型"+field.getType());
        }

        //第三组 java.lang.reflect.Method类
        //获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method method :declaredMethods) {
            //getName返回属性名
            //getModifiers以int形式返回修饰符
            //默认修饰符是0，public是1，private是2，protected是4，static是8，final是16
            //getReturnType以Class形式返回类型
            System.out.println(method.getName() + "该方法修饰符" + method.getModifiers()
            +"该方法的类型"+method.getReturnType());

            //getParameterTypes 以Class[]形式 得到当前方法形参情况
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(parameterType);
            }
        }

        //第四组 java.lang.reflect.Constructor类
        //getName返回属性名
        //getModifiers以int形式返回修饰符
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor constructor :declaredConstructors) {
            System.out.println(constructor.getName());

            //getParameterTypes 以Class[]形式 得到当前方法形参情况
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println("构造器形参" + parameterType);
            }
        }
    }
}

class A{
    public String hobby;

    public A() { }

    public void hi(){ }
}

interface IA{}
interface IB{}

@Deprecated
class Person extends A implements IA ,IB{
    public String name;
    protected int age;
    String job;
    private double sal;

    public Person(){ }
    
    public Person(String s){ }

    private Person(String s,int i){ }

    public void m1(String name,int age){ }
    
    protected void m2(){ }
    
    void m3(){ }
    
    private void m4(){ }
}

通过反射创建对象

方式一：调用类中的public修饰的无参构造器

方式二：调用类中的指定构造器

Class类相关方法：

newInstance：调用类中的无参构造器，获取相应类的对象

getConstructor(Class…clazz)：根据参数列表，获取对应的public构造器对象

getDecalaredConstructor(Class…clazz)：根据参数列表，获取对应的所有构造器对象

Constructor类相关方法：

setAccessible：爆破

newInstance(Object…obj)：调用构造器

/**
 * 通过反射机制创建对象实例
 */

public class ReflectionCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //String classPath = "reflection.User";
        //1.先获取到User类的Class对象
        Class<?> userClass = Class.forName("reflection.User");
        //2.通过public的无参构造器创建实例
        Object o1 = userClass.newInstance();
        System.out.println(o1);
        //3.通过public的有参构造器创建实例
        Constructor<?> constructor = userClass.getConstructor(String.class);
        Object o2 = constructor.newInstance("tom");
        System.out.println(o2);
        //4.通过非public的有参构造器创建实例
        Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(int.class, String.class);
        declaredConstructor.setAccessible(true);//爆破， 使用反射可以访问private构造器
        Object o3 = declaredConstructor.newInstance(20, "mike");
        System.out.println(o3);
    }
}

class User {
    private int age = 10;
    private String name = "jack";

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    private User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

通过反射访问类中的成员

/**
 * 通过反射访问类中的成员 
 */

public class ReflectAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        //1.得到Student类对应的Class对象
        Class<?> stuClass = Class.forName("reflection.Student");
        //2.创建对象
        Object o = stuClass.newInstance();
        //3.使用反射得到age属性对象
        Field age = stuClass.getField("age");
        age.set(o,88);//通过反射操作
        System.out.println(o);
        System.out.println(age.get(o));
        //4.操作name属性
        Field name = stuClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"tom");
        //也可以 name.set(null,"tom");  因为name是static的
        System.out.println(name.get(o));
    }
}

class Student{
    public int age;
    private static String name;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age + " name=" + name+
                '}';
    }
}

通过反射访问类中的方法

/**
 * 通过反射访问类中的方法
 */

public class ReflectAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //1.得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("reflection.Boss");
        //2.创建对象
        Object o = bossCls.newInstance();
        //3.调用public方法
        Method hi = bossCls.getMethod("hi", String.class);
        //Method hi = bossCls.getDeclaredMethod("hi",String.class);也可以
        //4.调用
        hi.invoke(o, "jack");

        //调用私有方法
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        System.out.println(say.invoke(o, 5, "tom", 'A'));
        //同样因为say方法是static，o也可以改成null
        
        //注意！！！ 在反射中，如果方法有返回值，统一返回Object
    }
}

class Boss {
    public int age;
    private static String name;

    public Boss() {
    }

    private static String say(int n, String s, char c) {
        return n + " " + s + " " + c;
    }

    public void hi(String s) {
        System.out.println("hi " + s);
    }
}

【Java基础学习笔记】反射

目录

反射

反射基本介绍

Class类

类加载

反射相关操作