static

static修饰的变量和方法统一属于类的静态资源，是类实例之间共享的
JDK将不同的静态资源放在不同的类中，而不是把所有静态资源放在一个类中，可以实现静态分类（不同类有自己的静态资源），避免重名和静态资源无限膨胀.

静态变量和静态方法

1. 被static修饰的变量属于类变量，可以通过类名.变量名直接引用，不需要new
2. 被static修饰的方法属于类方法，可以通过类名.方法名直接引用，不需要new

静态资源属于类，但是独立于类存在，静态资源是类初始化的时候加载的，而非静态资源那是类new的时候加载的。
类的初始化早于类的new，比如Class.forName("xxx")方法，就是初始化一个类，但是并没有new，只是加载这个类的静态资源，所以：

• 静态方法不能引用非静态资源
• 静态方法可以引用静态资源
• 非静态方法可以引用静态资源

错误示例

public class A
{
    private int i = 1;
    
    public static void main(String[] args)
    {
        // 错误代码，静态方法不能有引用非静态资源
        i = 1;
    }
}

静态块

静态块用于初始化一个类的时候操作用的，和静态变量、静态方法一样，静态块里面的代码只执行一次，且只在初始化类的时候执行。

• 静态资源的加载顺序是严格按照静态资源的定义顺序来加载的

public class A {
    private static int a = B();

    static {
        System.out.println("A.static block");
    }

    public static void main(String[] args) {
        System.out.println("a = " + a);
    }

    public static int B() {
        System.out.println("A.B()");
        return 1;
    }
}

打印结果：

    A.B()
    A.static block
    a = 1

• 静态代码块对于定义在它之后的静态变量可以赋值，不可以访问

public class A {
    static {
        c = 3;
        System.out.println(c);           // Cannot reference a field before it is defined 无法在定义字段之前引用该字段
    }

    private static int c;
}

• 静态代码块是严格按照 父类静态代码块>>子类静态代码块 的顺序加载的，且只加载一次

public class A {
    static {
        System.out.println("A.static block");
    }

    public A() {
        System.out.println("A.constructor()");
    }
}

class B extends A {
    static {
        System.out.println("B.static block");
    }

    public B() {
        System.out.println("B.constructor()");
    }

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

打印结果：

A.static block
B.static block
A.constructor()
B.constructor()
A.constructor()
B.constructor()

两个具有继承关系类的初始化顺序
父类的（静态变量、静态代码块）>> 子类的（静态变量、静态代码块）>> 父类的（变量、初始化块、构造器）>> 子类的（变量、初始化块、构造器）

static修饰类

使用static修饰类时，说明这个类时静态内部类，也就是匿名内部类。

public class A {
    static class C {
        static {
            System.out.println("C.static block");
        }

        public C() {
            System.out.println("C.constructor()");
        }
    }

    static {
        System.out.println("A.static block");
    }

    public A() {
        System.out.println("A.constructor()");
    }

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

打印结果 ：

A.static block
A.constructor()
C.static block
C.constructor()

import static

指定导入某个类中的指定静态资源，不需要类名.资源名，可以直接使用资源名。
注意一下，import static必须这么写，而不能写成static import。

import static java.lang.Math.sin;
import static java.lang.Math.sqrt;
//import static java.lang.Math.*;  导入Math中所有静态资源

public class AA {
    public static void main(String[] args) {
        System.out.println(Math.abs(-2.6));
        // 输出 : 2.6
        System.out.println(sin(2));
        // 输出 : 0.9092974268256817
        System.out.println(sqrt(4));
        // 输出 : 2.0
    }
}