66.【注解与反射】（三）

类的加载过程:

类的加载与classLoader的理解

package com.Kuang.reflectiom;
public class Demo8 {
    public static void main(String[] args) {
        A s=new A();
        System.out.println(A.m);
    }
}
class  A{
    static {
        System.out.println("A 类静态代码初始化");
        m=300;
    }
    static int m=100;
    public A(){
        System.out.println("A 类的无参构造初始化");
    }
}

什么时候会发生类初始化?
1.类的主动引用(一定会发生类的初始化)
(1).当虚拟机启动，先初始化main方法所在的类
(2).new 一个类的对象
(3).调用类的静态成员(除了final常量)和静态方法
(4).使用reflect 的方法进行反射调用
(5).当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
"（意思就是:当我们new子类的对象的时候，父类的构造器会被先初始化）"
2.类的被动引用(不会发生类的初始化)
(1).当访问一个静态域时，只有真正声明这个域得类才会被初始化，
(2).通过数组定义类引用，不会触发此类的初始化
(3).引用常量不会触发此类的初始化

当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

package com.Kuang.reflectiom;
public class Demo9 {
    static {
        System.out.println("main类被加载!");
    }
    public static void main(String[] args)  {
        //Son son=new Son();
        //利用反射的方法
        try {
            Class.forName("com.Kuang.reflectiom.Son");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class Father{
    static int b=2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m=300;
    }
    static int m=100;
    static final int M=1;
}

1.类加载器的作用: 
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法去的运行时
数据结构，然后在堆中生成一个戴白哦这个类的class对象，作为方法区中类数据
的访问入口
2.java文件过程:
java文件--->java编译器---->字节码(.class文件)---->类装载器
----->字节码校验器----->解释器----->操作系统平台
3.类加载器的作用:
类加载器的作用是用来把类(class)装载进内存的，jvm规范定义了如下的加载器:
(1).引导类加载器: jvm自带的加载器，"负责java平台核心库"。该加载器无法直
接获取.
(2).扩展类加载器: 负责jre/lib/ext目录库下的jar包
(3).系统加载器:负责classpath或path所指目录下的jar包

package com.Kuang.reflectiom;
public class Demo10 {
    public static void main(String[] args) {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类的加载器的父类加载器---->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类  ---->跟加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        //当前类是那个加载器加载的?
        try {
            ClassLoader classLoader = Class.forName("com.Kuang.reflectiom.Demo7").getClassLoader();
            System.out.println(classLoader);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

1.获得包名+类名
System.out.println(aClass.getName());  
2.获得类名
System.out.println(aClass.getSimpleName());  
3.获得类的全部属性
aClass.getDeclaredFields()
4.获得类的public属性
aClass.getField();
5.获得本类的及父类的全部public方法
aClass.getMethods();
6.获得类的所有方法
aClass.getDeclaredMethods();
7.获得类的指定方法:
aClass.getMethod();
7.获得全部构造器:
aClass.getDeclaredConstructors();

package com.Kuang.reflectiom;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Demo11 {
    public static void main(String[] args) {
        try {
            Class<?> aClass = Class.forName("com.Kuang.reflectiom.User");
            //获得类的名字
            System.out.println(aClass.getName());  //获得包名+类名
            System.out.println(aClass.getSimpleName());  //获得类名
            //获得类的属性
            Field[] fields=aClass.getDeclaredFields();
            for (Field field : fields) {
                System.out.println(field);
            }
            System.out.println("------------------");
            //获得类的方法
            Method[] declaredMethods = aClass.getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) {
                System.out.println(declaredMethod);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}