staitc

一、static和非static变量

1. static 修饰的变量称为类变量或全局变量或成员变量，在类被加载的时候成员变量即被初始化，与类关联，只要类存在，static变量就存在。非static修饰的成员变量是在对象new出来的时候划分存储空间，是与具体的对象绑定的，该成员变量仅为当前对象所拥有的。

2. static修饰的变量在加载的时候先于main方法加载在内存中的数据共享区-------方法区，而非static的变量在加载的时候，是要创建变量才加载在堆内存中的。

3. 一个static变量单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。static变量值在方法区加载一次，而非static在创建对象时会加载很多次。每次创建都会拷贝一份。
4. 对象在引用成员变量是直接通过类名.变量名调用，对象在引用实例变量时只能通过对象名.变量名调用。

5. 在类中调用成员变量时直接调用或者以类名.变量名方式调用，实例变量则用this或者直接调用。

public class Main {　　
    static int value = 33;

    public static void main(String[] args) throws Exception{
        new Main().printValue();
    }

    private void printValue(){
        int value = 3;
        System.out.println(this.value);
    }
}

这里面主要考察队this和static的理解。this代表什么？this代表当前对象，那么通过new Main()来调用printValue的话，当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，根本不可能与this关联，所以输出结果是33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

二、static方法和非static方法

1. static修饰的方法也和static一样。先于main方法被加载到方法区，以便共享使用。

2. 静态的static方法中不能使用this或者super关键字，因为static方法是先于对象创建之前就已经加载的方法，是属于类的方法，而this和super指向的是本类的对象或者父类的对象，非静态的方法是属于对象的，方法里可以用this和super。

3. static方法可以用对象.方法名来调用，也可以用类名.方法名来调用。而非静态的方法只能创建对象后时调用。

4. static方法是加载一次，被所有的对象所共享。而非静态方法是有多少个对象就拷贝多少次，每个对象只能调用自己的拷贝的方法。

5. 对象调用非静态的方法时，不考虑线程安全性的问题，而调用静态方法时，要考虑安全性的问题。因为静态方法只有一份。而对象的方法是自己有自己的。

6. 同一个类中，静态方法中只能访问类中的静态成员。而非静态方法可以访问静态或非静态的方法（使用类名调用，或者创创建本类的对象调用）。

三、static静态代码块

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。

四、static加载顺序DEMO

Demo1

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()的时候会先调用父类的构造器，然后再调用自身的构造器。

Demo2

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的构造器。

参考：https://www.cnblogs.com/dolphin0520/p/3799052.html

https://blog.csdn.net/a907691592/article/details/51668440