一。类文件结构
类在运行之前会进行编译，变成以class结尾的文件，这类文件在被加载的时候会根据一定的约定变成一个字节码文件，其中对应的字节码和类型是：
ClassFile { u4 magic; u2 minor_version; u2 major_version; u2 constant_pool_count; cp_info constant_pool[constant_pool_count-1]; u2 access_flags; u2 this_class; u2 super_class; u2 interfaces_count; u2 interfaces[interfaces_count]; u2 fields_count; field_info fields[fields_count]; u2 methods_count; method_info methods[methods_count]; u2 attributes_count; attribute_info attributes[attributes_count]; }
真正的字节码长这样：
[root@localhost ~]# od -t xC HelloWorld.class 0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07 0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63 0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63 0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f 0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16 0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13 0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61 0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46 0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64 0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e 0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64 0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74 0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61 0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61 0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f 0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76 0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01 0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01 0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00 0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00 0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00 0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00 0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a 0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b 0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00 0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00 0001120 00 00 02 00 14
1.魔数
魔数时直是否是class类型的文件，占据开头的0-3字节，cafebabe
2.版本
如上面所说，minor和major版本，占4-7字节部分。
3.常量池
常量池包括常量池计数（8-9字节）。
常量池：
1.字面量：也就是语义层面的常量，像int，string之类的，或者fiinal修饰的常量
2.符号引用：
1.包名的引用
2.类名，接口，全限定类名的引用
3.字段名，字段描述符，引用
4.方法名，方法描述符，引用
4.类访问标志
表示该类是一个公共类或是私有类
5.本类引用
表示本类的全限定名
6。父类引用
表示父类的全限定名
7.接口计数
8.接口表 interface_info
9.字段计数
10.字段表 field_info
1.字段名
2.字段描述符
3.访问标志 如volatile
11.方法计数
12.方法表 method_info
init
cinit
1.方法名
2.方法描述符
3.访问标志 syncronized
code:
1.方法字节码指令
2.局部变量表
3.操作数栈深度
二。编译期处理
1.默认构造器
在编译的时候如果类本身没有任何构造器，会给类自动一个无参构造器。
2.自动拆装箱
3.泛型集合取值
在jdk5之后，编译时会进行泛型擦除，也就是所有泛型的信息都消失了，所有的类都当成object来处理
public class Candy3 { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(10); // 实际调用的是 List.add(Object e) Integer x = list.get(0); // 实际调用的是 Object obj = List.get(int index); } }
所以在取值时，编译器真正生成的字节码中，还要额外做一个类型转换的操作：
// 需要将 Object 转为 Integer Integer x = (Integer)list.get(0);
还好这些麻烦事都不用自己做。编译器虽然擦除了泛型，但LocalVariableTypeTable保留了信息，在返回参数时会自动转化。
使用反射可以获取泛型信息。
4.可变参数
可变参数 String... args 其实是一个 String[] args
public class Candy4 { public static void foo(String... args) { String[] array = args; // 直接赋值 System.out.println(array); } public static void main(String[] args) { foo("hello", "world"); } }
它等价于
public class Candy4 { public static void foo(String[] args) { String[] array = args; // 直接赋值 System.out.println(array); } public static void main(String[] args) { foo(new String[]{"hello", "world"}); }
5.foreach循环
加强循环会被优化成普通循环
但集合的循环会被优化成迭代器。
6.switch字符串
对于这种优化会先判断字符串的hashcode和值，再运行其中的代码
7.try-with-resources
再jdk7以后，卸载try中的句柄都会被自动close。
8.方法重写时的桥接方法
如果子类返回值可以是父类返回值的子类，则会产生如下变化
class A { public Number m() { return 1; } } class B extends A { @Override // 子类 m 方法的返回值是 Integer 是父类 m 方法返回值 Number 的子类 public Integer m() { return 2; } }
变成：
class B extends A { public Integer m() { return 2; } // 此方法才是真正重写了父类 public Number m() 方法 public synthetic bridge Number m() { // 调用 public Integer m() return m(); } }
三。类加载过程
1。加载
1.把class二进制文件加载到方法区中
2.验证class格式文件
3.把class字节码中的静态存储结构转换为方法去中的运行时存储结构
4.在堆中生成class对象作为访问方法区该类的元信息入口
2。链接
1.验证元信息 验证java语义，
2.验证字节码
3.准备阶段 为静态字段赋值，不包括引用字段
如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶 段完成
如果 static 变量是 final 的，但属于引用类型，那么赋值也会在初始化阶段完成
4符号验证 （解析）
将常量池中的符号引用解析为直接引用，也就是将全类名符号转化成类在内存中的位置。
同样解析的还有包名，字段，方法。
3。初始化
即调用<cinit>()v方法。虚拟机会保证这个类的【构造方法】的线程安全。
初始化是懒惰的，以下情况会被初始化：
1.main 方法所在的类，总会被首先初始化
2.首次访问这个类的静态变量或静态方法时
3.子类初始化，如果父类还没初始化，会引发
4.子类访问父类的静态变量，只会触发父类的初始化
5.Class.forName
6.new 会导致初始化
不会导致初始化的情况“
1.访问类的 static final 静态常量（基本类型和字符串）不会触发初始化
2.类对象.class 不会触发初始化
3.创建该类的数组不会触发初始化
4.类加载器的 loadClass 方法
5.Class.forName 的参数 2 为 false 时
四。类加载器
类加载器有三种
1.初始化加载器 bootstrap classloader
2.扩展类加载器 extension classloader
3.应用类加载器 application classloader
类加载器遵循向上委派，向下加载的规则。
线程上下文类加载器。
我们在使用 JDBC 时，都需要加载 Driver 驱动，不知道你注意到没有，不写Class.forName("com.mysql.jdbc.Driver") 也是可以让 com.mysql.jdbc.Driver 正确加载。其中它的类加载器是bootstrap，但是却可以加载com.mysql.jdbc.Driver，这是因为其中使用了Class.forName加载，而省略了Class.forName("com.mysql.jdbc.Driver")是因为遵循了spi(Service Provider Interface)，在jar包下的 META-INF/services 包下，以接口全限定名名为文件，文件内容是实现类名称。
如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶 段完成 如果 static 变量是 final 的，但属于引用类型，那么赋值也会在初始化阶段完成