Java static关键字

static变量

static变量其实就是静态变量，与类的成员变量不一样，类的成员变量是每个类的对象私有的，对象之间不可以访问对方的成员变量。但是static变量是所有对象共有的，内存里只存这么一份，任何对象都可以对这个static变量进行访问/修改。：

public class Main{
    public static int staticValue = 0;//所有的Main类实例都可以访问
    private int mValue = 0;//只有实例内部可以访问
}

static方法

static方法即静态方法不依赖于实例存在。可以通过类名直接调用。但是在static方法内部不可以调用类的成员变量或者成员方法。

static方法与普通方法的区别：

• static方法只能访问static变量和static方法，不可以访问普通方法；
• 普通方法可以调用static变量和static方法，也可以调用成员变量和普通方法。

public class Main{
    private int mValue=0;
    public void doSomthing(){};
    private static int staticValue = 1;
    private static void staticDoSomething(){};
    public static void staticMethod(){
        mValue = 3;//调用成员变量，错误
        doSomething()//调用成员方法，错误
        staticValue = 3;
        staticMethod();
        return;
    }

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

static代码块

static代码块是在类里用{}包起来的代码，它在类加载的时候执行，而且只执行一次。当然，static代码块也只能访问static变量和static方法。而static代码块的执行顺序则与static代码块在类的位置一样，谁在前面谁先被执行

public class Person {

    public static Main temp = new Main();

    static {
        System.out.println("Person class is loaded.");
        Main.staticMethod();
    }

    private String name;

    public Person(String name) {
        this.name = name;
        System.out.println("A persion is created.");
    }

    public static void main(String[] args) {

    }
}

另一个Main类

public class Main {
    public static int staticValue = 0;
    public int value = 4;

    public static void staticMethod() {
        System.out.println(staticValue);
    }

    public static Person p = new Person("p1");

    static {
        System.out.println("Main class is loaded.");
    }

    public Main() {
        System.out.println("Main is created.");
    }

}

执行结果：

A persion is created.
Main class is loaded.
Main is created.
Person class is loaded.
0

分析一下执行顺序：
1.main函数是在Person类里的，所以默认先执行Person里的代码；
2.Person类的代码，先执行带static关键字的代码，把static关键字的代码排序：

public static Main temp = new Main();//第一个执行

static {//第二个执行
    System.out.println("Person class is loaded.");
    Main.staticMethod();
}

因为Main类还没有加载，开始加载Main类;
然后看Main类的代码,也是先执行static关键字的代码:

private static int staticValue = 1;//第一个执行

public static Person p = new Person("p1");//第二个执行

static {//第三个执行
    System.out.println("Main class is loaded.");
}

所以先给初始化staticValue；
然后新建一个Person对象，由于Person对象已经加载了，所以不用再把Person类的static代码从头再执行一次，直接执行Person的构造方法；
所以第一个打印：

A persion is created.

然后到Main类里的第三个执行：

Main class is loaded.

接着回到Person类的第二个执行：

Person class is loaded.
0

static内部类

static内部类与普通内部类的区别：

• static内部类只能访问原来类的static变量和方法；
• 普通内部类可以访问成员变量和成员方法，static变量和方法也可以访问；
• 新建实例时，static内部类可以:

OutterClass.StaticInnerClass instance = new OutterClass.StaticInnerClass()

普通内部类则需要：

OutterClass.InnerClass instance = outterClassInstance.new InnerClass();