Class类，Java底层的一些事

Class类：

在Object类中定义了以下的方法，此方法将被所有子类继承

public final Class getClass()

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结构来看也很好理解，即：可以通过对象反射求出类的名称。

对象在照镜子(反射)可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息。

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个.class文件
• 每个类的实例都会记得自己是由哪个Class实例所生成
• 通过Class可以完整地得到一个类中的所有被加载的结构
• Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

class类的常用方法：

获取Class类的实例：

1. 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

Class clazz=Person.class;

2. 已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class clazz =person.getClass();

3. 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

Class clazz=Class.forName("com.demo0.Student");

4. 内置基本数据类型可以直接用类名.Type
5. 还可以利用ClassLoader

哪些类型可以有Class对象：

• class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
• interface：接口
• []：数组
• enum：枚举
• annotation：注解@interface
• primitive type：基本数据类型
• void

类加载过程：

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化：

类的加载与ClassLoader的理解：

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程

• 验证：确保加载的类信息符合JVM的规范，没有安全方面的问题
• 准备：正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
• 解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程

初始化：

• 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
• 当初始化一个类的时候，如果发现父类还没有进行初始化，则需要先触发其父类的初始化。
• 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

//类加载实例
public class Test05 {
    public static void main(String[] args) {
        A a =new A();
        System.out.println(A.m);
        /*
        1.加载到内存,会产生一个类对应Class对象
        2.链接,链接结束后m=0
        3.初始化
            <clinit>(){
                System.out.println("A类静态代码块");
                m=300;
                m=100;
            }
            因此输出结果为100，而不是300  因为静态代码块在类变量之前
            
         */
    }
}
class A{
    static {
        System.out.println("A类静态代码块");
        m=300;
    }
    static int m=100;
    public  A(){
        System.out.println("A类的无参构造初始化");
    }
}

什么时候会发生类的初始化：

类的主动引用(一定会发生类的初始化)：

• 当虚拟机启动，先初始化main方法所在的类
• new一个类的对象
• 调用类的静态成员(除了final常量)和静态方法
• 使用java.lang.reflect包的方法对类进行反射调用
• 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用(不会发生类的初始化)：

• 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
• 通过数组定义类引用，不会触发此类的初始化
• 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        // Son son =new Son();
        //2.反射也会产生主动引用
        //Class.forName("com.xue.demo.extend.Son");
        //3.不会产生类的引用的方法
        //System.out.println(Son.b);
        //4.通过数组定义类引用
        //Son[] array= new Son[5];
        //5.引用常量
        System.out.println(Son.M);
    }
}
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.主动引用
Main类被加载
父类被加载
子类被加载
2.反射也会产生主动引用
Main类被加载
父类被加载
子类被加载
===============
不会产生类的引用的方法
3.子类引用父类的静态变量
Main类被加载
父类被加载
2
4.通过数组定义类引用
Main类被加载
5.引用常量
Main类被加载
1
*/

类加载器

类加载器的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象

类加载器的分类：

1.引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台的核心库，用来装载核心类库(rt.jar)。该加载器无法直接获取

2. 扩展类加载器：负责jre/lib/ext目录下的jar包或 -D java.ext.dirs指定目录下的jar包装入工作库
3. 系统类加载器(App)：负责java -classpath 或 -D java.class.path 所指目录下的类与jar包装入工作，是最常用的加载器

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类加载器  ——————sun.misc.Launcher$AppClassLoader
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
      //获取系统类加载器的父类加载器——>扩展类  —————sun.misc.Launcher$ExtClassLoader
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类加载器——>根加载器(c/c++) 无法直接获取 ——————null
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        //测试当前类是哪个加载器加载的 ——————sun.misc.Launcher$AppClassLoader
        ClassLoader classLoader = Class.forName("com.xue.demo.extend.Test07").getClassLoader();
        System.out.println(classLoader);
        //测试JDK内置类哪个加载器加载的 ——————null
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);
        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

双亲委派机制：自定义一个包，先看一下用户类加载器中有没有，再看扩展类，最后看系统类，如果在系统类中有，则用系统类中的包，你的包并不会被使用，会报错。目的：安全机制，保证核心类库不被破坏。