类的加载
类加载的三种方式
类加载的三种⽅式类加载分为动态加载和静态加载。
动态加载是从外存储器中加载类，⼀般类加载机制分析的也是动态加载。
⽽静态加载本质上是从内存中创建类的实例对象，此时类已经被加载到内存中。
⼀.静态加载通过new关键字来创建Test的实例对象。
⼆.动态加载1.通过Class.forName()来加载类，然后调⽤类的newInstance()⽅法实例化对象。
2.通过类加载器的loadClass()⽅法来加载类，然后调⽤类的newInstance()⽅法实例化对象。
这⾥有⼏个需要⽐较的地⽅：1.通过new关键字实例化类的对象和通过Class.forName()加载类是当前类加载器，即this.getClass.getClassLoader，只能在当前类路径或者导⼊的类路径下寻找类。
⽽⽤指定的classLoader来加载类可以从当前路径外寻找类，这⾥的classLoader甚⾄可以⽤户⾃定义。
2.我们知道类加载机制的三个过程主要是加载-->连接-->初始化。
Class.forName()实际调⽤的是Class.forName(className,true,this.getClass.getClassLoader)，第⼆个参数表⽰加载完后是否⽴即初始化，第三个参数即前⽂提到的表⽰是当前类加载器。
classLoader.loadClass()实际调⽤的是classLoader.loadClass(className,false)，第⼆个参数表⽰加载完成后是否连接，即⽤此⽅法加载类，加载完成后不会去初始化，⽽⽤Class.forName()加载类加载完成后可以被初始化。
所以有些类如果加载完成后需要⽴即被初始化则必须使⽤Class.forName()。
例如在加载数据库驱动时，⼀般⽤Class.forName("com.mysql.jdbc.Driver")。
这是因为该驱动有⼀个在静态代码块中注册驱动的过程，所以需要被初始化。
java 类里的loadclass用法
java 类里的loadclass用法Java中的loadClass()方法是在Class类中定义的一个方法，用于动态加载类。
在程序运行时可以根据类的全限定名来加载指定的类文件，并返回对应的Class对象。
loadClass()方法的语法如下：`public Class<?> loadClass(String name) throws ClassNotFoundException`这个方法可以在当前的ClassLoader中通过类的全限定名来加载指定的类文件。
如果找不到该类文件，则会抛出ClassNotFoundException异常。
下面将详细介绍loadClass()方法的使用以及相关概念和实例。
1. 理解Java类加载器在介绍loadClass()方法之前，先来了解一下Java类加载器。
类加载器是Java虚拟机（JVM）的一个组件，用于从文件系统、网络或其他来源加载Java类文件。
Java虚拟机通过类加载器来定位并加载类文件，将其转换为一个Class对象，并存放在方法区（即运行时数据区域之一）。
一个Java类加载器通常是由一个ClassLoader类的实例来表示的。
Java 提供了三种内置的ClassLoader：- Bootstrap ClassLoader：负责加载Java核心类库，是虚拟机的一部分，无法直接获取。
- Extension ClassLoader：负责加载Java扩展库，如javax包下的类。
- System ClassLoader：也称为Application ClassLoader，负责加载应用程序的类，可以通过ClassLoader.getSystemClassLoader()来获取。
2. 使用loadClass()方法动态加载类loadClass()方法是ClassLoader类的一个原生方法，可以通过子类来调用。
在调用loadClass()方法时，会按照ClassLoader的委派模型进行类的加载。
classloader加载原理
classloader加载原理classloader是java中一个比较重要的类加载器，每一个程序和类都会存在一个classloader，classloader有三种主要的工作：加载类的二进制字节流、连接、初始化。
一、Classloader加载机制1、首先classloader会按照特定的方式去搜索类文件，当它找到了相应的类文件之后，它会将这个类文件转换成为二进制字节流，这里涉及到编译程序，classloader会使用编译程序将源程序编译成可执行文件。
2、接下来classloader会将这些二进制字节流存储在内存中，然后classloader会连接这些字节流，这一步是它将这些字节流组装成一个完整的类文件，这里涉及到类的加载，这些加载的类可以被访问，但是它们的代码还未被执行。
3、最后classloader会初始化这些加载的类，这一步就是它将这些类的代码执行，这里classloader会执行所有类变量的初始化，同时也会执行所有静态代码块的内容，最后我们就可以得到一个完整的类文件。
二、Classloader的三种类型1、Bootstrap Classloader：它是用来加载JRE的核心类的，它的实现是C++语言，它的加载范围是从<JAVA_HOME>lib下面开始，这个类加载器不需要程序员编写任何外部类。
2、Extension Classloader：它是用来加载扩展类的，从<JAVA_HOME>libext开始加载，它继承自Bootstrap Classloader，这种类加载器也不需要程序员手动编写任何外部类。
3、Application Classloader：它是用来加载程序类的，它继承自Extension Classloader，它从ClassPath（来自系统变量或者命令行参数）所指定的路径中加载类，但是它不会加载扩展类。
三、Classloader安全机制1、安全性验证：Classloader在加载类的时候会先验证这个类文件，检查它是否符合class文件格式，其次classloader会过滤掉由它本身加载的不安全的类，这涉及到安全管理器的配置，例如：可以设置它只能加载特定的域名下的类文件。
jvm 打印类加载 参数
jvm 打印类加载参数JVM（Java虚拟机）是Java程序的运行环境，它扮演着将Java字节码转换为机器码并执行的关键角色。
在Java应用程序启动时，JVM会负责加载类并执行相应的操作。
本文将深入探讨JVM的类加载过程，并分析其中的参数。
一、类加载概述在Java中，类是代码的基本组织单元，它被封装在Java源文件中，并经过编译为字节码文件（.class）。
类加载是将字节码文件加载到JVM中并转换为可执行代码的过程。
JVM的类加载机制具有懒加载的特点，即在需要使用某个类时才会加载它。
二、类加载过程1.加载（Loading）：将字节码文件加载到JVM中，它可以通过文件系统、网络等方式获取字节码文件。
加载后的类会被存放在方法区（Method Area）中，并被分配一个唯一的类加载器实例。
2.链接（Linking）：链接分为三个阶段，包括验证（Verification）、准备（Preparation）和解析（Resolution）。
- 验证：确保字节码文件符合JVM规范，不包含安全漏洞。
- 准备：为类的静态变量分配内存，并设置默认初值。
- 解析：将符号引用转换为直接引用，以便JVM能够快速访问到类、方法和字段。
3.初始化（Initialization）：执行类的初始化代码，包括静态变量赋值和静态块的执行。
初始化是类加载过程中的最后一步，只有当类被使用时才会触发。
三、类加载参数1.-verbose:class该参数用于打印类加载的详细信息，包括类的加载、链接和初始化过程。
通过查看该输出信息，可以了解到类加载器的工作情况，以及类加载的顺序和时间等。
2.-Xbootclasspath/a:path该参数用于指定引导类加载器搜索类的路径。
在Java应用程序启动时，引导类加载器会先搜索这个路径下的类，如果找到了对应的类，则直接加载，不再使用默认的搜索路径。
这个参数可以用来加载自定义的类或者覆盖JDK中的类。
3.-Xms<size>和-Xmx<size>这两个参数用于指定JVM的初始堆大小和最大堆大小。
Java 类加载原理解析
Java类加载原理解析分类：java应用2010-07-14 14:07 55人阅读评论(0) 收藏举报Java类加载原理解析1基本信息摘要：每个java开发人员对ng.ClassNotFoundExcetpion这个异常肯定都不陌生，这背后就涉及到了java 技术体系中的类加载。
Java的类加载机制是java技术体系中比较核心的部分，虽然和大部分开发人员直接打交道不多，但是对其背后的机理有一定理解有助于排查程序中出现的类加载失败等技术问题，对理解java虚拟机的连接模型和java语言的动态性都有很大帮助。
由于关于java类加载的内容较多，所以打算分三篇文章简述一下：第一篇：java类加载原理解析第二篇：插件环境下类加载原理解析第三篇：线程上下文类加载器分类：开发技术－>J2EE标签：Java类加载类加载器双亲委派机制自定义类加载器作者：朱兴创建于2007-6-22MSN：zhu_xing@2Java虚拟机类加载器结构简述2.1JVM三种预定义类型类加载器我们首先看一下JVM预定义的三种类型类加载器，当一个JVM 启动的时候，Java 缺省开始使用如下三种类型类装入器：启动（Bootstrap）类加载器：引导类装入器是用本地代码实现的类装入器，它负责将<Java_Runtime_Home>/lib 下面的类库加载到内存中。
由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。
标准扩展（Extension）类加载器：扩展类加载器是由Sun 的ExtClassLoader（uncher$ExtClassLoader）实现的。
它负责将< Java_Runtime_Home >/lib/ext 或者由系统变量java.ext.dir 指定位置中的类库加载到内存中。
开发者可以直接使用标准扩展类加载器。
系统（System）类加载器：系统类加载器是由Sun 的AppClassLoader（uncher$AppClassLoader）实现的。
类加载的过程及各部件存放的位置
=name;
}
public void speak()
{
System.out.println(+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+country);
p.setName("lisi");
p.speak();
Person.showCountry();
}
static
{
System.out.println("StaticDemo 静态代码块2");
}
}
输出结果：
StaticDemo 静态代码块1
StaticDemo 静态代码块2
静态代码块被执行
null...0 //构造代码块
lisi...100 //speak()
country=cn //showCountry()
Person(String name,int age)
{
=name;
this.age=age;
}
static
{
System.out.println("静态代码块被执行");
}
{ System.out.println(name+"..."+age);
}
public void setName(String name)
3.将"lisi" 赋值给临时变量name。
java类加载方法
java类加载方法
Java类加载是指将Java字节码文件加载到Java虚拟机中，并将其转换为可执行的Java类的过程。
Java类加载器是用于动态加载Java类的一种机制。
Java类加载器负责查找Java类并加载它们。
Java类加载器有三种类型：启动类加载器、扩展类加载器和应用程序类加载器。
启动类加载器负责加载Java类库，扩展类加载器负责加载扩展库，而应用程序类加载器则加载应用程序中的类。
类加载过程包括加载、验证、准备和解析阶段。
加载阶段负责查找和加载类的字节码，验证阶段则验证类的字节码是否合法，准备阶段则为类的静态变量分配空间并初始化，而解析阶段则处理类之间的引用关系。
Java还支持动态类加载，这是一种在运行时加载类的机制。
动态类加载允许在程序运行时根据需要动态加载类，这有助于提高程序的灵活性和可扩展性。
动态类加载通常使用反射机制来实现。
- 1 -。
WebLogic类加载过程简述
WebLogic类加载过程王明杰20061012 19:28-21:59英文水平有限，翻译的肯定有不对的地方，欢迎指正。
希望能够各位同事在使用weblogic的过程中带来帮助。
小注：2006-10-12 下午，在weblogic中部署一个启动类，部署了近2个小时，weblogic总是提示“找不到类的异常”。
心情很是郁闷。
“大事问老婆，小事问goole”，一个字“搜”。
终于找到了WebLogic的官方文档，摘录下来，进行了翻译，终于对WebLogic的类的加载过程有了比较系统的了解。
希望该文档能够帮助和我有同样疑惑的人走出困境，共同进步！！！V ersion 0.1msn:wangmingjie_2002@官方原版（19：30开始）20061012开始WebLogic Server Application ClassloadingThe following sections provide an overview of Java classloaders, followed by details about WebLogic Server J2EE application classloading.下面的部分概况的介绍了java的类装载器，接着详细的介绍了WebLogicJ2EE应用服务器（WebLogic Server J2EE application ）的类装载过程。
▪Java Classloader Overview java类转载器综述▪WebLogic Server Application Classloader Overview WebLogic 应用服务器类装载器介绍。
▪Resolving Class References Between Modules and ApplicationsJava Classloader OverviewClassloaders are a fundamental module of the Java language. A classloader is a part of the Java virtual machine (JVM) that loads classes into memory;a classloader is responsible for finding and loading class files at run time. Every successful Java programmer needs to understand classloaders and their behavior. This section provides an overview of Java classloaders.类装载器是java语言的一个基本模块，类装载器是java虚拟机的一部分，把相应的类装载到内存中，类装载器负责在运行期间找到类并载入类。
JAVA类加载过程详解
JAVA类加载过程详解Java类加载是指将Java源文件编译成字节码文件，并将字节码文件加载到JVM中执行的过程。
Java的类加载机制具有动态性和延迟性，能够在程序运行过程中动态加载和卸载类，并且只有在首次使用时才会将类加载到内存中。
Java类加载过程主要包括以下几个步骤：1. 加载（Loading）：将类的字节码文件加载到JVM中的方法区中，并形成一个Class对象。
加载类的过程是通过类加载器完成的，Java提供了三种类加载器：启动类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）和应用类加载器（Application ClassLoader），它们之间形成了父子关系。
启动类加载器负责加载JVM自身需要的类，扩展类加载器负责加载JRE扩展目录中的类，应用类加载器负责加载用户自定义类。
类加载器之间通过委托机制来完成类的加载，即先委托父加载器进行加载，如果父加载器无法完成加载，再由子加载器自己去加载。
2. 链接（Linking）：将类的符号引用解析为直接引用，并进行校验。
符号引用是指在编译阶段通过类或接口的全限定名来引用其他类或接口，直接引用是指直接指向内存中已经加载的类的指针。
链接过程主要包括三个阶段：验证（Verification）、准备（Preparation）和解析（Resolution）。
验证：对字节码文件进行验证，确保字节码文件的正确性，比如检查魔数是否正确、类的版本是否合法、字段是否存在等。
准备：为静态字段分配内存，并初始化为默认值。
静态字段和实例字段存放在不同的内存区域，准备阶段只分配内存，不会进行初始化。
解析：将类的符号引用解析为直接引用，解析过程主要是根据类的全限定名查找类的字节码文件，并将字节码文件加载到内存中。
3. 初始化（Initialization）：对类的静态字段进行初始化，并执行静态代码块。
此时，类的字节码文件已经加载到内存中，并创建了对应的Class对象，但还未创建类的实例。
jvm加载类的原理机制
jvm加载类的原理机制好嘞，今天咱们聊聊JVM加载类的那些事儿。
说到JVM，可能有的小伙伴们会想，“这是什么东东啊？”其实呢，它就是Java的“幕后英雄”，负责把我们的Java程序变成计算机能听得懂的语言。
可别小看它，这个家伙可厉害了，就像个包罗万象的百宝箱，里面装着加载、编译、执行这些大把的功能。
那咱们今天就来扒一扒JVM是怎么加载类的，搞清楚这背后的秘密。
JVM在加载类之前，会经历一个热身的过程。
想象一下，像是运动员赛前的热身活动，首先得确定这位选手的身份。
JVM会通过类的全名，来检查这个类是否已经在它的“班级名单”上了。
就像学校里点名一样，如果发现这位同学已经来了，那就直接进教室，没什么好说的。
如果没在名单上，那就得开始一系列的查找工作。
嘿，别以为这简单，JVM就像个侦探，开始四处打听，这个类究竟在哪里，可能在本地文件系统，可能在网络上，甚至可能在一些神秘的JAR包里。
JVM就会开始它的“寻宝”之旅，像个小探险家，翻箱倒柜地寻找着这个类的字节码。
找到之后，才是真正的加载过程。
这个加载过程其实就是把类的字节码读到内存中，像个小孩子把玩具从箱子里拿出来一样，兴奋得不得了。
不过呀，JVM可不想一股脑儿把所有的玩具都拿出来。
它是个聪明的小家伙，决定只加载那些需要用到的类，这样才能省点内存，别让自己显得笨重。
不过，事情可不是那么简单。
加载类的同时，JVM还得验证一下这个类的合法性。
这就像是进门前的安检，确保没有不法分子混进来。
JVM会检查类的字节码，看看里面有没有不合规的东西。
如果发现问题，哎呀，那就得拒之门外了。
这一环节可得注意，要是有个坏家伙混进来，那可真是坏事一桩。
等到通过验证后，接下来的工作就是准备阶段。
JVM会为这个类分配一些必要的资源，像是给新生分配座位一样。
这一步非常关键，因为没有资源的支持，这个类就没办法正常发挥作用。
紧JVM会开始初始化这个类，像是给新生讲解学校规章制度一样。
这一过程包括静态变量的赋值和静态代码块的执行。
Java静态内部类的加载时机
Java静态内部类的加载时机前⾔： 在看单例模式的时候，在⽹上找帖⼦看见其中有⼀种（IoDH）实现单例的⽅式，其中⽤到了静态内部类，⽂章中有写到当jvm加载外部类的时候，并没有加载静态内部内这和之前⾃⼰想的不⼀样，特意在⽹上找了⼀些帖⼦总结⼀下。
⼀、学习前千的疑问： 稍微了解Java虚拟机内的加载过程的步骤，都很清楚，⼀个类的静态资源、⼀些常量都是在类加载的时候就被加载⾦内存中分配空间了，所以我⼀开始理所当然的以为静态内部类中的静态变量同样属于静态资源，也应该在在内加载的时候被加载，然⽽实际情况却不是这样的，带着这个问题我上⽹找了⼏篇博客查找原因。
⼆、探究的过程： 在这⾥我们直接上⼀段代码，在这⾥我们分别进⾏三次测试来：public class StaticClass {public static long OUTER_DATE = System.currentTimeMillis();static {System.out.println("外部类静态块加载时间：" + System.currentTimeMillis());}public StaticClass() {System.out.println("外部类构造函数时间：" + System.currentTimeMillis());}static class InnerStaticClass {public static long INNER_STATIC_DATE = System.currentTimeMillis();static{System.out.println("静态内部类静态块加载时间：" + System.currentTimeMillis());}}class InnerClass {public long INNER_DATE = 0;public InnerClass() {INNER_DATE = System.currentTimeMillis();}}} 1、当外部内静态变量被调⽤public static void main(String[] args) {StaticClass outer = new StaticClass();System.out.println("外部类静态变量加载时间：" + outer.OUTER_DATE);} 打印结果： 外部类静态块加载时间：1556088212487 外部类构造函数时间：1556088212487 外部类静态变量加载时间：1556088212487 从控制台打印的结果我们可以看到： 外部静态变量调⽤时，外部内进⾏了加载（注：静态代码块在类被加载时执⾏）并且执⾏了初始化操作（注：构造⽅法被调⽤），⽽静态内部类并没有被加载（注：静态内部类中的静态代码块没有执⾏），且类的加载顺序必定会在初始化的前⾯，所有看到先执⾏了静态代码块中的代码，其次执⾏了构造⽅法中的代码，完成上⾯两部后最后才打印出了静态变量 2、⾮静态内部类变量调⽤时：public static void main(String[] args) {StaticClass outer = new StaticClass();System.out.println("⾮静态内部类加载时间"+outer.new InnerClass().INNER_DATE);} 打印结果：外部类静态块加载时间：1556088682706外部类构造函数时间：1556088682706⾮静态内部类加载时间1556088682707 从控制台打印的结果我们可以看到： ⾮静态内部类变量被调⽤时的执⾏结果和外部静态变量被调⽤的结果⼀样，并且静态内部类也没有被加载，出现这种情况也在预料之中，因为⾮静态内部类的初始化不许依赖于外部类，如果想实例化⼀个⾮静态内部类，则必须先实例化外部类，所以我们就看到了上⾯的结果 3、静态内部类中的变量被调⽤时：public static void main(String[] args) {System.out.println("静态内部类加载时间："+InnerStaticClass.INNER_STATIC_DATE);} 测试结果： 外部类静态块加载时间：1556089480349 静态内部类静态块加载时间：1556089480352 静态内部类加载时间：1556089480352 从控制台打印的结果我们可以看到： 静态内部类的变量被调⽤时，我们可以看出外部类进⾏了加载（注：外部类中的静态代码块中的代码执⾏了），但是并没有被初始化（注：外部类的构造⽅法并没有执⾏），且静态内部类也完成了加载三、得出结论： 有上⾯我们进⾏的测试可以得出结论，静态内部类和⾮静态内部类⼀样，都不会因为外部内的加载⽽加载，同时静态内部类的加载不需要依附外部类，在使⽤时才加载，不过在加载静态内部类的过程中也会加载外部类。
类加载的概念
类加载的概念类加载是指将类的字节码数据从磁盘加载到内存中，并转化为方法区中的类模板的过程。
类加载是Java虚拟机进行的一个重要的执行环境准备阶段，也是Java 程序运行的基础之一。
在Java中，类加载器负责把.class文件加载进内存，以供后续程序调用。
类加载是Java运行时环境的基础，它决定了程序的运行状态和行为。
类加载的过程一般包括加载、连接和初始化三个阶段。
首先，类加载的第一个阶段是加载，在这个阶段，虚拟机通过类加载器查找并加载.class文件。
类加载器是Java虚拟机的一部分，它的主要任务是根据类名或者类的全限定名找到对应的.class文件，并将其加载到内存中。
在Java中，类加载器主要分为三种：启动类加载器、扩展类加载器和应用程序类加载器。
启动类加载器是Java虚拟机的一部分，用于加载核心类库，如ng包等。
扩展类加载器用于加载扩展库，如JDK的扩展类库。
应用程序类加载器用于加载用户自定义的类，即程序中自己编写的类。
在加载阶段，类加载器首先会检查该类是否已经加载过，如果没有加载过，则通过IO流从硬盘读取.class文件，然后将其转化为二进制数据流，最后存放在方法区中。
其次，类加载的第二个阶段是连接，包括验证、准备和解析三个步骤。
验证阶段主要是对.class文件进行验证，包括文件格式的验证、元数据的验证、字节码的验证和符号引用的验证等。
验证通过后，虚拟机会对类中的静态变量进行空间分配，并赋予默认初始值，这个过程叫做准备阶段。
在解析阶段，虚拟机将类中的符号引用转化为直接引用，即将常量池中的符号引用替换为直接引用。
连接阶段的主要任务是为了确保加载进内存的类是正确、可用的。
只有通过了连接阶段的验证、准备和解析后，类才能被正常执行。
最后，类加载的第三个阶段是初始化，即在这个阶段，虚拟机会对类进行初始化操作。
类的初始化主要是对类变量（静态变量）的赋值和执行静态代码块。
此时，虚拟机会按照程序的顺序去执行类的静态初始化语句，比如静态变量的初始化和静态代码块的执行。
类的加载cinit方法
类的加载cinit方法
在Java中，类加载过程中会调用`<cinit>`方法对类进行初始化。
`<cinit>`方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并而成。
`<cinit>`方法与类的构造器不同，类的构造器是实例初始化方法，`<cinit>`不需要显式调用父类的`<cinit>`方法，虚拟机会在调用子类的`<cinit>`方法之前，首先保证父类的`<cinit>`方法已经执行完毕。
因此，虚拟机中第一个执行`<cinit>`方法的类就是`ng.Object`。
由于父类的`<cinit>`方法会优先执行，因此变量赋值操作也会优先于子类的`<cinit>`方法。
对于类和接口来说，`<cinit>`方法不是必须的，如果一个类中没有静态代码块，也没有静态变量赋值操作，那么编译器可以不为该类生成`<cinit>`方法。
`<cinit>`方法的执行是线程安全的，多线程在执行类初始化时，只会有一个线程会执行`<cinit>`方法，其他线程会阻塞。
art 打印类加载流程
art 打印类加载流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 创建一个自定义的类加载器，继承自`ng.ClassLoader`类。
art 打印类加载流程
art 打印类加载流程Class loading in Java is a fundamental process that takes place when a class is first referenced in a running Java application. 类加载是Java 中的一个基本过程，当一个类在运行的Java应用程序中首次被引用时，就会发生这个过程。
When a class is needed for the first time, the Java Virtual Machine (JVM) will locate and load the class file into memory. 当一个类第一次被需要时，Java虚拟机（JVM）会定位并将类文件加载到内存中。
The process begins by the JVM looking for the class in the classpath, which is a list of directories and JAR files containing class files. This process starts with a class loader, which is responsible for finding and loading the class file. 这个过程始于JVM在classpath中查找类，classpath是一个包含类文件的目录和JAR文件的列表。
这个过程从一个类加载器开始，它负责查找和加载类文件。
There are three built-in class loaders in Java: the Bootstrap Class Loader, the Extension Class Loader, and the System/Application ClassLoader. 在Java中有三种内置的类加载器：Bootstrap类加载器、扩展类加载器和系统/应用程序类加载器。
java类的加载顺序（面试题）
java类的加载顺序（⾯试题）
初始化：
1. 静态属性：static 开头定义的属性
2. 静态⽅法块： static {} 圈起来的⽅法块
3. 普通属性：未带static定义的属性
4. 普通⽅法块： {} 圈起来的⽅法块
5. 构造函数：类名相同的⽅法
6. ⽅法：普通⽅法
实例化：按照上⾯的顺序，但是不重新加载静态修饰的属性以及⽅法了，因为第⼀次初始化的时候，已经被加载过了，可以直接调⽤。
直接运⾏2,3,4,5,6
普通类：
静态变量
静态代码块
普通变量
普通代码块
构造函数
继承的⼦类：
⽗类静态变量
⽗类静态代码块
⼦类静态变量
⼦类静态代码块
⽗类普通变量
⽗类普通代码块
⽗类构造函数
⼦类普通变量
⼦类普通代码块
⼦类构造函数
抽象的实现⼦类: 接⼝ - 抽线类 - 实现类
接⼝静态变量
抽象类静态变量
抽象类静态代码块
实现类静态变量
实习类静态代码块
抽象类普通变量
抽象类普通代码块
抽象类构造函数
实现类普通变量
实现类普通代码块
实现类构造函数
接⼝注意：
声明的变量都是静态变量并且是final的，所以⼦类⽆法修改，并且是固定值不会因为实例⽽变化
接⼝中能有静态⽅法，不能有普通⽅法，普通⽅法需要⽤defalut添加默认实现
接⼝中的变量必须实例化
接⼝中没有静态代码块、普通变量、普通代码块、构造函数。
类加载机制及SPI
类加载机制及SPI最近重温Java类加载及双亲委派机制，并写了⼀个SPI的例⼦从⽹上找了⼀张图⽚，对着图⽚及课堂笔记来梳理下。
⾸先java⾃带的类加载器分为BootStrapClassLoader(引导\启动类加载器)，ExtClassLoader(扩展类加载器)，AppClassLoader(应⽤程序类加载器)三种，此外还⽀持⽤户⾃⼰定义的⾃定义类加载器，加载的是⽤户⾃⼰指定的⽬录。
BootStrapClassLoader：jvm中，c++处理类加载的这套逻辑，被称为启动类加载器，是由c++编写的，在java中为null，加载的路径是Jre/lib/rt.jar, 在这个过程中会通过启动类加载器，来加载uncherHelper，并执⾏checkAndLoadMain，以及加载main函数所在的类，并启动扩展类加载器、应⽤类加载器ExtClassLoader: 扩展类加载器，加载的是Jre/lib/ext/*.jar，查看⽅式：public static void main(String[] args) {ClassLoader classLoader = ClassLoader.getSystemClassLoader().getParent();URLClassLoader urlClassLoader = (URLClassLoader) classLoader;URL[] urls = urlClassLoader.getURLs();for (URL url : urls) {System.out.println(url);}}AppClassLoader: 应⽤类加载器，加载⽤户程序的类加载器，加载的是CLASS_PATH中指定的所有jarpublic static void main(String[] args) {String[] urls = System.getProperty("java.class.path").split(":");for (String url : urls) {System.out.println(url);}System.out.println("---------------------------------------------------------");URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();URL[] urls1 = classLoader.getURLs();for (URL url : urls1) {System.out.println(url);}}双亲委派机制：类加载时，AppClassLoader 会先查看⾃⾝是否已经加载过当前class⽂件，如果加载过则直接返回，如果没有加载过，则委托他的⽗类（ExtClassLoader）尝试进⾏加载，ExtClassLoader也会先查看⾃⼰是否加载过，加载过则直接返回，没有加载过，则继续委派给BootStrapClassLoader，如果直⾄BootStrapClassLoader都没有加载过，则会AppClassLoader会尝试进⾏加载。
关于类加载的时候，static代码块中可以赋值但不能引用的问题
关于类加载的时候，static代码块中可以赋值但不能引⽤的问题关于类加载的时候，static代码块中可以赋值但不能引⽤的问题类加载过程：先看代码：class StaticTest{static {a=10;System.out.println(a);//报错：Illegal forward reference}static int a=1;public static void main(String[] args) {StaticTest staticTest = new StaticTest();}}编译不通过，报错信息说⾮法的前向引⽤，因为对于a的声明在下⾯的静态变量中，属于语法错误，jvm编译不通过。
如果去掉输出这句，变成下⾯的代码：class StaticTest{static {a=10;}static int a=1;public static void main(String[] args) {StaticTest staticTest = new StaticTest();System.out.println(a);}}输出结果为：1问题：为什么a还没有被声明就可以被赋值，为什么不报错？答：1.类加载的时候在连接阶段的准备中，做了下⾯的事情：为类的静态变量分配内存并设置默认初始值，这些变量所使⽤的内存都将在⽅法区中进⾏分配。
注意：这时候进⾏内存分配的仅包括类变量（static），⽽不包括实例变量，实例变量会在对象实例化的时候随对象⼀起分配到堆中。
这些内存都将在⽅法区中分配⾮常量（final）的静态数据类型被默认赋对应类型的零值（如0、0L、null、false等），⽽不是程序中显⽰的赋值。
准备阶段检测到了a为int，分配内存并为a赋初值0。
2.然后进⼊初始化阶段之后，对静态代码块执⾏初始化，静态变量显⽰初始化。
初始化的顺序为代码排列顺序。
如静态代码块在静态变量声明前，静态变量a在静态代码块和静态变量中分别做了赋值，则a先被静态代码块赋值，后被静态变量赋值语句赋值。
类的生命周期
类的⽣命周期类⽣命周期概况JVM为java程序提供运⾏时环境（runtime environment），管理类和对象的⽣命周期是JVM的重要⼯作之⼀。
类的⽣命周期从类被加载、连接和初始化开始到类被卸载结束。
只有当类在⽣命周期中时，才能被使⽤，⽐如调⽤类的静态⽅法或者创建类的实例。
类的加载、连接和初始化类的⽣命周期从加载、连接和初始化开始。
并且严格按照如下步骤进⾏：1. 加载：查找，并且加载类的⼆进制数据2. 连接 1. 验证：确保类被正确加载 2. 准备：为类的静态变量分配内存，并且初始化为默认值 3. 解析：把类中的符号引⽤转化为直接引⽤3. 初始化：为类的静态变量赋予正确的初始值。
加载类加载的过程如下：1. 将类对应.class⽂件中的⼆进制数据读到内存中，把它存放在运⾏时数据区的⽅法区内；2. 在堆区创建⼀个Class实例，此实例 a) 描述了⽅法区内的数据结构 b) 提供了访问类在⽅法区内数据结构的接⼝，如下图所⽰：可以简单的理解为：类加载的产品是⼀个Class类的实例。
连接连接指将已经读⼊内存的⼆进制数据合并到虚拟机的运⾏时环境中去。
包括验证、准备、解析三个步骤。
验证被加载的.class⽂件并不⼀定是java编辑器⽣成的（⽐如⿊客可以制作⾃定义结构的.class⽂件），所以jvm才需要对.class⽂件进⾏验证，保证被加载的类有正确的内部结构，并且与其他类协调⼀致。
如果jvm检查到错误，那么抛出Error对象。
以此来提⾼程序的健壮性。
准备准备阶段为类的静态变量分配内存并且赋默认值。
解析解析阶段，jvm把类的⼆进制数据中的符号引⽤替换为直接引⽤。
⽐如，dog.run();这⾏代码，run这个⽅法是被dog这个符号（变量名）引⽤，解析过程将dog这个符号替换为⼀个指针地址（直接引⽤）。
初始化执⾏指静态变量⽣命和静态代码块。
卸载当类被加载、连接、初始化后，⽣命周期就开始了，java程序可以正常使⽤该类（实例化，调⽤⽅法等），当描述此类的Class对象不可触及（触不可及为对象⽣命周期中的概念），Class对象将结束⽣命周期，此类⽅法区内的数据将被卸载，此类的⽣命周期结束。
对象在内存中实例化的过程
对象在内存中实例化的过程一、引言在计算机科学中，对象是指由属性和方法构成的实体，是面向对象编程（OOP）的核心概念之一。
在程序运行过程中，对象需要被实例化并分配内存空间，以便在内存中存储和操作。
本文将详细描述对象在内存中实例化的过程。
二、对象的定义在开始讨论对象在内存中实例化的过程之前，我们先来了解一下对象的定义。
对象是一个实实在在的实体，具有状态、行为和标识。
状态是指对象的属性值，行为是指对象的方法，标识是指对象在内存中的唯一标识。
三、对象的实例化过程1. 类的加载在实例化对象之前，首先需要将对象所属的类加载到JVM中。
类是对象的模板，定义了对象的属性和方法。
类的加载是指将类的字节码文件加载到JVM的方法区中，并进行验证、准备和解析等操作。
类加载是JVM的一个重要过程，保证了对象在内存中的正确实例化。
2. 对象的内存分配类加载完成后，JVM会为对象分配内存空间。
内存空间的分配主要有两种方式：堆上分配和栈上分配。
在面向对象编程中，大部分对象都是在堆上进行分配的。
堆是运行时数据区域，用于存储对象实例。
栈是线程私有的，用于存储局部变量和方法调用的栈帧。
当对象被分配到堆上时，JVM会为其分配一块连续的内存空间，并返回对象在堆中的引用地址。
3. 对象的初始化对象分配内存后，JVM会自动为对象的属性赋予默认值。
基本类型的属性会被赋予默认的零值，引用类型的属性会被赋予null值。
此外，JVM还会调用对象的构造方法，初始化对象的属性值。
构造方法是对象的特殊方法，用于初始化对象的状态。
4. 对象的引用对象初始化完成后，JVM会返回对象在内存中的引用地址。
引用是指对对象的间接访问，通过引用可以操作对象的属性和方法。
在Java中，引用是强类型的，需要在编译时进行类型检查。
通过引用，可以实现对象之间的关联和交互。
四、对象的生命周期对象的生命周期是指对象从被创建到被销毁的整个过程。
对象的生命周期主要包括以下几个阶段：1. 创建阶段：对象在内存中被实例化，分配内存空间，并初始化属性和方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
类从加载到虚拟机到卸载，它的整个生命周期包括：加载（Loading），验证（Validation），准备（Preparation），解析（Resolution），初始化（Initialization），使用（Using）和卸载（Unloading）。
其中，验证、准备和解析部分被称为连接（Linking）。
加载：在加载阶段，虚拟机主要完成三件事：1.通过一个类的全限定名来获取定义此类的二进制字节流。
2.将这个字节流所代表的静态存储结构转化为方法区域的运行时数据结构。
3.在Java堆中生成一个代表这个类的ng.Class对象，作为方法区域数据的访问入口。
验证：验证阶段作用是保证Class文件的字节流包含的信息符合JVM规范，不会给JVM造成危害。
如果验证失败，就会抛出一个ng.VerifyError异常或其子类异常。
验证过程分为四个阶段：1.文件格式验证：验证字节流文件是否符合Class文件格式的规范，并且能被当前虚拟机正确的处理。
2.元数据验证：是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言的规范。
3.字节码验证：主要是进行数据流和控制流的分析，保证被校验类的方法在运行时不会危害虚拟机。
4.符号引用验证：符号引用验证发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在解析阶段中发生。
准备：准备阶段为变量分配内存并设置类变量的初始化。
在这个阶段分配的仅为类的变量（static修饰的变量），而不包括类的实例变量。
对已非final的变量，JVM会将其设置成“零值”，而不是其赋值语句的值：pirvate static int size = 12;那么在这个阶段，size的值为0，而不是12。
final修饰的类变量将会赋值成真实的值。
解析：解析过程是将常量池内的符号引用替换成直接引用。
主要包括四种类型引用的解析。
类或接口的解析、字段解析、方法解析、接口方法解析。
初始化：在准备阶段，类变量已经经过一次初始化了，在这个阶段，则是根据程序员通过程序制定的计划去初始化类的变量和其他资源。
这些资源有static{}块，构造函数，父类的初始化等。
至于使用和卸载阶段阶段，这里不再过多说明，使用过程就是根据程序定义的行为执行，卸载由GC完成。
都是父类先执行<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）再执行构造方法虚拟机类加载机制：虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。
Java语言里，类型的加载和连接过程是在程序运行期间完成的。
类的生命周期：加载loading验证verification准备preparation解析resolution初始化initialization使用using卸载unloading有且只有以下四种情况必须立即对类进行”初始化”(称为对一个类进行主动引用)：1.遇到new、getstatic、putstatic、invokestatic这四条字节码指令时(使用new实例化对象的时候、读取或设置一个类的静态字段、调用一个类的静态方法)。
2.使用ng.reflet包的方法对类进行反射调用的时候。
3.当初始化一个类的时候，如果发现其负类没有进行过初始化，则需要先触发其父类的初始化。
4.当虚拟机启动时，虚拟机会初始化主类(包含main方法的那个类)。
被动引用：1.通过子类引用父类的静态字段，不会导致子类初始化(对于静态字段，只有直接定义这个字段的类才会被初始化)。
2.通过数组定义类应用类：ClassA [] array=new ClassA[10]。
触发了一个名为[LClassA的类的初始化，它是一个由虚拟机自动生成的、直接继承于Object的类，创建动作由字节码指令newarray触发。
3.常量会在编译阶段存入调用类的常量池。
编译器会为接口生成<clinit>()构造器，用于初始化接口中定义的成员变量。
一个接口在初始化时，并不要求其父类接口全部完成了初始化，只有在真正使用到父接口的时候才会初始化。
1. 加载1.通过一个类的全限定名来获取此类的二进制字节流。
2.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3.在java堆中生成一个代表这个类的Class对象，作为方法区这些数据的访问入口。
2. 验证验证：确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
虚拟机规范：如果验证到输入的字节流不符合Class文件的存储格式，就抛出一个ng.VerifyError异常或其子类异常。
1.文件格式验证：验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。
这个阶段的验证时给予字节流进行的，经过了这个阶段的验证之后，字节流才会进入内存的方法区中进行存储所以后面的验证阶段都是给予方法区的存储结构进行的。
2.元数据验证：对类的元数据信息进行语义校验，保证不存在不符合java语言规范的元数据信息。
3.字节码验证：进行数据流和控制流分析，对类的方法体进行校验分析，保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。
4.符号引用验证：发生在虚拟机将符号引用转化为直接引用的时候(解析阶段)，对常量池中的各种符号引用的信息进行匹配性的校验。
3. 准备准备阶段是正式为类变量分配内存并设置类变量初始值(各数据类型的零值)的阶段，这些内存将在方法区中进行分配。
但是如果类字段的字段属性表中存在ConstantValue属性，那在准备阶段变量值就会初始化为ConstantValue属性指定的值。
public static final int value=122;4. 解析解析阶段是在虚拟机将常量池内的符号引用替换为直接引用的过程。
符号引用：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。
符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中。
直接引用：直接引用可以是直接指向目标的指针、相对偏移量或者一个能间接定位到目标的句柄。
如果有了直接引用，那引用的目标必定已经在内存中存在。
A. 类或接口(对应于常量池的CONSTANT_Class_info类型)的解析：假设当前代码所处的类为D，需要将一个从未解析过的符号引用N解析为一个类或接口C的直接引用：1.如果C不是一个数组类型，虚拟机将会把代表C的全限定名传递给D的类加载器去加载这个类。
2.如果C是一个数组类型，并且数组的元素类型为对象(N的描述符类似[ng.Integer)，将会加载数组元素类型(ng.Integer)，接着由虚拟机生成一个代表此数组维度和元素的数组对象。
3.如果以上过程没有发生异常，则C在虚拟机中已经成为了一个有效的类和接口了，之后还要进行的是符号引用验证，确认D是否具有对C的访问权限，如果没有，将抛出ng.IllegalAccessError异常。
B. 字段(对应于常量池的CONSTANT_Fieldref_info类型)解析：1.对字段表中的class_index项中索引的CONSTANT_Class_info符号引用进行解析。
用C表示这个字段所属的类或接口。
2.如果C本身就包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用。
3.否则，如果C实现了接口，则会按照继承关系从下往上递归搜索各个接口和他的父接口，如果接口中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用。
4.否则，如果C不是ng.Object类型的话，将会按照继承关系从下往上递归的搜索其父类，如果在父类中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用。
5.否则，查找失败，抛出ng.NoSuchFieldError异常。
虚拟机的编译器实现可能会更严格：如果一个同名字段同时出现在C实现的接口和父类中，或者同时在自己或父类的多个接口中出现，编译器将可能拒绝编译。
C. 类方法(对应于常量池的CONSTANT_Methodref_info类型)解析：1.对方法表中的class_index项中索引的CONSTANT_Class_info符号引用进行解析。
用C表示这个方法所属的类或接口。
2.类方法和接口方法符号引用的常量类型定义是分开的，如果在类方法表中发现class_index中索引的C是个接口，则抛出ng.IncompatibleClassChangeError。
3.在类C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用。
4.否则，在C的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用。
5.否则，在C实现的接口列表及它们的父接口中递归的查找是否有简单名称和描述符都与目标相匹配的方法，如果有说明C是个抽象类，查找结束，抛出ng.AbstractMethodError 异常。
6.否则，查找失败，抛出ng.NoSuchMethodError异常。
7.如果查找返回了直接引用，将会对这个方法进行权限验证，如果发现不具备对这个方法的访问权限，则抛出ng.IllegalAccessError异常。
D. 接口方法(对应于常量池的CONSTANT_InterfaceMethodref_info类型)：1.对方法表中的class_index项中索引的CONSTANT_Class_info符号引用进行解析。
用C表示这个方法所属的类或接口。
2.如果在接口方法表中发现class_index中索引的C是个类，则抛出ng.IncompatibleClassChangeError。
3.否则，在接口C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用。
4.否则，在接口C的父接口中递归查找，知道ng.Object类(包括在内)，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用。
5.否则，查找失败，抛出ng.NoSuchMethodError。
5. 初始化初始化阶段是执行类构造器<clinit>()方法的过程。
1.<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{}块)中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序决定的。
静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块中可以赋值，但是不能访问。
2. 方法与实例构造器<init>()不同，不需要显示的调用父类构造器，虚拟机会保证在子类的<clinit>()方法执行之前，父类的<clinit>()已经执行完毕。