类加载器与反射

   类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

 加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象

 连接

验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

  初始化

就是我们以前讲过的初始化步骤

   类初始化时机

1. 创建类的实例

2. 类的静态变量，或者为静态变量赋值

3. 类的静态方法

4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

5. 初始化某个类的子类

6. 直接使用java.exe命令来运行某个主类

     类加载器

 负责将.class文件加载到内存中，并为之生成对应的Class对象。

  虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行

     类加载器的组成

  Bootstrap ClassLoader 根类加载器

也被称为引导类加载器，负责Java核心类的加载

比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

Extension ClassLoader 扩展类加载器

负责JRE的扩展目录中jar包的加载。

在JDK中JRE的lib目录下ext目录

 System ClassLoader 系统类加载器

    反射

   Class类

代码演示：

public class Person {
    public String name;
    private int age;
    public Person(){
        System.out.println("公共构造方法");
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("公共有参构造");
    }
    private Person(int age,String name){
        System.out.println("私有有参构造");
    }
    public void eat(){
        System.out.println("公共方法");
    }
    public void sleep(String name){
        System.out.println(name+"公共有参方法");
    }
    private void playGames(){
        System.out.println("私有方法");
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

//获取字节码文件对象的三种方式
    public static void method1() throws ClassNotFoundException{
        //1.通过对象获取
        Person p=new Person();
        Class c=p.getClass();
        System.out.println(c);
        //2.通过类名获取
        Class c1=Person.class;
        System.out.println(c1);
        System.out.println(c==c1);
        System.out.println(c.equals(c1));
        //3.通过Class类的静态方法forName(包名.类名)获取
        Class c2=Class.forName("com.oracle.demo03.Person");
        System.out.println(c2);
    }

   通过反射获取构造方法并使用

//获取构造方法
    public static void method2() throws Exception{
        //获取字节码文件对象
        Class c=Class.forName("com.oracle.demo03.Person");
        //获取非私有构造方法数组
        /*Constructor[] cons=c.getConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }*/
    /*    //获取空参构造
        Constructor con=c.getConstructor();
        //使用空参构造创建对象
        Object obj=con.newInstance();
        Person p=(Person)obj;
        p.eat();*/
        //获取有参构造方法并调用
        /*Constructor con=c.getConstructor(String.class,int.class);
        Object obj=con.newInstance("张三",18);
        System.out.println(obj);*/
        //针对空参构造有一个快速创建对象的方式
        //1.Person类中必须有空参构造方法
        //2.空参构造方法必须是public修饰
        Object obj=c.newInstance();
        System.out.println(obj);
    }

通过反射方式，获取构造方法，创建对象

1. 获取到Class对象

2. 获取指定的构造方法

3. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)

通过反射方式，获取私有构造方法，创建对象

通过反射获取成员变量并使用

代码展示：

    //通过反射获取私有构造---暴力反射  不推荐使用
    //它破坏了我们程序的封装性、安全性
    //抢银行方式
    public static void method3()throws Exception{
        //获取字节码文件对象
        Class c=Class.forName("com.oracle.demo03.Person");
        //获取所有构造方法
        /*Constructor[] cons=c.getDeclaredConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }*/
        //获取私有构造方法并使用
        Constructor con=c.getDeclaredConstructor(int.class,String.class);
        //取消Java对我的检查
        con.setAccessible(true);
        Object obj=con.newInstance(18,"李四");
        System.out.println(obj);
    }
    public static void method4() throws Exception{
        //获取字节码文件对象
        Class c=Class.forName("com.oracle.demo03.Person");
        Object obj=c.newInstance();
        //获取公共成员变量并使用
        Field field=c.getField("name");
        field.set(obj,"张三");
        //获取私有成员变量并使用
        Field f=c.getDeclaredField("age");
        f.setAccessible(true);
        f.set(obj, 18);
        System.out.println(obj);
        //System.out.println(field.get(obj));
    }
    public static void method5() throws Exception{
        //获取字节码文件对象
        Class c=Class.forName("com.oracle.demo03.Person");
        Object obj=c.newInstance();
        //获取空参的成员方法并运行
        Method method=c.getMethod("eat");
        method.invoke(obj);
        //获取有参成员方法并运行
        Method method1=c.getMethod("sleep", String.class);
        method1.invoke(obj, "张三");
    }

    泛型擦除

反射配置文件

public class Demo {

    public static void main(String[] args) throws Exception {
        //反射配置文件实现
        //把我们要运行的类和方法以键值对的形式写在文本中
        //我们想要运行哪个类里面的方法 只需要改配置文件即可
        /*步骤：
         * 1.准备配置文件，键值对
         * 2.IO读取配置文件，Reader
         * 3.将文件中的键值对保存在Properties集合中，键值对就是类和方法名
         * 4.通过反射获取指定类的class文件对象
         * 5.通过class文件对象获取指定方法
         * 6.运行方法
         * */
        FileReader fr=new FileReader("src/config.properties");
        Properties pro=new Properties();
        pro.load(fr);
        String className=pro.getProperty("className");
        String methodName=pro.getProperty("methodName");
        Class c=Class.forName(className);
        Object obj=c.newInstance();
        Method method=c.getMethod(methodName);
        method.invoke(obj);
        
    }

配置文件：

#className=com.oracle.demo04.Person
#methodName=eat
className=com.oracle.demo04.Student
methodName=study
className=com.oracle.demo04.Worker
methodName=work