基本数据类型

• Java内置8种基本类型 -> 6种数字类型 -> 4种整数类型: byte, short, int, long

• 2种浮点类型: float, double
• 1种布尔类型: boolean
• 1种字符类型: char

1、原始数据类型对应的封装对象

• (byte, Byte), (short, Short), (long, Long), (float,Float), (double, Double), (boolean, Boolean)
• (int, Integer), (char, Character)

小题

Integer i = null;
int j = i.intValue();
12

编译通过，但运行时报错NullPointerException。因为调用了null.somemethod()。

自动装箱和拆箱

Integer i = 100;  //自动装箱，编译器执行Integer.valueOf(100)
int j = i;        //自动拆箱，编译器执行i.intValue()
12

小题

 Integer i1 =200;  
 Integer i2 =200;          
 System.out.println("i1==i2: "+(i1==i2));                   
 Integer i3 =100;  
 Integer i4 =100;  
 System.out.println("i3==i4: "+(i3==i4));

运行结果为false,true.

首先，==和equals()的区别：

• ==比较的是两个对象的引用是否相同，或者是比较原始数据类型是否相等；
• equals()比较的是两个对象的内容是否相同。

其次，-128~127的Integer值可以从缓存中取得。其他情况要重新创建。

public static Integer valueOf(int i) {

if (i >= IntegerCache.low && i <= IntegerCache.high)

return IntegerCache.cache[i + (-IntegerCache.low)];

return new Integer(i);

}

可以通过JVM参数配置缓存大小，-XX:AutoBoxCacheMax=<size>

String str1 ="abc";
String str2 ="abc";
System.out.println(str2==str1); 
System.out.println(str2.equals(str1));  
String str3 =new String("abc");
String str4 =new String("abc"); 
System.out.println(str3==str4);  
System.out.println(str3.equals(str4));  
12345678

结果是true,true, false, true.前两个String对象从String池中获取，后两个对象是新创建的，内容相同但引用不同。

小题

String d ="2"; 
String e ="23";
e = e.substring(0, 1);
System.out.println(e.equals(d)); 
System.out.println(e==d);
12345

结果是true,false.直接上源码：

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

• 关于基本数据类型的几点补充short s1=1; s1=s1+1;这一句编译错误，因为执行s1+1返回的结果是int类型（执行隐式类型转换）。修改的话要强制转换为short型才可以。short s1=1; s1+=4;这一句没有任何问题。switch语句不能作用于long类型中，可以作用于char, byte, short, int, Character, Byte, Short, Integer, String or an enum.小题

 public static void main(String[] args) throws Throwable {
     int j=0;
     for(int i=0;i<1000;i++) {
         j=j++;
     }
     System.out.println(j);
 }
1234567

运行结果为0。

解释一（未十分确信）：Java使用中间缓存变量机制，j=j++语句会执行为：

temp=j;
j=j+1;
j=temp;
123

解释二（靠谱）：使用javap反汇编命令进行反汇编，其中j=j++对应的结果是（j对应的变量编号是1）：

   11: iload_1                   //将局部变量j的值放到栈顶：0
   12: iinc          1, 1        //将局部变量j的值加1，j=1
   15: istore_1                  //将栈顶的值放到局部变量j中，j=0
123

所以从底层实现看，j=j++这一句中的自增操作只是对局部变量的操作，局部变量变化后没有存储到栈顶，反而被之前栈顶的值覆盖了，所以相当于不起作用。

继 承（面向对象特征之一）

好处：

　　1：提高了代码的复用性。

　　2：让类与类之间产生了关系，提供了另一个特征多态的前提。

父类的由来：其实是由多个类不断向上抽取共性内容而来的。

　　java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。

　　单继承：一个类只能有一个父类。

　　多继承：一个类可以有多个父类。

　　为什么不支持多继承呢？

　　因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。

　　但是java支持多重继承。A继承B B继承C C继承D。

　　多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。

　　所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。

简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。

子父类出现后，类中的成员都有了哪些特点：

