反射、反射机制、类加载、Class类专题复习

一、反射概念

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

　　2.加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透
　　过这个镜子看到类的结构，所以，形象的称之为:反射

 

　　Java反射最大的好处就是能在运行期间，获得某个类的结构、成员变量，用来实例化。

　　而且反射是框架的灵魂，反射也是框架的底层基石，学好反射对于我们阅读框架源码也是有非常大的帮助！

 

二、反射原理图

 

三、反射相关的主要类具体使用

　　1. java.lang.Class:代表一个类，Class对象表示某 个类加载后在堆中的对象
　　2. java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
　　3. java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量
　　4. java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器

public class Dog {
    private String name;
    public int age;
    
    public Dog(){

    }
    public Dog(String name){

    }
    
    public void eat(){
        System.out.println("吃骨头");
    }

    public void call(){
        System.out.println("汪汪汪");
    }
}

public class ReflectionQuestion {
    public static void main(String[] args) throws Exception {
        //1、使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\com\\ycl\\reflection\\reflection.properties"));
        String classPath = properties.get("classPath").toString();
        String methodName = properties.get("method").toString();

        //2、创建对象 传统方法行不通 --> 反射机制
        //new classPath();

        //3、使用反射机制解决
        //(1)加载类,返回Class类型的对象
        Class aClass = Class.forName(classPath);
        //(2)通过 aClass 得到加载的类 com.ycl.reflection.Dog 的对象实例
        Object o = aClass.newInstance();

        //(3)通过 aClass 得到你加载的类 com.ycl.reflection.Dog 的 methodName "eat"的方法对象
        //java.Lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
        //即反射中，可以把方法视为对象（万物皆对象）
        Method method = aClass.getMethod(methodName);
        //(4)通过method调用方法：即通过方法对象来实现调用方法
        method.invoke(o);//传统方法 对象.方法();反射机制 方法.invoke(对象)

        //java.Lang.reflect.Field:代表类的成员变量，FieLd对象表示某个类的成员变量
        //得到name字段
        //getField 不能得到私有属性
        Field nameField = aClass.getField("age");
        Object o1 = nameField.get(o); //传统写法 对象.成员变量 ， 反射：成员变量对象.get(对象)
        System.out.println(o1);

        //java.Lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器
        Constructor constructor1 = aClass.getConstructor();//()中可以指定构造器参数类型，不写返回的是无参构造器
        Constructor constructor2 = aClass.getConstructor(String.class);//这里的String.class就是String类的Class对象

        System.out.println(constructor1);
        System.out.println(constructor2);
    }
}　

 

四、反射的优点和缺点

　　1. 优点:可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就失去底层支撑。

　　2. 缺点:使用反射基本是解释执行，对执行速度有影响

 

五、传统和反射调用方法性能比较及优化

/**
 * 测试反射调用的性能，和优化方案
 */
public class Reflection1 {
    public static void main(String[] args) throws Exception {
        m1();
        m2();
        m3();
    }
    //传统方法调用方法
    public static void m1(){
        Dog dog = new Dog();
        long s = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            dog.eat();
        }
        System.out.println("传统调用方法用时"+(System.currentTimeMillis() - s)+"毫秒");
    }

    //通过反射调用方法
    public static void m2() throws Exception {
        Class<Dog> aClass = Dog.class;
        Dog dog1 = aClass.newInstance();
        Method method = aClass.getMethod("eat");
        long s = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(dog1);//反射调用方法
        }
        System.out.println("反射调用方法用时"+(System.currentTimeMillis()-s)+"毫秒");
    }

    //反射调用优化 （关闭调用检查）
    public static void m3() throws Exception {
        Class<Dog> aClass = Dog.class;
        Dog dog1 = aClass.newInstance();
        Method method = aClass.getMethod("eat");
        method.setAccessible(true); //关闭调用检查
        long s = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(dog1);//反射调用方法
        }
        System.out.println("反射优化后调用方法用时"+(System.currentTimeMillis()-s)+"毫秒");
    }
}

 

六、Class类系统介绍

　　1. Class类特点梳理

/**
 * 对Class类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1、Class也是类，因此也继承Object类

        //2、Class类对象不是new出来的而是系统创建出来的
        //(1)传统new对象
        /* ClassLoader
           public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
           }
        */
        Dog dog = new Dog();

        //（2）反射方式
        /* ClassLoader类，仍然是通过ClassLoader类加载Class对象
         public Class<?> loadClass(String name) throws ClassNotFoundException {
            return loadClass(name, false);
         }
         */
        Class<?> aClass1 = Class.forName("com.ycl.reflection.Dog");

        //3、对于某个类的Class对象，在内存中只有一份，因为类只加载一次
        Class<?> aClass2 = Class.forName("com.ycl.reflection.Dog");
        System.out.println(aClass1.hashCode());// 81628611
        System.out.println(aClass2.hashCode());// 81628611

        //4、每个类的实例都会记得自己是由哪个 Class 实例所生成

        //5、通过Class对象可以得到一个类的完整结构，通过一系列API

        //6、Class对象是存放在堆里的

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

    }
}

 　　2. Class类常用方法

 　　代码实现

