Java的源代码（xxx.java）可以通过java的编译器生成字节码文件（xxx.class），java的编译器的功能有如下几点：
1、 词法分析
2、 语法分析
3、 语法、抽象语法树
4、 语义分析
5、 注解抽象语法树
6、 字节码生成器
Java的字节码文件通过java虚拟机编译运行，java虚拟机有类加载器，字节码校验器，编译字节码（解析执行），JIT编译器（编译执行）编译出机器指令，最后经由操作系统运行机器指令得出结果。编译字节码和JIT编译器类似于java的执行引擎
java.lang . reflect 包下的接口和类，包括 Class 、 Method 、 Field ， Constructor 和 Array等 ，这些类分别代表类、方法 、成员变量构造器和数组 ， Java 程序可以使用这些类动态地获取某个对象 、某个类的运行时信息， 并可以动态地创建 Java 对 象 ，动态地调用 Java 方法， 访问并修改指定对象的成员变量值 。
当调用 Java 命令运行某个 Java 程序时，该命令将会启动一个 Java 虚拟机进程，不管该 Java 程序有多么复杂，该程序启动了多少个线程，它们都处于该 Java 虚拟机进程里 。
在同一个jvm的所有线程，所有变量都处于同一个进程里，它们使用jvm的内存区。不同的jvm内存区信息不共享。
jvm进程终止的几种原因：
1、程序运行到最后正常结束。 2、程序运行到System.exit()或Runtime.getRuntime().exit()代码区结束。 3、程序运行过程中遇到未捕获的异常或者错误而退出。 4、程序所在的平台强制结束了jvm的进程（命令行或者任务管理器强制杀死该进程）
实例代码：
public class B{
static int a = 6;
public B(){
a++;
}
}
public class ATest {
public static void main(String[] args) {
B.a++;
System.out.println(B.a);
}
}
public class BTest {
public static void main(String[] args) {
B b = new B();
B.a++;
System.out.println(b.a);
}
}
ATest的输出是7，BTest的输出是8，ATest调用B.a++后没有在B类里面运行B类的构造函数，直接是静态域的a自加为7，BTest的输出是8，而不是9的原因是main函数里面的第一行代码创建了一个B的对象，创建的过程中默认调用了B的无参数构造器，所以a的值从6变成7，在main函数里面的第二行代码，再次引用了B类里面的变量自加，从7变成8。所以两个jvm的运行过程是独立的，数据不互通。
1.2类的加载类加载指的是将类的 class 文件读入内存，并为之创建一个 java.lang. Class 对象，也就是说， 当程序中使用任何类时，系统都会为之建立一个 java.lang.Class 对象 。当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三个步骤来对该类进行初始化 。
1、通过加载一个类的全限定类名获取定义此类的二进制字节流文件。
2、将这个字节流所代表的静态存储结构转化为方法区的运行时的数据结构。
3、所生成的java.lang.class对象，作为方法区的这个类的各种数据的访问入口。
类的加载器加载的数据来源有以下几种：
1、从本地文件系统加载 class 文件，这是绝大部分示例程序的类加载方式 。 2、从 JAR 包加载 class 文件，jvm可以从 JAR 文件中 直接加载该 class 文件 。 3、通过网络加载class文件 4、把一个java的源文件动态编译并执行加载 5、从专有的数据库中提取class文件，比较少见。 6、从加密文件中获取，这是典型的防止class文件被反编译的措施。 7、由其他文件生成，典型的场景：jsp应用。
类的加载大致过程：
当类被加载之后，系统为之生成一个对应的 Class 对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到jre中 。类连接又可分为如下三个阶段。
(1)验证 : 验证阶段用于检验被加载的类是否有正确的内部结构，并和其他的类协调一致，这样不会危害到虚拟机的安全，验证主要包含以下几种：
1、文件格式验证
2、元数据验证
3、字节码验证
4、符号引用验证
( 2 ) 准备 : 类的准备阶段为类变量分配内存空间并初始化默认值。不包含使用了final修饰的static，因为final在编译的时候就会被分配了，在程序运行当中是一个常量。另外还不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量会随对象分配在java的堆中。
(3)解析:将类的二进制数据的符号引用代替为直接引用 。
1.4类的初始化1、解析操作是随jvm执行完初始化后再执行。
2、符号引用是一组符号来描述所引用的目标。直接引用是直接指向目标的指针，相对偏移量或者是一组间接定位到目标的句柄。
3、解析动作主要针对的是类或者接口，字段，类方法，接口方法，方法类型等。
类的初始化阶段是执行类的构造器方法clinit()的过程
这个方法不需要定义，当类变量中不存在静态变量或者是静态代码块的时候，这个方法就不会被执行，这个是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块的语句合并来的。
构造器方法中的指令按语句在源文件中出现的顺序来执行的。
clinit()方法不同于类的构造器init()。如果该类拥有父类，jvm会保证子类的clinit()执行之前，父类的clinit()会先执行完毕。
java虚拟机必须保证一个类的clinit()方法在多线程下被同步加锁。
public class ThreadClassInitTest {
public static void main(String[] args) {
Runnable run = () ->{
System.out.println(Thread.currentThread().getName()+"开始");
ThreadClass threadClass = new ThreadClass();
System.out.println(Thread.currentThread().getName()+"结束");
};
Thread thread1 = new Thread(run,"线程1");
Thread thread2 = new Thread(run,"线程2");
thread1.start();
thread2.start();
// java虚拟机必须保证一个类的clinit()方法在多线程下被同步加锁。
// 线程1或者线程2加载类后出不来了，然后后续的代码块都没法执行了。
}
}
class ThreadClass{
static {
if(true){
System.out.println(Thread.currentThread().getName()+"初始化当前类");
while (true){}
}
}
}
public class ClassInitTest {
static class Father{
private static int a = 10;
static {
a = 20;
}
}
static class Son extends Father {
private static int b = Father.a;
}
public static void main(String[] args) {
System.out.println(Son.b);// 20
//clinit()方法不同于类的构造器init()。
//如果该类拥有父类，jvm会保证子类的clinit()执行之前，
//父类的clinit()会先执行完毕。
}
}
jvm初始化类的步骤：
（1）假如这个类还没有被加载和连接，程序先加载并连接该类。
（2）假如该类的直接父类还没有被初始化，则先初始化其直接父类。
（3）假如类中有初始化语句，则系统依次执行这些初始化语句。
在类的初始化阶段，虚拟机负责对类进行初始化，主要就是对静态属性进行初始化。在Java类中对静态属性指定初始值有两种方式：
（1）声明静态属性时指定初始值；
（2）使用静态初始化块为静态属性指定初始值。
jvm初始化的时机：
- 创建类的实例。为某个类创建实例的方式包括使用new操作符来创建实例，通过反射来创建实例，通过反序列化的方式来创建实例。
- 调用某个类的静态方法。
- 访问某个类或接口的静态属性，或为该静态属性赋值。
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。例如代码：Class.forName(“Person”)。
- 初始化某个类的子类，当初始化某个类的子类时，该子类的所有父类都会被初始化。
- 直接使用java.exe命令来运行某个主类，当运行某个主类时，程序会先初始化该主类。
- final型的静态属性，如果该属性可以在编译时就得到属性值，则可认为该属性可被当成编译时常量。当程序使用编译时常量时，系统会认为这是对该类的被动使用，所以不会导致该类的初始化
public class ClassInitTest {
private static int a = 10;
static {
a = 20;// linking的prepare: a = 0 ---> initial: 10 --> 20;
b = 10;//linking的prepare: b = 0 ---> initial: 10 --> 1;
//System.out.println(number);//报错，非法的向前引用。
System.out.println(ClassInitTest.number);// 正确
}
private static int number = 20;
private static int b = 1;
static {
number = 100;// linking的prepare: number = 0 ---> initial: 20 --> 100;
}
public static void main(String[] args) {
System.out.println("a = "+ClassInitTest.a);
System.out.println("number = "+ClassInitTest.number);
System.out.println("b = "+ClassInitTest.b);
}
}
1.5类的加载机制
JVM的类加载机制主要有如下三种机制：
1.6 类的加载器全盘负责：所谓全盘负责，就是说当一个类加载器负责加载某个Class的时候，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显式使用另外一个类加载器来载入。
父类委托：所谓父类委托则是先让parent（父）类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。
缓存机制：缓存机制将会保证所有被加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存中搜寻该Class，只有当缓存中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，并存入cache。这就是为什么我们修改了Class后，程序必须重新启动JVM，程序所作的修改才会生效的原因。（因为此时缓存中不存在修改后的Class对象）
jvm支持两种类型的加载器，分别是引导类加载器和自定义类加载器。
自定义类加载器是程序开发中程序员自定义的一种类加载器，java虚拟机没有这样的规范，而是把所有的派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。
public class ClassLoaderTest {
public static void main(String[] args) {
// 获取系统类加载器
ClassLoader loader = ClassLoader.getSystemClassLoader();
System.out.println(loader); // sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取系统类加载器的上层，扩展类加载器
ClassLoader parent = loader.getParent();
System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@61bbe9ba
// 获取其上层，但是获取不到引导类加载器
ClassLoader allFather = parent.getParent();
System.out.println(allFather); // null
// 获取当前类的加载器： 对于用户定义的类默认使用系统类加载器进行加载
ClassLoader loaderTest = ClassInitTest.class.getClassLoader();
System.out.println(loaderTest);
// 获取String的类加载器
// java 的核心类库都是使用引导类加载器加载的
ClassLoader stringLoader = String.class.getClassLoader();
System.out.println(stringLoader);// null
ClassLoader integerLoader = Integer.class.getClassLoader();
System.out.println(integerLoader);// null
}
}
1.7 类加载器加载Class的步骤
- 检测此 Class 是否载入过(即在缓存区中是否有此 Class ) ，如果有则直接进入第 8 步，否则接着执行第 2 步 。
- 如果父类加载器不存在( 如果没有父类加载器 ，则要么 parent 一定是根类加载器，要么本身就是根类加载器) ，则跳到第 4 步执行 :如果父类加载器存在 ，则接着执行第 3 步。
- 请求使用 父类加载器去载入目标类 ，如果成功载入则跳到第 8 步 ， 否则接着执行第 5 步。
- 请求使用根类加载器来载入目标类，如果成功载入则跳到第 8 步 ， 否则跳到第 7 步。
- 当前类加载器尝试寻找 Class 文件 ( 从与此 ClassLoader 相关的类路径中寻找)，如果找到则执行第 6 步 ， 如果找不到则跳到第 7 步。
- 从文件中载入 Class ， 成功载入后跳到第 8 步。
- 抛出 ClassNotFoundException 异常。
- 返回对应的 java .lang.Class 对象。
其中 ，第 5 、6 步允许重写 ClassLoader的 findClassO方法来实现自己的载入策略 ，甚至重写 loadClass()方法来实现自己的载入过程 。
1.8 类加载器的分类java虚拟机自带的加载器有三种（这里写的稍微有点乱，我参考了很多，不懂的建议去搜别的参考一下。）
1、启动类加载器（引导类加载器（根类加载器）：Bootstrap ClassLoader）
- 这个类加载器使用C/C++实现的，内嵌在jvm的内部（一般的类加载器访问不到）
- 它用来加载java的核心类库，（比如JAVA_HOME/jre/lib/resources.jar或者是sun.boot.class.path路径下的内容）用于提供jvm需要的类
- 不继承自java.lang.ClassLoader，没有父类加载器。（它最大）
- 加载扩展类加载器和应用程序类加载器，并且为他们指定父类加载器。
- 为了安全考虑，BootstrapClassLoader只是会加载sun、javax、java等开头的类。
2、扩展类加载器（Extension ClassLoader）
- java 语言编写的，由sun.misc.Launcher$ExtClassLoader实现。
- 派生于ClassLoader类
- 父类加载器为启动类加载器
- 从java.ext.dirs系统属性所指定的目录中加载类库，或者是从jdk安装的目录jre/lib/ext子目录的（扩展类库）下加载类库，如果用户创建jar文件放在此目录下也会自动有扩展类加载器加载。
3、应用程序类加载器（系统类加载器 AppClassLoader）
- java 语言编写，由sun.misc.Launcher$AppClassLoader实现
- 派生于ClassLoader类
- 父类加载器为扩展类加载器
- 它负责加载环境变量classpath或是系统属性，java.class.path路径下的类库。
- 该类是程序中默认的类加载器。java的应用的类都是由该加载完成。
- 通过ClassLoader.getSystemClassLoader()可以获取该类加载器。
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
public class ClassLoaderTest {
public static void main(String[] args) {
// 获取系统类加载器
ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
System.out.println("系统类加载器："+systemLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取系统类加载器的上层，扩展类加载器
ClassLoader parent = systemLoader.getParent();
System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@61bbe9ba
Enumeration eml = null;
try {
eml = systemLoader.getResources("");
} catch (IOException e) {
e.printStackTrace();
}
while(eml.hasMoreElements()){
System.out.println(eml.nextElement()); // 代码路径/java/AnnotationAndReflection/target/classes/
}
//获取系统类加载器的父类加载器，得到扩展类加载器
ClassLoader extensionLader = systemLoader.getParent();
System.out.println( " 扩展类加载器 : " + extensionLader);// sun.misc.Launcher$ExtClassLoader@61bbe9ba
System.out.println(" 扩展类加载器的加载路径: "
+ System.getProperty (" java.ext.dirs " ));
System.out.println("扩展类加载器的 parent: "
+ extensionLader . getParent());
}
}
系统类加载器的加载路径是程序运行的当前路径，扩展类加载器的加载
路径是 null，扩展类加载器的父加载器是 null，并不是根类加载器。这是 因为根类加载器并没有继承 ClassLoader 抽象类 ，所以扩展类加载器的 getParent()方法返回 null 。但实际上，扩展类加载器的父类加载器是根类加载器，只是根类加载器并不是 Java 实现的，而且由于程序通常无须访问根类加载器，因此访问扩展类加载器的父类加载器时返回 null 。
用户自定义类加载器
在java程序开发的过程中，类的加载基本上都是由上述三类加载器加载完成，在必要的时候可以自己定义类加载器。
自定义类加载器可以实现一下几种常见的功能：
1、执行代码前自动验证数字签名
2、根据用户提供的密码解密代码，从而实现代码混淆器来避免反编译*.class文件
3、根据用户需求来动态地加载类
4、根据应用需求把其他数据以字节码的形式加载到应用中。
自定义类加载器好处：
1、隔离加载类
2、修改类加载的方式
3、扩展加载源
4、防止源码泄露
ClassLoader类有如下两个关键方法：
loadClass(String name, boolean resolve)：根据指定的二进制名称来加载类，该方法为ClassLoader的入口点，系统就是调用ClassLoader的该方法来获取指定类对应的Class对象。
findClass(String name)：根据二进制名称来查找类。
如果需要实现自定义的ClassLoader，可以通过重写以上两个方法来实现，优先推荐重写findClass(String name)方法。因为重写 findClassO方法可以避免覆盖默认类加载器的父类委托 和缓冲机制两种策略 ; 如果重写 loadClassO方法 ，则实现逻辑更为复杂。
loadClass()方法的执行步骤如下 ：
1、用 findLoadedClass(String) 来检查是否己经加载类 ， 如果已经加载则直接返回 。 在父类加载器上调用
2、 loadClassO方法。 如果父类加载器为 null ，则使用根类加载器来加载 。
3、 调用 findClass(String)方法查找类。
ClassLoader 里还包含如下一些普通方法：
1、 findSystemClass(String name): 从本地文件系统装入文件 。 它在本地文件系统中寻找类文件，如果存在，就使用 defineClassO方法将原始字节转换成 Class 对象，以将该文件转换成类。
2、static getSystemClassLoaderO: 这是一个静态方法，用于返回系统类加载器 。
3、getParent（）: 获取该类加载器的父类加载器 。4、resolveClass(Class c): 链接指定的类 。 类加载器可以使用此方法来链接类 c 。
5、findLoadedClass(String name): 如果此 Java 虚拟机己加载了名为 name 的类，则直接返回该类对应的Class 实例，否则返回 null。该方法是 Java 类加载缓存机制的体现。
import java.io.*;
import java.lang.reflect.*;
public class CompileClassLoader extends ClassLoader
{
private byte[] getBytes(String filename)
throws IOException
{
File file = new File(filename);
long len = file.length();
byte[] raw = new byte[(int)len];
try(
FileInputStream fin = new FileInputStream(file))
{
int r = fin.read(raw);
if(r != len)
throw new IOException("无法读取全部文件"
+ r + " != " + len);
return raw;
}
}
private boolean compile(String javaFile)
throws IOException
{
System.out.println("CompileClassLoader:正在编译 "
+ javaFile + "...");
// 调用系统的javac命令
Process p = Runtime.getRuntime().exec("javac " + javaFile);
try
{
// 其他线程等待这个线程完成
p.waitFor();
}
catch(InterruptedException ie)
{
System.out.println(ie);
}
int ret = p.exitValue();
return ret == 0;
}
protected Class findClass(String name)
throws ClassNotFoundException
{
Class clazz = null;
String fileStub = name.replace("." , "/");
String javaFilename = fileStub + ".java";
String classFilename = fileStub + ".class";
File javaFile = new File(javaFilename);
File classFile = new File(classFilename);
if(javaFile.exists() && (!classFile.exists()
|| javaFile.lastModified() > classFile.lastModified()))
{
try
{
if(!compile(javaFilename) || !classFile.exists())
{
throw new ClassNotFoundException(
"ClassNotFoundExcetpion:" + javaFilename);
}
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
if (classFile.exists())
{
try
{
byte[] raw = getBytes(classFilename);
clazz = defineClass(name,raw,0,raw.length);
}
catch(IOException ie)
{
ie.printStackTrace();
}
}
if(clazz == null)
{
throw new ClassNotFoundException(name);
}
return clazz;
}
public static void main(String[] args) throws Exception
{
if (args.length < 1)
{
System.out.println("缺少目标类，请按如下格式运行java源文件：");
System.out.println("java CompileClassLoader ClassName");
}
String progClass = args[0];
String[] progArgs = new String[args.length-1];
System.arraycopy(args , 1 , progArgs
, 0 , progArgs.length);
CompileClassLoader ccl = new CompileClassLoader();
Class clazz = ccl.loadClass(progClass);
Method main = clazz.getMethod("main" , (new String[0]).getClass());
Object[] argsArray = {progArgs};
main.invoke(null,argsArray);
}
}
1.9 URLClassLoader类
Java为ClassLoader提供了一个URLClassLoader实现类，该类也是系统类加载器和扩展类加载器的父类（此处是父类，而不是父类加载器，这里是类与类之间的继承关系），URLClassLoader功能比较强大，它既可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件来加载类。
应用程序中可以直接使用URLClassLoader来加载类，URLClassLoader类提供了如下两个构造器：
URLClassLoader(URL[] urls)：使用默认的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的系列路径来查询、并加载类。
URLClassLoader(URL[] urls, ClassLoader parent)：使用指定的父类加载器创建一个ClassLoader对象，其他功能前一个构造器相同。