　　1：成员变量。

　　　　当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

　　　　如果想要调用父类中的属性值，需要使用一个关键字：super

　　　　This：代表是本类类型的对象引用。

　　　　Super：代表是子类所属的父类中的内存空间引用。

　　　　注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。

　　2：成员函数。

　　　　当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)

　　　　什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。

　　3：构造函数。

　　发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?

　　原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();

　　super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

　　为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)

　　因为子类继承父类，会继承到父类中的数据，必须要看父类是如何对自己的数据进行初始化的。

　　所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

注意：

　　子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

　　如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

　　如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

问题：super()和this()是否可以同时出现的构造函数中。

　　两个语句只能有一个定义在第一行，所以只能出现其中一个。

　　super()或者this():为什么一定要定义在第一行？

　　因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

继承的细节：

　什么时候使用继承呢？

　　　当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。

　　英文书中，所属关系：" is a "

　　注意：不要仅仅为了获取其他类中的已有成员进行继承。

　　所以判断所属关系，可以简单看，

　　如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。

细节二：

　在方法覆盖时，注意两点：

　　　1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。

　　　2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)

继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。

这时如何解决问题呢？介绍一个关键字，final:最终。

final特点：

　1：这个关键字是一个修饰符，可以修饰类，方法，变量。

　2：被final修饰的类是一个最终类，不可以被继承。

　3：被final修饰的方法是一个最终方法，不可以被覆盖。

　4：被final修饰的变量是一个常量，只能赋值一次。

异 常：

　　异常：就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

　　出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。

　　————————java.lang.Throwable：

　　Throwable：可抛出的。

　　　　|——Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。

　　　　|——Exception：异常，可以有针对性的处理方式

　　无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名。

这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。

可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。

——————————————————————————————————————————————————————

　　class ExceptionDemo{

　　　　public static void main(String[] args) {

　　　　　　// byte[] buf = new byte[1024*1024*700];//java.lang.OutOfMemoryError内存溢出错误

　　　　}

　　}

——————————————————————————————————————————————————————

　　在开发时，如果定义功能时，发现该功能会出现一些问题，应该将问题在定义功能时标示出来，这样调用者就可以在使用这个功能的时候，预先给出处理方式。

　　如何标示呢？通过throws关键字完成，格式：throws 异常类名,异常类名...

　　这样标示后，调用者，在使用该功能时，就必须要处理，否则编译失败。

　　处理方式有两种：1、捕捉；2、抛出。

　　对于捕捉：java有针对性的语句块进行处理。

　　try {

　　　　需要被检测的代码；

　　}catch(异常类 变量名){

　　　　异常处理代码；

　　}fianlly{

　　一定会执行的代码；

　　}

——————————————————————————————————————————————————————

　　catch (Exception e) { //e用于接收try检测到的异常对象。

　　　　System.out.println("message:"+e.getMessage());//获取的是异常的信息。

　　　　System.out.println("toString:"+e.toString());//获取的是异常的名字+异常的信息。

　　　　e.printStackTrace();//打印异常在堆栈中信息；异常名称+异常信息+异常的位置。

　　}

——————————————————————————————————————————————————————

　　异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。

　　特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

throw 和throws关键字的区别：

　throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。

　throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

　　通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定要声明，否则编译失败。但是也有特殊情况。

异常分两种：

　　1：编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。

　　2：运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。

编译时被检查的异常和运行时异常的区别：

　　编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。

　　声明的原因：是需要调用者对该异常进行处理。

　　运行时异常如果在函数内被抛出，在函数上不需要声明。

　　不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。

　　定义异常处理时，什么时候定义try，什么时候定义throws呢？

　　功能内部如果出现异常，如果内部可以处理，就用try；

　　如果功能内部处理不了，就必须声明出来，让调用者处理。

　　自定义异常：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装。这个异常，称为自定义异常。

