Java中static关键字的含义和使用

static关键字标识的块在且仅在类被加载时执行一次，一般用来初始化静态变量和调用静态方法（不用创建类的情况下调用方法和变量）。可以用来修饰方法和变量，还可以修饰代码块以优化性能。
被static关键字修饰的方法和变量不需要通过对象访问，只要类被加载了就可以通过类名去访问。

static方法

---

由于static方法发可以不依赖特定实例使用，因此方法中没有this。因此，static方法中不能访问类的非静态成员变量和非静态方法（否则通过依赖的传递性还是要依赖某个实例）。当然，在非静态成员方法中还是可以访问静态成员变量/方法的。

public class MyObject {
    private static String str1 = "staticProperty";
    private String str2 = "property";

    public static void print(){
        System.out.println(str1);
    }

    public void print2(){
        System.out.println(str1);
        System.out.println(str2);
    }
}

public class Test2 {
    public static void main(String[] args){
        MyObject.print();

        MyObject mo = new MyObject();
        mo.print2();
    }
}

运行Test2，得到输出。

可见不创建实例调用静态方法以及非静态方法调用静态变量是成功的。

Java中最常见的静态方法就是main了，因为程序执行main方法时显然没有任何对象被创建。
与此相对应的是构造器也一定在类被创造前执行，但不能认为构造器是static方法，因为其中可以使用this。事实上，构造器不是类方法。

static变量

---

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。
下例说明静态变量只有一个副本，从任何实例改变静态变量的值，所有实例的该值均会改变（事实上，不存在“实例的该值”这个概念，因为该值并不依赖某个实例存在，只是通过某个实例访问它罢了，也可以不通过实例访问它）。

public class MyObject {
    static double SDouble = 0;;

    public void incr(){
        SDouble++;
    }
}

public class Test2 {
    public static void main(String[] args){
        MyObject mo1 = new MyObject();
        MyObject mo2 = new MyObject();
        System.out.println(mo1.SDouble);
        System.out.println(mo2.SDouble);

        mo1.incr();
        System.out.println(mo1.SDouble);
        System.out.println(mo2.SDouble);

    }
}

运行得到结果：

static语句块

---

可以置于类中任何地方，一个类中也可以有多个该语句块，类加载时按照语句块顺序执行。在且仅在类加载时执行一次。

public class Test {
    public static int x = 100;
    public final static int y = 200;

    public  Test(){
        System.out.println("Test constructor executed!");
    }

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

    public static void display(){
        System.out.println("static method executed!");
    }

    public void display_1(){
        System.out.println("instance method executed!");
    }
}

public class StaticBlockTest {
    public static void main(String[] args){
        try{
            Class.forName("Test");
            Class.forName("Test");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

StaticBlockTest类的执行结果为：

可见static语句块仅执行了一次。

既然仅在类加载时执行一次，那么什么是类加载的时候呢？有如下情况：

• Class.forName()显式加载
• 实例化一个类的时候
• 调用该类静态方法的时候
• 调用该类静态变量的时候
• 加载子类时会自动加载父类

值得注意的是：

• 调用类的静态常量时并不会加载类
• 使用Class.forName()的时候也可以选择不加载类，在参数中加入Class.forName(“classname”,false,StaticBlockTest.class.getClassLoader())即可

相关常见面试笔试题

---

1.这段代码的输出是什么？

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();
    }
}

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

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

运行结果：

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

2.下面这段代码的输出结果？

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();
    }
}

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

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

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

    public MyClass(){
        System.out.println("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的构造器。

static关键字的应用举例

---

JDBC中应用

java中有一个DriverManager类，用于管理各种数据库驱动程序、建立新的数据库连接。DriverManager类包含一些列Drivers类，这些Drivers类必须通过调用DriverManager的registerDriver()方法来对自己进行注册。
所有Drivers类都必须包含有一个静态方法，利用这个静态方法可以创建该类的实例，然后在加载该实例时向DriverManage类进行注册。我们经常用Class.forName()对驱动程序进行加载，那么注册就发生在这条语句的执行过程中，前面说的Drivers的静态方法是放在static{}中的，当对驱动程序进行加载的时候，会执行该static{}，便完成了注册。

hibernate中的应用

hibernate中的SessionFactory是一个重量级的类，创建该类的对象实例会耗费比较多的系统资源，如果每次需要时都创建一个该类的实例，显然会降低程序的执行效率，所以经常将对该类的实例化放在一个static{}中，只需第一次调用时执行，提高程序的执行效率，如下:

static {
  try {
       configuration.configure(configFile);
       sessionFactory = configuration.buildSessionFactory();
  } catch (Exception e) {
       System.err.println("%%%% Error Creating SessionFactory %%%%");
       e.printStackTrace();
  }
}

参考文章：
Java中的static关键字解析
java中static{}语句块详解