static关键字

静态变量和静态方法

static关键字最基本的用法是：

1、被static修饰的变量属于类变量，可以通过类名.变量名直接引用，而不需要new出一个类来

2、被static修饰的方法属于类方法，可以通过类名.方法名直接引用，而不需要new出一个类来

被static修饰的变量、被static修饰的方法统一属于类的静态资源，是类实例之间共享的，换言之，一处变、处处变。JDK把不同的静态资源放在了不同的类中而不把所有静态资源放在一个类里面，很多人可能想当然认为当然要这么做，但是是否想过为什么要这么做呢？个人认为主要有三个好处：

1、不同的类有自己的静态资源，这可以实现静态资源分类。比如和数学相关的静态资源放在java.lang.Math中，和日历相关的静态资源放在java.util.Calendar中，这样就很清晰了

2、避免重名。不同的类之间有重名的静态变量名、静态方法名也是很正常的，如果所有的都放在一起不可避免的一个问题就是名字重复，这时候怎么办？分类放置就好了。

3、避免静态资源类无限膨胀，这很好理解。

静态方法能不能引用非静态资源？静态方法里面能不能引用静态资源？非静态方法里面能不能引用静态资源？
 public class A
 {
     private int i = 1;
     
     public static void main(String[] args)
     {
         i = 1;
     }
 }

此类中第7行代码出错，静态资源（静态方法）引用非静态资源（实例变量，也成成员变量，成员变量包括静态变量（类变量）和实体变量）是错误的，静态资源在类初始化的时候就被加载，但是实例变量是创建对象以后才会加载，所以静态资源访问不到非静态资源。
静态资源属于类，但是是独立于类存在的。从JVM的类加载机制的角度讲，静态资源是类初始化的时候加载的，而非静态资源是类new的时候加载的。类的初始化早于类的new，比如Class.forName(“xxx”)方法，就是初始化了一个类，但是并没有new它，只是加载这个类的静态资源罢了。所以对于静态资源来说，它是不可能知道一个类中有哪些非静态资源的；但是对于非静态资源来说就不一样了，由于它是new出来之后产生的，因此属于类的这些东西它都能认识。所以上面的几个问题答案就很明确了：

1、静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。

2、静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。

3、非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。

静态块

静态块也是static的重要应用之一。也是用于初始化一个类的时候做操作用的，和静态变量、静态方法一样，静态块里面的代码只执行一次，且只在初始化类的时候执行。静态块很简单，不过提三个小细节：
1、静态资源的加载顺序是严格按照静态资源的定义顺序来加载的。这和周志明老师《深入理解Java虚拟机：JVM高级特性与最佳实践》中类初始化中的说法“<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的”是一致的。
  public class A
  {
      private static int a = B();
      
      static
      {
         System.out.println("Enter A.static block");
      }
      
     public static void main(String[] args)
     {
         new A();
    }
     
     public static int B()
     {
         System.out.println("Enter A.B()");
         return 1;
     }
 }

 输出结果：
Enter A.B()
Enter A.static block


2、静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问。
  public class A
  {
      static
      {
          c = 3;
          System.out.println(c);//Cannot reference a field before it is defined
      }
      
      private static int c;
 }


3、静态代码块是严格按照父类静态代码块->子类静态代码块的顺序加载的，且只加载一次。
 public class A
  {
      static
    {
          System.out.println("A.static block");
      }
      
      public A()
      {
         System.out.println("A.constructor()");
     }
 }


 public 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要修饰一个类，说明这个类是一个静态内部类（注意static只能修饰一个内部类），也就是匿名内部类。像线程池ThreadPoolExecutor中的四种拒绝机制CallerRunsPolicy、AbortPolicy、DiscardPolicy、DiscardOldestPolicy就是静态内部类。

import static
使用JUnit可能会用到，写assert的时候会方便些。import static是JDK1.5之后的新特性，这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名.资源名，可以直接使用资源名。注意一下，import static必须这么写，而不能写成static import

 import static java.lang.Math.*;
 
 public class A
 {
     public static void main(String[] args)
     {
         System.out.println(sin(2.2));
     }
 }


利弊：
1、简化了一些操作，比如静态导入Math下的所有静态资源，在频繁使用Math类下静态资源的地方，可以少些很多“Math.”
2、降低了代码的可读性