（JVM）在JVM中，类是如何被加载的呢？本篇文章就带你认识类加载的一套流程！

Classfile /E:/Java/学习案例/2024.5.8 总复习/第一天：JAVA基本操作/basic/target/test-classes/two/JVM/test.class
  Last modified 2024年9月2日; size 531 bytes
  MD5 checksum 2aeac6e727155f8d343cdb28e189275d
  Compiled from "test.java"
public class two.JVM.test
  minor version: 0
  major version: 61
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #21                         // two/JVM/test
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
常量池：------------------------------------------------------
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // java/lang/System.out:Ljava/io/PrintStream;
   #8 = Class              #10            // java/lang/System
   #9 = NameAndType        #11:#12        // out:Ljava/io/PrintStream;
  #10 = Utf8               java/lang/System
  #11 = Utf8               out
  #12 = Utf8               Ljava/io/PrintStream;
  #13 = String             #14            // Hello,world
  #14 = Utf8               Hello,world
  #15 = Methodref          #16.#17        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #16 = Class              #18            // java/io/PrintStream
  #17 = NameAndType        #19:#20        // println:(Ljava/lang/String;)V
  #18 = Utf8               java/io/PrintStream
  #19 = Utf8               println
  #20 = Utf8               (Ljava/lang/String;)V
  #21 = Class              #22            // two/JVM/test
  #22 = Utf8               two/JVM/test
  #23 = Utf8               Code
  #24 = Utf8               LineNumberTable
  #25 = Utf8               LocalVariableTable
  #26 = Utf8               this
  #27 = Utf8               Ltwo/JVM/test;
  #28 = Utf8               main
  #29 = Utf8               ([Ljava/lang/String;)V
  #30 = Utf8               args
  #31 = Utf8               [Ljava/lang/String;
  #32 = Utf8               SourceFile
  #33 = Utf8               test.java
常量池：------------------------------------------------------
{
  public two.JVM.test();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Ltwo/JVM/test;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
      
      主要看以下代码：#7 代表这一行代码需要去常量池中找到的地址
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         
         3: ldc           #13                 // String Hello,world
         5: invokevirtual #15                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "test.java"

/** 反编译后的执行顺序
 *          0: ldc           #7                  // String a
 *          2: astore_1
 *          3: ldc           #9                  // String b
 *          5: astore_2
 *          6: ldc           #11                 // String ab
 *
 *          8: astore_3
 *          9: aload_1
 *         10: aload_2
 *         11: invokedynamic #13,  0             // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
 *         16: astore        4
 *         18: return
 */

// stringTable[] 这是一个hashtable结构，不能扩容，当存在同一种数值就不允许重复了
public class Pool {
    // 常量池中的信息，都会加载到运行时常量池中，不过都还是常量池中的符号，只有在使用时才会把符号变为对象
    // 例如： ldc #2 这种就调用了这个符号，那么对应符号代表的信息就会被转为对象

    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        // 如上直接声明的字符串对象是会被存入stringTable中的。

        String s4 = s1+s2;// 会存储在堆中但不存在于stringTable里
        // 这种有字符串变量拼接的对象会调用makeConcatWithConstants方法，在java8版本会使用stringBuilder()进行.append()拼接。
        /** makeConcatWithConstants方法说明
         * 代码生成器有三种不同的方式来处理字符串连接表达式中的常量字符串操作数S。
         * 首先，S可以具体化为引用(使用ldc)，并作为普通参数(recipe '\1')传递。
         * 或者，S可以存储在常量池中并作为常量(配方'\2')传递。
         * 最后，如果S不包含配方标签字符('\1'，'\2')，则可以将S插入到配方本身中，从而将其字符插入到结果中。
         */

        String s5 = "a"+"b";// 底层指令会直接在常量池中寻找对应的符号，如果有相符的会直接使用对应地址创建一个新的对象
        /**
         *          6: ldc           #11                 // String ab
         *          8: astore_3
         *          9: aload_1
         *         10: aload_2
         *         11: invokedynamic #13,  0             // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
         *         16: astore        4
         *         18: ldc           #11                 // String ab
         */


//        System.out.println(s3==s4);// 两者存储地址不一样一个是内存，一个是存储中，所以为false
        System.out.println(s3==s5);// 因为两个对象本质都存储使用的同一个stringTable里的符号地址，所以为true
    }
}

