33_java之类加载器和反射

01类加载器

* A.类的加载
    当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
   * a 加载 
        * 就是指将class文件读入内存，并为之创建一个Class对象。
        * 任何类被使用时系统都会建立一个Class对象
    * b 连接
        * 验证 是否有正确的内部结构，并和其他类协调一致
        * 准备 负责为类的静态成员分配内存，并设置默认初始化值
        * 解析 将类的二进制数据中的符号引用替换为直接引用
    * c 初始化 
        * 就是我们以前讲过的初始化步骤（new 对象）
    * 注：简单的说就是：把.class文件加载到内存里，并把这个.class文件封装成一个Class类型的对象。
* B.类的加载时机
    以下的情况，会加载这个类。
    * a. 创建类的实例
    * b. 类的静态变量，或者为静态变量赋值
    * c. 类的静态方法
    * d. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
    * e. 初始化某个类的子类
    * f. 直接使用java.exe命令来运行某个主类
        
* C: 类加载器(了解)
    负责将.class文件加载到内在中，并为之生成对应的Class对象。
    * a. Bootstrap ClassLoader 根类加载器
        * 也被称为引导类加载器，负责Java核心类的加载
        * 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
    * b. Extension ClassLoader 扩展类加载器 * 负责JRE的扩展目录中jar包的加载。 * 在JDK中JRE的lib目录下ext目录
    * c. System ClassLoader 系统类加载器 * 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。 
* 我们用的是System ClassLoader 系统类加载器

02反射

A. 反射定义

    * a. JAVA反射机制是在运行状态中，
            对于任意一个类，都能够知道这个类的所有属性和方法；
            对于任意一个对象，都能够调用它的任意一个方法和属性；
        这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
    * b.反射技术
        条件：运行状态
        已知：一个类或一个对象(根本是已知.class文件)
        结果：得到这个类或对象的所有方法和属性
    * 注: 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

B. Class类

    * a. Class类及Class对象的了解
        要想解剖一个类，必须先了解Class对象。
        阅读API的Class类得知，Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
    * b. 得到Class对象
        * 1. 有三个方法
            方式一: 通过Object类中的getClass()方法
                Person person = new Person();
                Class clazz = person.getClass();
            方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。
                Class clazz = Person.class;
            方式三: 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。
                Class c3 = Class.forName("Person");
            注：第三种和前两种的区别是：
                    前两种你必须明确Person类型.
                    后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了
​
        * 2. 得到Class对象的三个方法代码演示：
           代码演示
            /*
             * 获取.class字节码文件对象的方式
             *      1：通过Object类中的getObject()方法
             *      2: 通过 类名.class 获取到字节码文件对象
             *      3: 反射中的方法,
             *          public static Class<?> forName(String className) throws ClassNotFoundException
             *          返回与带有给定字符串名的类或接口相关联的 Class 对象 
             */
            public class ReflectDemo {
                public static void main(String[] args) throws ClassNotFoundException {
                    // 1： 通过Object类中的getObject()方法
                    // Person p1 = new Person();
                    // Class c1 = p1.getClass();
                    // System.out.println("c1 = "+ c1);
​
                    // 2: 通过 类名.class 获取到字节码文件对象
                    // Class c2 = Person.class;
                    // System.out.println("c2 = "+ c2);
​
                    // 3: 反射中的方法
                    Class c3 = Class.forName("cn.itcast_01_Reflect.Person");// 包名.类名
                    System.out.println("c3 = " + c3);
                }
            }
 Person类 package cn.itcast_01_Reflect; 
　　　　public class Person { 
　　　　　　　　　 //成员变量
　　　　　　　　　　public int age; 

　　　　　　　　　　private String address;

　　　　　　　　　　public String name; 
　　　　　　　　　　
                //构造方法　　　　

                public Person() {
                    System.out.println("空参数构造方法");
                }
                
                public Person(String name) {
                    this.name = name;
                    System.out.println("带有String的构造方法");
                }
                //私有的构造方法
                private Person(String name, int age){
                    this.name = name;
                    this.age = age;
                    System.out.println("带有String，int的构造方法");
                }
                
                public Person(String name, int age, String address){
                    this.name = name;
                    this.age = age;
                    this.address = address;
                    System.out.println("带有String, int, String的构造方法");
                }
                
                //成员方法
                //没有返回值没有参数的方法
                public void method1(){
                    System.out.println("没有返回值没有参数的方法");
                }
                //没有返回值，有参数的方法
                public void method2(String name){
                    System.out.println("没有返回值，有参数的方法 name= "+ name);
                }
                //有返回值，没有参数
                public int method3(){
                    System.out.println("有返回值，没有参数的方法");
                    return 123;
                }
                //有返回值，有参数的方法
                public String method4(String name){
                    System.out.println("有返回值，有参数的方法");
                    return "哈哈" + name;
                }
                //私有方法
                private void method5(){
                    System.out.println("私有方法");
                }
​
                @Override
                public String toString() {
                    return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
                }
            }
        * 注: Class类型的唯一性
            因为一个.class文件在内存里只生成一个Class对象，所以无论那一种方法得到Class对象，得到的都是同一个对象

C.通过反射获取无参构造方法并使用

* a. 得到无参构造方法
        public Constructor<?>[] getConstructors() 
            获取所有的public 修饰的构造方法。
            选择无参构造方法，不建议使用。
        public Constructor<T> getConstructor(Class<?>... parameterTypes) 
            获取public修饰, 指定参数类型所对应的构造方法。
            不传参数得到无参构造方法。
* b. 运行无参构造方法
        public T newInstance(Object... initargs) 
        使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。 
        因为是无参构造，所以不传参数。
* c. 通过反射获取无参构造方法并使用的代码演示：

　　　　　　　 package cn.itcast.demo1;
            import java.lang.reflect.Constructor;
            /*
             *  通过反射获取class文件中的构造方法,运行构造方法
             *  运行构造方法,创建对象
             *    获取class文件对象
             *    从class文件对象中,获取需要的成员
             *    
             *  Constructor 描述构造方法对象类
             */
            public class ReflectDemo1 {
                public static void main(String[] args) throws Exception {              
                    Class c = Class.forName("cn.itcast.demo1.Person");
                    //使用class文件对象,获取类中的构造方法
                    //  Constructor[]  getConstructors() 获取class文件对象中的所有公共的构造方法
                    /*Constructor[] cons = c.getConstructors();
                    for(Constructor con : cons){
                        System.out.println(con);
                    }*/
                    //获取指定的构造方法,空参数的构造方法
                    Constructor con =  c.getConstructor();
                    //运行空参数构造方法,Constructor类方法 newInstance()运行获取到的构造方法
                    Object obj = con.newInstance();
                    System.out.println(obj.toString());
                }

转载于:https://www.cnblogs.com/alexzhang92/p/9972611.html