　　对于除法运算，0作为除数是不可以的。java中对这种问题用ArithmeticException类进行描述。对于这个功能，在我们项目中，除数除了不可以为0外，还不可以为负数。可是负数的部分java并没有针对描述。所以我们就需要自定义这个异常。

自定义异常的步骤：

　1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。

　2：通过throw 或者throws进行操作。

异常的转换思想：当出现的异常是调用者处理不了的，就需要将此异常转换为一个调用者可以处理的异常抛出。

try catch finally的几种结合方式：

　　1，

　　　　try {

}catch{

}finally{

}

　　2,

　　　　try{

} catch {

}

　　3,

　　　　try{

} finally {

}

　　这种情况，如果出现异常，并不处理，但是资源一定关闭，所以try finally集合只为关闭资源。

　　记住：finally很有用，主要用户关闭资源。无论是否发生异常，资源都必须进行关闭。

　　System.exit(0); //退出jvm，只有这种情况finally不执行。

当异常出现后，在子父类进行覆盖时，有了一些新的特点：

　　1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。

　　2：如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。

注意：

　　如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。

　　如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。

常见异常：

　　1、脚标越界异常（IndexOutOfBoundsException）包括数组、字符串；

　　　　空指针异常（NullPointerException）

　　2、类型转换异常：ClassCastException

　　3、没有这个元素异常：NullPointerException

　　4、不支持操作异常；

　　异常要尽量避免，如果避免不了，需要预先给出处理方式。比如家庭备药，比如灭火器。

多线程：

　　进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

　　线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

　　一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

　　jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

　　当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

　　随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

　　返回当前线程的名称：Thread.currentThread().getName()

　　线程的名称是由：Thread—编号定义的。编号从0开始。

　　线程要运行的代码都统一存放在了run方法中。

　　线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

　　start方法：1）、启动了线程；2）、让jvm调用了run方法。

　　创建线程的第一种方式：继承Thread ，由子类复写run方法。

　　步骤：

　　　　1，定义类继承Thread类；

　　　　2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

　　　　3，通过创建Thread类的子类对象，创建线程对象；

　　　　4，调用线程的start方法，开启线程，并执行run方法。

　　线程状态：

　　　　被创建：start()

　　　　运行：具备执行资格，同时具备执行权；

　　　　冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

　　　　临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

　　　　消亡：stop()

创建线程的第二种方式：实现一个接口Runnable。

步骤：

　　1，定义类实现Runnable接口。

　　2，覆盖接口中的run方法（用于封装线程要运行的代码）。

　　3，通过Thread类创建线程对象；

　　4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

　　　　　　为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。

5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

　　Ticket t = new Ticket();

　　Thread t1 = new Thread(t); //创建线程。

　　t1.start();

　　为什么要有Runnable接口的出现？

　　1：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

　　　　可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

　　　　只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式，因为实现Runnable接口可以避免单继承的局限性。

　　2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

　　所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

　　实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

Java程序是怎么执行的？

1. 先把Java代码编译成class字节码，大致流程是：Java源代码 --> 词法分析器 --> 语义分析器 --> 字节码生成器 --> 字节码；
2. 将.clsss文件放入Java虚拟机，通常是Oracle官方自带的hotspot jvm
3. JVM使用类加载器装载class文件；
4. 类加载完成后，进行字节码校验，校验通过后JVM解释器会把字节码翻译成机器码交给操作系统解释执行，但不是所有代码都解释执行，例如hotspot jvm提供了JIT（Just In Time）也就是动态编译器，在运行时将热点代码编译为机器码，这时字节码就变成了编译执行；

JVM如何判定热点代码？

• 基于采样的热点判定JVM会周期性检查各个线程的栈顶，若某个方法经常出现在栈顶，那这个方法就是热点方法，优点是实现简单，缺点是缺少精确性，很容易受到线程阻塞或外界因素的影响
• 基于计时器的热点判定主要就是虚拟机给每一个方法甚至代码块建立了一个计数器，统计方法的执行次数，超过一定的阀值则标记为此方法为热点方法。Hotspot 虚拟机使用的基于计数器的热点探测方法。它使用了两类计数器：方法调用计数器和回边计数器，当到达一定的阀值是就会触发 JIT 编译。方法调用计数器：在 client 模式下的阀值是 1500 次，Server 是 10000 次，可以通过虚拟机参数： -XX:CompileThreshold=N 对其进行设置。但是JVM还存在热度衰减，时间段内调用方法的次数较少，计数器就减小。回边计数器：主要统计的是方法中循环体代码执行的次数。