/**
 * 演示Class类的一些常用方法
 */
public class Class02 {
    public static void main(String[] args) throws Exception {
        String  classPath="com.ycl.reflection.Car";
        //1. 获取到Car类对应的Class对象
        //<?>表示不确定的Java类型
        Class<?> cls = Class.forName(classPath);
        
        //2. 输出cls
        System.out.println(cls);//显示cls对象，是哪一个类的Class对象   class com.ycl.reflection.Car
        System.out.println(cls.getClass());//输出运行类型    class java.lang.Class
        
        //3. 得到包名
        System.out.println(cls.getPackageName()); //com.ycl.reflection
        
        //4. 得到全类名
        System.out.println(cls.getName()); //com.ycl.reflection.Car
        
        //5. 通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car); //Car{band='BMW', price=500000, color='白色'}
        
        //6. 通过反射获取属性  brand
        Field brand= cls.getField("brand");
        System.out.println(brand.get(car)); //BMW
        
        //7. 通过反射给属性赋值
        brand.set(car,"奥迪");
        System.out.println(brand.get(car)); //奥迪
        
        //8. 通过反射获取所有的字段属性
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        } //  brand  price  color
    }
}

　　3. 获取class类对象的六种方法　

　　1. 前提:已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName(获取，可能抛出ClassNotFoundException, 实例: Class cls1 = Class.forName( "java.lang.Cat" );
　　　应用场景:多用于配置文件，读取类全路径，加载类.

　　2. 前提:若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高，实例: Class cls2 = Cat.class;
　　    应用场景:多用于参数传递，比如通过反射得到对应构造器对象.　

　　3. 前提:已知某个类的实例，调用该实例的getClass(方法获取Class对象，实例: Class clazz =对象.getClass(）; //运行类型
　　　应用场景:通过创建好的对象，获取Class对象.

　　4. 通过类加载器获取类的Class对象，具体实现看以下代码展示 

　　5. 基本数据(int, char,boolean,float,double,byte,long,short)按如下方式得到Class类对象，Class cls =基本数据类型.class　　

　　6.基本数据类型对应的包装类，可以通过.TYPE得到Class类对象，Class cls =包装类.TYPE

　　

　　代码实现　

/**
 * 演示获取Class对象的各种方式（6）
 */
public class GetClass_ {
    public static void main(String[] args) throws Exception {
        //1. Class.forName
        String classAllPath="com.ycl.reflection.Car";//实际运用时可以通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2. 类名.class ,应用场景：用于参数传递
        Class<Car> cls2 = Car.class;
        System.out.println(cls2);

        //3. 对象.getClass 应用场景：有对象实例
        Car car = new Car();
        Class<? extends Car> cls3 = car.getClass();
        System.out.println(cls3);

        //4. 通过类加载器【4种】，来获取到类的Class对象
        //(1)先得到类加载器 car的类加载器（类加载器是公用的）
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        // cls1  cls2  cls3  cls4  其实是同一个对象

        //5. 基本数据类型（byte、short、int、long、float、double、char、boolean）按以下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);  //int

        //6. 基本数据类型对应的包装类，可以通过.TYPE得到Class类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;

        //int 和Integer 的Class对象其实是同一个
        System.out.println(type1.hashCode());   //685325104
        System.out.println(integerClass.hashCode());   //685325104
    }
}

 　　4. 哪些类型有Class对象　　

　　1.外部类，成员内部类，静态内部类，局部内部类，匿名内部类
　　2.interface :接口
　　3.数组
　　4.enum :枚举
　　5.annotation :注解
　　6.基本数据类型
　　7.void

 七、类加载

　　1. 基本说明　　

　　反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。
　　1.静态加载:编译时加载相关的类，如果没有则报错，依赖性太强
　　2.动态加载:运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性

　　　2. 类加载时机　

　　1.当创建对象时(new)  //静态加载
　　2.当子类被加载时,父类也加载  //静态加载
　　3.调用类中的静态成员时  //静态加载
　　4.通过反射  //动态加载

　　3. 类加载流程图

　　

 　　类加载各阶段完成的任务

　　

 　　3.1 加载阶段　　

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

　　 3.2 连接阶段-验证

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

 　　 3.3 连接阶段-准备　

　　　　JVM会在该阶段对静态变量，分配内存并默认初始化(对应数据类型的默认初始值，如0、OL、null、 false等) 。这些变量所使用的内存都将在方法区中进行分配　  

class A {
    //属性-成员变量-字段
    //类加载的链接阶段-准备  属性是如何处理
    //1. n1是实例属性，不是静态变量，因此在准备阶段是不会分配內存
    //2. n2是静态变量，分配內存 n2 是默认初始化 0，而不是20
    //3. n3是static final 是常量，他和静态变量不一样，因为一旦赋值就不变了 n3 = 30
    public int n1 = 10;
    public static int n2 = 20;
    public static final int n3 = 30;
}

 　　3.4 连接阶段-解析

　　　　虚拟机将常量池内的符号引用替换为直接引用的过程

　　3.5 初始化阶段　　

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

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

 

 

 

 九、通过反射创建对象 

1.方式一:调用类中的public修饰的无参构造器
2.方式二:调用类中的指定构造器

3. Class类相关方法
　　newInstance :调用类中的无参构造器，获取对应类的对象
　　getConstructor(Class..clazz):根据参数列表，获取对应的构造器对象
　　getDecalaredConstructor(Class..clazz):根据参数列表，获取对应的构造器对象
4. Constructor类相关方法
　　setAccessible:暴破
　　newlnstance(0bjec..obj):调用构造器

/**
 * 通过反射机创建实例
 */
public class CreateNewInstance {
    public static void main(String[] args) throws Exception {
        //1、先获取到User类的Class对象
        Class<?> cls = Class.forName("com.ycl.reflection.User");

        //2、通过public的无参构造器创造实例
        Object o1 = cls.newInstance();
        System.out.println(o1); // User{age=0, name='null'}

        //3、通过public的有参构造器创建实例
        Constructor<?> constructor = cls.getConstructor(String.class);
        Object o2 = constructor.newInstance("张三");
        System.out.println(o2); //  User{age=0, name='张三'}

        //4、通过非public的有参构造器创建实例
        Constructor<?> declaredConstructor = cls.getDeclaredConstructor(int.class, String.class);
        declaredConstructor.setAccessible(true); //暴破（暴力破解），使用反射可以访问private 构造器，反射面前，都是纸老虎
        Object o3 = declaredConstructor.newInstance(20, "李四");
        System.out.println(o3);// User{age=20, name='李四'}
    }
}
class User{
    private int age;
    private String name;

    public User(){

    }

    public User(String name){ //public 有参构造
        this.name=name;
    }

    private User(int age,String name){ //private 有参构造
        this.age=age;
        this.name=name;
    }

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

十、通过反射操作属性

/**
 * 反射操作属性
 */
public class ReflectionAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        //1、得到Student类对应的Class对象
        Class<?> cls = Class.forName("com.ycl.reflection.Student");

        //2、创建对象
        Object o = cls.newInstance();
        System.out.println(o.getClass()); //class com.ycl.reflection.Student

        //3、反射得到age 属性对象
        Field age = cls.getDeclaredField("age");
        age.set(o,30); //反射设置属性
        System.out.println(o);// Student{age=30,name=null}

        //4、使用反射操作name 属性  private static
        Field name = cls.getDeclaredField("name");
        name.setAccessible(true);// 暴破
        name.set(o,"YCL");// 以为name是static所以它在类加载的时候就已经有了（所有实例都有），也可以不用指定实例对象 o-->null
        System.out.println(o);// Student{age=30,name=YCL}
        System.out.println(name.get(o));//获取属性值  YCL
        System.out.println(name.get(null));//获取属性值,要求name是static
    }
}
class Student{
    public int age;
    private static String name;

    public Student(){//构造器

    }

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

十一、通过反射调用方法

/**
 * 通过反射调用方法
 */
public class ReflectionAccessMethod {
    public static void main(String[] args) throws Exception {
        //1、得到Person类对应的Class对象
        Class<?> cls = Class.forName("com.ycl.reflection.Person");
        //2、创建对象
        Object o = cls.newInstance();
        //3、调用public的hi()
        Method hi = cls.getDeclaredMethod("hi", String.class);//获取hi()对象
        hi.invoke(o,"你好");//调用方法，设置形参

        //4、调用private static 方法
        //得到say()的对象
        Method say = cls.getDeclaredMethod("say", int.class, String.class, char.class);//获取say()对象
        say.setAccessible(true);// 暴破
        System.out.println(say.invoke(o, 2, "王五", 's')); // 2 王五 s
        System.out.println(say.invoke(null, 200, "王五", '女')); //因为他是static方法所以实例对象参数可设置为null  200 王五 女

        //5、在反射中，如果方法有返回值，统一返回Object
        Object reVal = say.invoke(null, 500, "YCL", '男');
        System.out.println(reVal);  //  500 YCL 男
    }
}
class Person{
    public int age;
    private static String name;

    public Person(){//构造器

    }

    private static String say(int n,String s,char c){//静态方法
        return n+" "+s+" "+c;
    }

    public void hi(String s){ //普通方法
        System.out.println("hi"+s);
    }

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