public class Pool2 {
    public static void main(String[] args) {
        String x = "ab";
        /**
         * 1. new String 在stringTable中添加了 "a" "b"
         * 2. 通过拼接后转为了 s String对象（堆中）
         */
        String s = new String("a")+new String("b");// 经过了拼接后，s还处于堆中
        String s2 = s.intern();// intern 方法，将在堆中的对象尝试放入串池，如果串池中有则把串池中的对象返回
        // 经过转换 s2 = 若s存在于串池中，那么就等于串池中的字符串，如果没有则会将s放入串池中
        /**
         * intern()：如果s字符串对象已经存在于串池中，那么会返回串池中的字符串，而s字符串对象不变动
         * 如果s字符串对象不存在于串池，那么就会将s字符串对象放进串池中，并返回这个字符串
         */

        System.out.println(s=="ab");
        System.out.println(s2=="ab");
    }
}

/**
	面试题
*/
public class pool3 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a"+"b";
        String s4 = s1+s2;
        String s5 = "ab";
        String s6 = s4.intern();

        System.out.println(s3==s4);// false
        System.out.println(s3==s5);// true
        System.out.println(s3==s6);// true

        String x = new String("c")+new String("d");
        String x2 = "cd";
        String x3 = x.intern();

        System.out.println(x==x2);// false
        System.out.println(x2==x3);// true
        // 如果 17行 和 18行 调换一下位置会输出什么？输出true、true。
    }
}

import java.util.ArrayList;

/***
 * StringTable 位置
 * 测试永久代的或堆的内存溢出
 */
public class StringTablePosition {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        int j = 0;
        try
        {
            for (int i = 0; i < 260000; i++) {
                list.add(String.valueOf(i).intern());
                j++;
            }
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            System.out.println(j);
        }

    }
}

java.lang.OutOfMemoryError: Java heap space
at java.lang.Integer.toString(Integer.java:401)
at java.lang.String.valueOf(String.java:3099)
at StringTablePosition.main(StringTablePosition.java:13)

int i = 0;
try {
}catch (Throwable e){
    e.printStackTrace();
}finally {
    System.out.println(i);
}

int i = 0;
try {
    for (int j=0;j<10000;j++){
        String.valueOf(j).intern();
        i++;
    }
}catch (Throwable e){
    e.printStackTrace();
}finally {
    System.out.println(i);
}

/**
     * StringTable性能调优
     * -XX:StringTableSize=2000 -XX:+PrintStringTableStatistics
     */

try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("../demo.txt"), "utf-8"))){
    String line = null;
    long start = System.nanoTime();
    while (true){
        line = reader.readLine();
        if (line == null){
            break;
        }
        line.intern();
    }
    System.out.println("cost："+(System.nanoTime()-start)/1000000+"ms");
}

public void AdjustOptimize2() throws Exception {
    ArrayList<String> address = new ArrayList<>();
    System.in.read();

    for (int i = 0; i < 10; i++) {
        try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("../demo.txt"), "utf-8"))){
            String line = null;
            long start = System.nanoTime();
            while (true){
                line = reader.readLine();
                if (line == null){
                    break;
                }
                // 不放入StringTable放进直接堆中
                address.add(line);
            System.out.println("cost："+(System.nanoTime()-start)/1000000+"ms");
        }
    }
    System.in.read();
}

public void AdjustOptimize2() throws Exception {
    ArrayList<String> address = new ArrayList<>();
    System.in.read();

    for (int i = 0; i < 10; i++) {
        try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("E:/Java/学习案例/JVM/JVM/src/main/resources/demo.txt"), "utf-8"))){
            String line = null;
            long start = System.nanoTime();
            while (true){
                line = reader.readLine();
                if (line == null){
                    break;
                }
                // 加进StringTable池
                address.add(line.intern());
            }
            System.out.println("cost："+(System.nanoTime()-start)/1000000+"ms");
        }
    }
    System.in.read();
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 直接内存
 * ByteBuffer
 */
public class DreictMemory {
    static final String FROM = "E:\\Java\\学习案例\\JVM\\JVM\\src\\main\\resources\\b.mp4";
    static final String TO = "E:\\Java\\学习案例\\JVM\\JVM\\src\\main\\resources\\out\\a.mp4";
    static final int _1Mb = 1024 * 1024;

