static

static是什么

static是Java中的一个关键字，可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

• 方便在没有创建对象的情况下来进行调用（方法/变量）。

static怎么用

1. 修饰方法
   也就是静态方法，特点是不依赖与任何对象就可以进行访问。使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗。
   在静态方法中不能访问类的非静态成员变量和非静态成员方法，在非静态成员方法中是可以访问静态成员方法/变量的；

public class HelloHandler {
    public static String parse() {
        return "静态方法";
    }

    public String getValue() {
        return HelloHandler.parse();
    }
}

2. 修饰变量
   static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
   static成员变量的初始化顺序按照定义的顺序进行初始化。

public class HelloController {
    /**定义常量时使用*/
    private static String url = "http://www.baidu.com";

    public void postUrl() {
        String postUrl = url;
    }
}

3. static代码块
   它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行；
   该类不管创建多少对象，静态代码块只执行一次；
   一个类中的静态代码块可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果静态代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

public class HelloController {
    static Date date;
    static {
        date = new Date();
    }

    public void getDate() {
        System.out.println(date);
    }
}

4. 静态引入
   这个很不爽，最好别用，虽然写法简单，但是易读性差；

静态代码加载顺序

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

注意加载顺序，先加载类，父先子后，再调用构造

类加载的时机

类从被加载到虚拟机内存到卸载出内存主要包括 加载，验证，准备，解析，初始化，使用和卸载，验证，准备和解析统称为连接。
在5种情况下，类必须被初始化
1.当遇到new，getstatic，putstatic，invokestatic时；
2.使用反射调用类时；
3.当初始化子类存在父类时，父类需要初始化；
4.要执行包含main()方法的类时，虚拟机会先初始化这个主类；
5.使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic,REF_putStatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化时，需要先对其初始化；
除此5中外都不会触发类的初始化操作。

class FinalStatic {

    public static final int A = 4 + 4;
    static {
        System.out.println("如果执行了，证明类初始化了……");
    }
}

public class HelloHandler {
    public static void main(String[] args) {
        System.out.println(FinalStatic.A);
    }
}

这个输出结果只有 8，因为没有初始化FinalStatic这个类，如果

class FinalStatic {
    public static final int A = 4 + new FinalValue().getB();
    static {
        System.out.println("如果执行了，证明类初始化了……");
    }
}

class FinalValue {
    public static final int B = 1;
    public int getB() {
        return B;
    }
}

public class HelloController {
    public static void main(String[] args) {
        System.out.println(FinalStatic.A);
    }

}

如果执行了，证明类初始化了……
5
这样就会触发类初始化

class Singleton {

    public static Singleton singleton = new Singleton();
    public static int a;
    public static int b = 0;

    private Singleton() {
        super();
        a++;
        b++;
    }

    public static Singleton GetInstence() {
        return singleton;
    }
}

public class HelloHandler {

    public static void main(String[] args) {
        System.out.println(Singleton.a);
        System.out.println(Singleton.b);
    }

}

a = 1 b = 0

总结

为什么要总结这个呢，因为在开发过程中，往往忽略了性能方面的思考，小小得一个static 就能改善代码的运行效率，提高性能，所以归纳是必须的。