堆、栈、方法区、静态代码块---Java

java 堆、栈、方法区

堆区: 

1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) 

2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身 3、new出来的对象，有初始值。

栈区: 

1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中 

2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。

3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。 4、没有初始值

方法区: 

1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量或方法。 

2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

第一段代码：

public class Test extends Base{

    static{
        System.out.println("test static");
    }
    
    public Test(){
        System.out.println("test constructor");
    }
    
    public static void main(String[] args) {
        new Test();
    }
}

class Base{
    
    static{
        System.out.println("base static");
    }
    
    public Base(){
        System.out.println("base constructor");
    }
}

 输出结果：

base static
test static
base constructor
test constructor

先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。 

第二段代码：

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
    
    public Test() {
        System.out.println("test constructor");
    }
    
    public static void main(String[] args) {
        new MyClass();
    }
}

class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}


class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
    
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

 输出结果：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

 类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

第三段代码：

public class Test {
    
    static{
        System.out.println("test static 1");
    }
    public static void main(String[] args) {
        
    }
    
    static{
        System.out.println("test static 2");
    }
}

 输出结果：

test static 1
test static 2

 虽然在main方法中没有任何语句，但是还是会输出，原因上面已经讲述过了。另外，static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行），并且执行是按照static块的顺序执行的。