    public static void main(String[] args) {
        io(); // io 用时：1535.586957 1766.963399 1359.240226
        directBuffer(); // directBuffer 用时：479.295165 702.291454 562.56592
    }

    private static void directBuffer() {
        long start = System.nanoTime();
        try (FileChannel from = new FileInputStream(FROM).getChannel();
             FileChannel to = new FileOutputStream(TO).getChannel();
        ) {
            ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
            while (true) {
                int len = from.read(bb);
                if (len == -1) {
                    break;
                }
                bb.flip();
                to.write(bb);
                bb.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
    }

    private static void io() {
        long start = System.nanoTime();
        try (FileInputStream from = new FileInputStream(FROM);
             FileOutputStream to = new FileOutputStream(TO);
        ) {
            byte[] buf = new byte[_1Mb];
            while (true) {
                int len = from.read(buf);
                if (len == -1) {
                    break;
                }
                to.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("io 用时：" + (end - start) / 1000_000.0);
    }
}

static final int _100Mb = 1024 * 1024 * 100;
/**
     * 内存溢出
     */
@Test
public void test1(){
    ArrayList<ByteBuffer> list = new ArrayList<>();
    int i = 0;
    try {
        while (true) {
            ByteBuffer allocate = ByteBuffer.allocateDirect(_100Mb);
            list.add(allocate);
            i++;
        }
    }finally {
        System.out.println(i);
    }
}

static final int _1Gb = 1024 * 1024 * 1000;
/**
     * 分配与释放
     */
@Test
public void test2() throws IOException {
    ByteBuffer allocate = ByteBuffer.allocateDirect(_1Gb);
    System.out.println("分配完毕..");
    System.in.read();
    System.out.println("开始释放");
    allocate = null;
    System.gc();
}

static int _1Gb = 1024 * 1024 * 1024;

public static void main(String[] args) throws IOException {
    Unsafe unsafe = getUnsafe();
    // 分配内存
    long base = unsafe.allocateMemory(_1Gb);
    unsafe.setMemory(base, _1Gb, (byte) 0);
    System.in.read();

    // 释放内存
    unsafe.freeMemory(base);
    System.in.read();
}

public static Unsafe getUnsafe() {
    try {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        return unsafe;
    } catch (NoSuchFieldException | IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

ByteBuffer allocate = ByteBuffer.allocateDirect(_2Gb);
						↓↓↓↓
public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
}
						↓↓↓↓
	DirectByteBuffer(int cap) {                   // package-private
        super(-1, 0, cap, cap, null);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);

        long base = 0;
        try {
            // 设置直接内存空间大小
            base = UNSAFE.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        UNSAFE.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        // Cleaner虚引用，
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;

    }
			↓↓↓ 经过不同的方法，最后使用unsafe.freeMemory方法释放内存
                            
public void run() {
      if (address == 0) {
           // Paranoia
           return;
      }
      // freeMemory方法释放内存
      UNSAFE.freeMemory(address);
      address = 0;
      Bits.unreserveMemory(size, capacity);
}

package Class;

public class demo1 {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Classfile /E:/Java/test.class
  Last modified 2024年10月28日; size 411 bytes #// 最后更改日期
  MD5 checksum 1f24a99621f4aba89f176c75a621d56e #// 加密哈希值
  Compiled from "test.java" #// 编译来源
public class test #// 类名
  minor version: 0 
  major version: 55
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #5                          // test
  super_class: #6                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // 娴嬭瘯 》》 指的是“测试”字面量，字符码不是utf-8
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // test
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               test.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               娴嬭瘯
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               test
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public test();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      # // stack 栈的深度；locals 局部变量表的长度；args_size 参数的数量
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC # 作用区域
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String 娴嬭瘯
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 3: 0
        line 4: 8
}
SourceFile: "test.java"

package Class;

/**
 * 演示 字节码指令 和 操作数栈、常量池的关系
 */
public class demo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = Short.MAX_VALUE+1;
        int c = a+b;
        System.out.println(c);
    }
}

Classfile /E:/Java/demo2.class
  Last modified 2024年10月28日; size 434 bytes
  MD5 checksum 949fd83375d8625cebadfbc1cf1e19b5
  Compiled from "demo2.java"
public class Class.demo2
  minor version: 0
  major version: 55
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #6                          // Class/demo2
  super_class: #7                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #7.#16         // java/lang/Object."<init>":()V
   #2 = Class              #17            // java/lang/Short
   #3 = Integer            32768
   #4 = Fieldref           #18.#19        // java/lang/System.out:Ljava/io/PrintStream;
   #5 = Methodref          #20.#21        // java/io/PrintStream.println:(I)V
   #6 = Class              #22            // Class/demo2
   #7 = Class              #23            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               SourceFile
  #15 = Utf8               demo2.java
  #16 = NameAndType        #8:#9          // "<init>":()V
  #17 = Utf8               java/lang/Short
  #18 = Class              #24            // java/lang/System
  #19 = NameAndType        #25:#26        // out:Ljava/io/PrintStream;
  #20 = Class              #27            // java/io/PrintStream
  #21 = NameAndType        #28:#29        // println:(I)V
  #22 = Utf8               Class/demo2
  #23 = Utf8               java/lang/Object
  #24 = Utf8               java/lang/System
  #25 = Utf8               out
  #26 = Utf8               Ljava/io/PrintStream;
  #27 = Utf8               java/io/PrintStream
  #28 = Utf8               println
  #29 = Utf8               (I)V
{
  public Class.demo2();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        10
         2: istore_1
         3: ldc           #3                  // int 32768
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        13: iload_3
        14: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        17: return
      LineNumberTable:
        line 8: 0
        line 9: 3
        line 10: 6
        line 11: 10
        line 12: 17
}
SourceFile: "demo2.java"

/**
     * 从字节码角度分析a++相关题目
     */
@Test
public void test1(){
    int a = 10;
    int b = a++ + ++ a + a--;
    System.out.println(a);
    System.out.println(b);
}

Classfile /E:/Java/学习案例/JVM/JVM/src/test/java/Class/demo3.class
  Last modified 2024年10月28日; size 423 bytes
  MD5 checksum de9c94aef90c89bfe8a02cec9b7f6a9b
  Compiled from "demo3.java"
public class Class.demo3
  minor version: 0
  major version: 55
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #4                          // Class/demo3
  super_class: #5                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #5.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #17.#18        // java/io/PrintStream.println:(I)V
   #4 = Class              #19            // Class/demo3
   #5 = Class              #20            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               main
  #11 = Utf8               ([Ljava/lang/String;)V
  #12 = Utf8               SourceFile
  #13 = Utf8               demo3.java
  #14 = NameAndType        #6:#7          // "<init>":()V
  #15 = Class              #21            // java/lang/System
  #16 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;
  #17 = Class              #24            // java/io/PrintStream
  #18 = NameAndType        #25:#26        // println:(I)V
  #19 = Utf8               Class/demo3
  #20 = Utf8               java/lang/Object
  #21 = Utf8               java/lang/System
  #22 = Utf8               out
  #23 = Utf8               Ljava/io/PrintStream;
  #24 = Utf8               java/io/PrintStream
  #25 = Utf8               println
  #26 = Utf8               (I)V
{
  public Class.demo3();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: bipush        10
         2: istore_1
         3: iload_1
         4: iinc          1, 1
         7: iinc          1, 1
        10: iload_1
        11: iadd
        12: iload_1
        13: iinc          1, -1
        16: iadd
        17: istore_2
        18: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: iload_1
        22: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        25: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        28: iload_2
        29: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        32: return
      LineNumberTable:
        line 5: 0
        line 6: 3
        line 7: 18
        line 8: 25
        line 9: 32
}
SourceFile: "demo3.java"

public class demo1 {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
        ClassLoader classLoader = demo1.class.getClassLoader();
        Class<?> c = classLoader.loadClass("ClassLoad.C"); // LoadClass 它只是加载了C类，但是并没有触发解析C类中的方法，因此并不会加载D类

        new C();// 而 new 会导致C的加载并且触发解析
        System.in.read();
    }
}
class C{
    D d = new D();
}
class D{

}

package ClassLoad;

public class demo2 {
    static {
        System.out.println("main init");// main方法所在的类，总是会被首先初始化
    }

    public static void main(String[] args) throws ClassNotFoundException {
        // 访问类的static final 静态常量（基本类型和字符串）不会触发初始化
        System.out.println(B.b);

        // 类的对象.class不会触发初始化
        System.out.println(B.class);

        // 创建该类的数组不会触发初始化
        System.out.println(new B[0]);

        // 不会初始化类B，但会加载 B、A
        ClassLoader c1 = Thread.currentThread().getContextClassLoader();
        c1.loadClass("ClassLoad.B");

        // 不会初始化类B，但会加载 B、A
        ClassLoader c2 = Thread.currentThread().getContextClassLoader();
        Class.forName("ClassLoad.B",false,c2);


        // 首次访问这个类的静态变量或静态方法时
        System.out.println(A.a);

        // 子类初始化，如果父类还没初始化会触发
        System.out.println(B.c);

        // 子类访问父类的静态变量，只会触发父类的初始化
        Class.forName("ClassLoad.B");
    }
}
class A{
    static int a = 0;
    static {
        System.out.println("a init");
    }
}

class B extends A{
    final static double b = 5.0;
    static boolean c = false;
    static {
        System.out.println("b init");
    }
}

public class demo4{
    public static void main(String[] args){
        System.out.println(E.a);
        System.out.println(E.b);
        
		/**
        	E.a 和 E.b 都不会引起E类初始化，因为他们都是已经确定的值
        	而 E.c 使用的是Integer包装类，他在编译期中会有 Integer.valueOf(obj);这个操作
        	所以他会导致 E 类初始化
        */
        System.out.println(E.c);
    }
}
class E{
    public static final int a = 10;
    public static final String b = "hello";
    public static final Integer c = 20;
}

public final class Singleton{
    private Sinleton(){}
    
    // 内部类中保留单例
    private static class LazyHolder{
        static final Singleton INSTANCE = new Singleton();
    }
    // 第一次调用 getInstance方法，才会导致内部类加载和初始化其静态成员
    public static Sinleton getInstance(){
        return LazyHolder.INSTANCE;
    }
}

public class demo3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("ClassLoad.F");
        System.out.println(aClass.getClassLoader());
    }
}