Java内存泄漏的常见场景

• 长生命周期对象持有短生命的引用，比如，缓存系统，我们加载了一个对象放在缓存中，然后一直不使用这个缓存，由于缓存的对象一直被缓存引用得不到释放，就造成了内存泄漏；
• 各种连接未调用关闭方法，比如，数据库 Connection 连接，未显性地关闭，就会造成内存泄漏；
• 内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露；
• 改变哈希值，当一个对象被存储进 HashSet 集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则对象修改后的哈希值与最初存储进 HashSet 集合中时的哈希值就不同了，在这种情况下，即使在 contains 方法使用该对象的当前引用作为的参数去 HashSet 集合中检索对象，也将返回找不到对象的结果，这也会导致无法从 HashSet 集合中单独删除当前对象，造成内存泄露。

类加载器
Java类加载器基于三个机制：委托、可见性和单一性。委托机制是指将加载一个类的请求交给父类加载器，如果这个父类加载器不能够找到或者加载这个类，那么再加载它。可见性的原理是子类的加载器可以看见所有的父类加载器加载的类，而父类加载器看不到子类加载器加载的类。单一性原理是指仅加载一个类一次，这是由委托机制确保子类加载器不会再次加载父类加载器加载过的类。类加载器负责加载文件系统、网络或其他来源的类文件。有三种默认使用的类加载器(jvm自带)：Bootstrap类加载器、Extension类加载器和System类加载器（或者叫作Application类加载器）。每种类加载器都有设定好从哪里加载类。

3、本地方法栈、本地方法接口
用于融合其他编成语言为java所用

pc寄存器
程序计数器：记录程序的执行顺序

5、方法区、静态区
方法区存储了每一个类的结构信息、方法区是规范，在不同的虚拟机里头实现是不一样的，最典型的就是永久代和元空间。
1.方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。
3.全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

注意：Java7及以前版本的Hotspot中方法区位于永久代中。同时，永久代和堆是相互隔离的，但它们使用的物理内存是连续的。永久代的垃圾收集是和老年代捆绑在一起的，因此无论谁满了，都会触发永久代和老年代的垃圾收集。在Java8中，元空间(Metaspace)登上舞台，方法区存在于元空间(Metaspace)。同时，元空间不再与堆连续，而且是存在于本地内存（Native memory）。永久代的参数-XX:PermSize和-XX：MaxPermSize也随之失效。当Java Heap空间不足时会触发GC，但Native memory空间不够却不会触发GC。

6、栈
栈区:对象实例在Heap（堆）中分配好以后，需要在Stack中保存一个4字节的Heap内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例。
1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中。
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
4.由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。
5.栈管运行、堆管存储

7、堆
堆区:专门用来保存对象的实例(创建的对象和数组)，实际上也只是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在Stack中）。堆的结构，物理：新生代+老年代，逻辑上：新生代+老年代+永久代（java7），java8永久代被移除。
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身.
3.一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

引用计数法（一般不采用）
● 复制算法(Copying)
● 标记清除算法(Mark-Sweep)
● 标记压缩算法(Mark-Compact)

9、执行过程（Java8）
（1）java编译器把类编译成.class文件。
（2）类加载器加载.class文件。
（3）栈负责运行和存储本地（8种基本数据类型和对象的引用）变量、栈操作、实例方法出口等等。
（4）堆负责存储创建的对象和数组、静态变量、字符串常量池。说明：动态创建的字符串不会默认跑到常量池里面的，不用担心GC扫不掉它们。
（5）方法区负责存储类元信息。