第一类怎么建立，那个太熟识了，new一下(只不过还有很多有效途径，比如说散射、反格式化、clone等，这里拿最简单的new来说)：
Dog dog = new Dog();
他们总是惯于一般来说句子的继续执行，却对于另一面的实现过程缺少知觉，而认知那个操作过程对前面艰涩艰涩的散射和全权只不过会有很大帮助，因此请亦须努力学习那块文本。
在看这首诗之前，罗嗦一句：如果你做题上面所言的业务流程等同于白看，即使现在读懂了，两个主日后呢，两个月后你又能提过多少，因为第一类建立操作过程那个习题平时的工作中基本上不会牵涉到，太下层了，复述的习题不经常予以利用容易忘却，因此我的建议是什么呢，业务流程努力做到心里约莫有特征值，当中牵涉到关键性的习题代普雷就能了。
JVM缓存
先简单说下java软件包缓存数学模型和放置文本的差别，两部分：
栈缓存 放置基本上类型统计数据和第一类的提及表达式，统计数据能直接用做访问，速度比堆快堆缓存 放置建立的第一类和字符串，会由java软件包的手动废弃物拆解来管理（GC）,建立两个第一类放进堆内的同时也会在栈中建立两个对准该第一类堆缓存中的门牌号提及表达式，上面说的第一类就是存在该缓存中上面他们就按照第一类聚合的操作过程来逐一传授参与当中操作过程的各概念
首先有这么两个类，前面的调用如前所述那个传授：
/**
* @author 炜哥
* @since 2021-04-18 11:01:41
*
* 继续执行次序：（错误率从高到低。）动态标识符块>内部结构标识符块>内部结构方法>一般方法。
* 当中动态标识符块只继续执行一次。内部结构标识符块在每天建立第一类是单厢继续执行。 */
public class Dog {
//预设小狗的最大年纪是16岁
private static int dog_max_age = 16;
//小狗的名字
private String dog_name;
{
System.out.println(“小狗的内部结构标识符块”);
}
static {
System.out.println(“小狗的动态标识符块”);
}
//无参内部结构器故意没设 //有参内部结构器
public Dog(String dog_name) {
this.dog_name = dog_name;
}
public void getDogInfo(){
System.out.println(“名字是:”+dog_name + ” 年纪：” + dog_max_age);
}
//狗叫
public static void barking(){
System.out.println(“汪汪汪~~~”);
}
}
JVM聚合.class文件
两个java文件会在编译期间被调用聚合.class字节码文件，字节码文件是专门给JVM阅读的，他们平时吭哧吭哧写的一行行标识符最终单厢被编译成机器能看懂的句子，那个文件前面会被类加载器加载到缓存。
类加载器加载.class文件
《深入认知Java的软件包》中约莫有这么一句话：在软件包遇到一条new的指令时，会去检查一遍在动态常量池中能否定位到两个类的符号提及 （就那个类的路径+名字），并且检查那个符号提及代表的类是否已被加载、导出和调用过。如果不是第一次使用，那必须先继续执行相应的类加载操作过程，那个操作过程由类加载器来完成。 类加载字面意思就能认知成加载class文件，更准确点的说法就是会把class文件变成两个二进制流加载到缓存中，即把类的描述信息加载到Metaspace，至于类加载器如何找到并把两个class文件转成IO流加载到缓存中，我前面会专门写一篇关于类加载器的文章，这里就只要认知建立第一类中有这么一步就行了。不过这里面有很重要的概念不得不讲：Class第一类
知识扩展：Class第一类
划重点，这是个非常重要的概念，认知它对于认知前面的散射和全权会有很大的帮助 类加载器 ClassLoader 加载class文件时，会把类里的一些数值常量、方法、类信息等加载到缓存中，称之为类的元统计数据，最终目的是为了聚合两个Class第一类用来描述类，那个第一类会被保存在.class文件里，可能有新手看到这里会比较懵逼，class也有第一类？当然了，Class是个实实在在的类（用来描述类的类，比较拗口），有内部结构方法（ private ，意味着能聚合第一类，但不能手动聚合，由JVM自动建立Class第一类）,类加载器会给每个java文件都建立两个Class第一类，用来描述类，我画个图：
//以下操作只能由jvm完成，他们手动做不了
Class cls1 = new Class(Dog.class.getClassLoader());
Class cls2 = new Class(Cat.class.getClassLoader());
Class cls3 = new Class(People.class.getClassLoader());
le.Class类的类，那么它里面肯定包含了所有能够描述该class的所有属性，比如说类名、方法、接口等，他们先到Class类源码中瞄一眼：
这里面有个方法 newInstance()，即建立第一类， 我把源标识符贴出来并简单导出下：
@CallerSensitive
public T newInstance()
throws InstantiationException, IllegalAccessException
{
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
}
if (cachedConstructor == null) {
if (this == Class.class) {
throw new IllegalAccessException(
“Can not call newInstance() on the Class for java.lang.Class”
);
}
try {
Class<?>[] empty = {};
//声明无参内部结构第一类
final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
// Disable accessibility checks on the constructor
// since we have to do the security check here anyway // (the stack depth is wrong for the Constructors
// security check to work) java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
c.setAccessible(true);
return null;
}
});
cachedConstructor = c;
} catch (NoSuchMethodException e) {
//如果class中没有无参内部结构方法，那么抛InstantiationException错误
throw (InstantiationException)
new InstantiationException(getName()).initCause(e);
}
}
Constructor<T> tmpConstructor = cachedConstructor;
// Security check (same as in java.lang.reflect.Constructor) int modifiers = tmpConstructor.getModifiers();
if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
if (newInstanceCallerCache != caller) {
Reflection.ensureMemberAccess(caller, this, null, modifiers);
newInstanceCallerCache = caller;
}
}
// Run constructor
try {
//最终还是调用了无参内部结构器第一类的newInstance方法
return tmpConstructor.newInstance((Object[])null);
} catch (InvocationTargetException e) {
Unsafe.getUnsafe().throwException(e.getTargetException());
// Not reached
return null;
}
}
首先搞清楚 newInstance 两种方法差别：
Class.newInstance() 只能够调用无参的内部结构函数，即预设的内部结构函数，他们在Class源码里也看到了只不过最终还是调用了无参内部结构器第一类 Constructor 的 newInstance 方法，举个栗子：Dog.class 中是没有无参内部结构方法，那么会直接抛出 InstantiationException 异常：//Dog类中只有两个dog_name的有参内部结构方法
Class c = Class.forName(“com.service.ClassAnalysis.Dog”);
Dog dog = (Dog) c.newInstance();//直接抛InstantiationException异常
Constructor.newInstance() 能根据传入的参数，调用任意构造内部结构函数，也能散射私有内部结构器（了解就行）//Dog类中只有两个dog_name的有参内部结构方法
Constructor cs = Dog.class.getConstructor(String.class);
Dog dog = (Dog) cs.newInstance(“小黑”);//继续执行没有问题
但是这里面的 newInstance跟他们这次要说的 new 方法存在差别，两者建立第一类的方式不同，建立条件也不同：
使用 newInstance 时必须要保证这类已经加载并且已经建立连接，就是已经被类记载器加载完毕，而 new 不需要class第一类的 newInstance 方法只能用无参内部结构，上面已经提到了，而 new 不需要前者使用的是类加载机制，是一种方法，后者是建立两个新类，一种关键性字那个不能说newInstance 不方便，相反它在散射、工厂设计模式、全权中发挥了重要作用，后续我也会写下全权和散射，因为认知起来确实有点绕。还有一点需要注意，不管以哪种方式建立第一类，对应的Class第一类都是同两个
Dog dog1 = new Dog(“旺财”);
Dog dog2 = new Dog(“小黑”);
Class c = Class.forName(“com.service.classload.Dog”);//为了测试，加了无参内部结构
Dog dog3 = (Dog) c.newInstance();
System.out.println(dog1.getClass() == dog2.getClass());
System.out.println(dog1.getClass() == dog3.getClass());
连接和调用
在此阶段首先为动态static表达式缓存中分配存储空间，设立初始值（还未被调用）比如说：
public static int i = 666;//被类加载器加载到缓存时会继续执行，赋予两个初始值
public static Integer ii = new Integer(666);//也被赋值两个初始值
但请注意，实际上i 的初始值是0，不是666，其他基本上统计数据类型比如说boolean的初始值就是false，以此类推。如果是提及类型的成员表达式 ii 那么初始值就是null。（对基本上统计数据类型和提及类型不熟识的能看我的另外一首诗《 java的统计数据类型&手动装箱/拆箱浅谈》，这里就不多说了）
Dog dog = new Dog(“旺财”);//在这里打个断点
继续执行，首先会继续执行动态成员表达式调用，预设值是0：
但有例外，如果加上了 final 修饰词那么初始值就是设定的值。
接着对已经分配存储空间的动态表达式真正赋值，比如说为上面的dog_max_age 赋值16，还有继续执行动态标识符块，也就是类似上面的标识符：
static {
System.out.println(“小狗的动态标识符块”);
}
到这为止，类的加载操作过程才算完成。
建立实例
在加载类完毕后，第一类的所需大小根据类信息就能确认了，具体建立的步骤如下：
先给第一类分配缓存（包括本类和父类的所有实例表达式，不包括上面的动态表达式），并设置预设值，如果有提及第一类那么会在栈缓存中申请两个空间用来对准的实际第一类。继续执行调用代码实例化，先调用父类再调用子类，赋予给定值（尊重长辈是java的传统美德）第一类实例化完毕后如果存在提及第一类的话还需要把第一步的栈第一类对准到堆缓存中的实际第一类，这样两个真正可用的第一类才被建立出来。说了这么多估计很多人都没概念，懵逼状态中，只不过很简单，他们只要读懂new的建立第一类就两步：调用和实例化，再给你们搞一张图:能简单认知②③④为调用⑤实例化（可恶，我这该死的责任感！）
本文不指望你能使劲弄懂java软件包下层加载建立第一类的操作过程（只不过有些步骤我都懒得讲了，因为说出来也都非常理论化，没多大意思），是想让你知道第一类的诞生操作过程有哪几个重要概念参与了，弄懂这些概念比起单单知道第一类建立的操作过程有意义的多：
类加载器，能找找网上的资料，蛮多的，那块文本做个了解就行Class类和Class第一类的概念，请重点掌握，不然认知散射和动态全权很费劲，spring的源码也会难以认知栈缓存和堆缓存以及对应的基本上类型和提及类型，也很重要，争取能基本上认知OVER