package ClassLoad;

public class F {
    static {
        System.out.println("bootstrap F init");
    }
}

java -Xbootclasspath/a:. ClassLoad.demo3

bootstrap F init
null

public class demo3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("ClassLoad.F");
        System.out.println(aClass.getClassLoader());
    }
}

package ClassLoad;

public class F {
    static {
        System.out.println("bootstrap F init");
    }
}

bootstrap F init
jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先，检查该类是否已经加载完毕
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        // 如果有上级，委派上级LoadClass （ExtClassLoader）
                        c = parent.loadClass(name, false);
                    } else {
						// 没有上级(ExtClassLoader)，则委派 BootstrapClassLoader
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // 类没有找到，则从非空父类装入器
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 如果仍然没有找到，则反射findClass方法，找到这个类的加载器自己扩展
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);
					
                    // 这是定义类装入器；记录统计数据
                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

Class.forName("com.mysql.jdbc.Driver")

public class DriverManager {
        private static final CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    static{
        loadinitialDrivers();
    }

}

System.out.println(DriverManager.class.getClassLoader());

package ClassLoad;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class LoadTest {
}
class MyClassLoader extends ClassLoader {
    public static void main(String[] args) throws ClassNotFoundException {
        MyClassLoader cl = new MyClassLoader();
        /**
         * 在同一个类加载器中，加载的类并不会被重新加载（c2）
         */
        Class<?> a1 = cl.loadClass("demo1");
        Class<?> a2 = cl.loadClass("demo1");
        System.out.println(a1 == a2);

        /**
         * 而在不同类加载器中，哪怕读取的是同一个类，他们由于类加载器的不同，内存的地址也是不同的。
         */
        MyClassLoader cl2 = new MyClassLoader();
        Class<?> a3 = cl2.loadClass("demo1");
        System.out.println(a1==a3);
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String path = "E:\\Java\\学习案例\\JVM\\"+name+".class";
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            Files.copy(Paths.get(path),os);
            byte[] bytes = os.toByteArray();
            return defineClass(name, bytes, 0, bytes.length);

        } catch (IOException e) {
//            throw new RuntimeException(e);
            e.printStackTrace();
            throw new ClassNotFoundException("类文件未找到：",e);
        }

    }
}