Java中的static详细总结学习，一篇就够了

用途：static关键字是用来区分类和对象的。

被static修饰的属于类，叫做（类成员、静态成员、类变量），可以直接通过（类.成员）来调用

不被static修饰的属于对象，叫做（对象成员、非静态成员、实例变量）可以通过（对象.成员）来调用。

static代码块可以出现在类的任何地方，绝对不能出现在方法中。

被static修饰的不用通过对象来访问，直接通过类来访问。

静态域 分为静态变量，静态方法，静态块。 当执行到静态域时，按着静态域的顺序加载，并且静态域只在类的第一次加载时被执行。

被static修饰的代码中，不能出现this和super这两个关键字。this表示这个类的当前实例，super表示父类的当前实例；static属于类，this是类的对象，当然不能调用。

被static修饰的静态代码块的作用，提升程序性能。

被static修饰的代码，在类加载的时候加载。

在静态方法中不能访问非静态成员变量和非静态成员方法，但在非静态成员方法中可以访问静态变量和静态方法。

学习下面代码的输出顺序：

public class Test {
    People p=new People("WanYuan");
    static{
        System.out.println("test static");
    }
    public Test(){
        System.out.println("Test的无参构造方法");
    }

    public static void main(String[] args) {
        new MyClass();
    }

}
class People{
    static {
        System.out.println("people static");
    }

    public People(String str){
        System.out.println("people"+str);
    }
}
class MyClass extends My{
    People p=new People("JiaLuo");
    static{
        System.out.println("MyClass static");
    }
    public MyClass() {
        System.out.println("MyClass constructor");
    }

}
class My{
    static{
        System.out.println("My static");
    }
}

输出结果为：

 1.先找到main方法，main方法是程序的入口，执行main方法之前，先加载main方法所在的类Test。

2.加载Test类时，发现有static修饰的代码块，所以先打印 test static。

3.Test加载完成后，执行main方法中的 new MyClass()，执行代码之前先加载new MyClass()所在的类MyClass，但是MyClass继承父类My，所以先加载父类My再加载MyClass类。

4.加载My时有静态代码块输出My static ，加载MyClass时有静态代码块输出MyClass static。

5. 加载完类之后，调用MyClass的构造器生成对象（new MyClass( )  ），生成对象之前，需要先初始化父类的成员变量，如果父类中有People p=new People("people"),并加载People类。本例中并没有，所以初始化父类，没有变化。

6.这个例子中，父类中没有People p=new People("people")。调用MyClass的构造器生成对象（new MyClass( )  ）之前，接下来需要调用父类的无参构造函数，本例中父类也没有无参构造函数。

7.解决完父类的初始化对象和调用无参构造函数之后，调用MyClass的构造器生成对象（new MyClass( )  ），发现MyClass还没有初始化，所以接着初始化MyClass类。初始化MyClass时发现还有People类没有加载，所以先加载People类。

8.加载People类，发现有static代码块，先执行static代码块，输出people static。

9.接着完成people类的初始化执行People的构造器，输出peopleJiaLuo。

10.最后调用Myclass类的构造器，完成MyClass类的初始化。

总结：先加载类再初始化类；

在没有继承父类的情况下，Class类加载的先后顺序如下：

在继承父类的情况下，Class类的加载顺序如下：

父类静态----->子类静态----->父类非静态----->父类构造函数----->子类非静态----->子类构造函数

 静态代码块，构造代码块，无参构造函数，有参构造函数，普通代码块执行顺序

public class Test03 {
    static{
        System.out.println("这是静态代码块");
    }

    {
        System.out.println("这是构造代码块");
    }

    public Test03(){
        System.out.println("这是无参构造");
    }

    public Test03(String name){
        System.out.println("这是有参构造函数");
    }

    public void add(){
        System.out.println("这是普通代码块");
    }

    public static void main(String[] args) {
        Test03 test03=new Test03();
        Test03 test04=new Test03("JiaLuo");
    }
}

 程序先执行静态代码块，每次新建一个对象都会去执行构造代码块，代码中新建了两个对象，所以出现了两次构造代码块，构造代码块优先于构造函数执行，又依赖于构造函数。没有构造函数新建对象，就不会由构造代码块执行。

静态代码块（static{}）在类加载的时候执行，是最早被执行的。
构造代码块（{}内的部分）在每一次创建对象的时候执行，始终在构造方法前执行。
构造方法在新建对象的时候调用。