static深入理解

java中static可以修饰成员变量、方法、类、代码块。

1. static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3. static修饰类

一般静态内部类可以用static修饰（java内部类分为四种：常规内部类、静态内部类、局部内部类、匿名内部类）。只能访问外部类的static成员，不能直接访问外部类的实例变量与实例方法。

4. static语句块

可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块。
（1）当一个类中有多个static{}的时候，按照static{}的定义顺序，从前往后执行；
（2）先执行完static{}语句块的内容，才会执行调用语句；

[java]  view plain  copy

1. public class A {  
2.   
3.     public static void main(String args[]){  
4.         System.out.println(5);  
5.     }  
6.     static{  
7.         System.out.println(1);  
8.     }  
9.     static {  
10.         System.out.println(2);  
11.     }  
12.     static {  
13.         System.out.println(3);  
14.     }  
15.     static {  
16.         System.out.println(4);  
17.     }  
18. }//运行结果为1 2 3 4 5   

（3）如果静态变量在定义的时候就赋给了初值(如 static int X=100)，那么赋值操作也是在类加载的时候完成的，并且当一个类中既有static{}又有static变量的时候，同样遵循“先定义先执行”的原则。

[java]  view plain  copy

1. public class A {  
2.         public static int x = 10;  
3.         static{  
4.             System.out.println(x);  
5.             x = 20;  
6.             System.out.println(x);  
7.         }  
8.           
9.         public static void main(String args[]){  
10.            int y = A.x;  
11.         }  
12.     }//结果为10  20  

（4） 通过static来理解类的加载顺序

（4.1）类A中执行main()的时候，首先加载A，B初始化之前，首先加载B

[java]  view plain  copy

1. public class A   {  
2.     static{  
3.         System.out.println("Static A");  
4.     }  
5.     public A(){  
6.         System.out.println("constructor A");  
7.     }  
8.     public static void main(String args[]){  
9.          new B();   
10.     }  
11. }  
12. class B {  
13.     static{  
14.         System.out.println("Static B");  
15.     }  
16.     public B(){  
17.         System.out.println("constructor B");  
18.     }  
19. }  

运行结果：

Static A
Static B
constructor B

（4.2）类A加载之前首先加载其父类

[java]  view plain  copy

1. public class A extends B  {  
2.     static{  
3.         System.out.println("Static A");  
4.     }  
5.     public A(){  
6.         System.out.println("constructor A");  
7.     }  
8.     public static void main(String args[]){  
9.          new A();   
10.     }  
11. }  
12. class B {  
13.     static{  
14.         System.out.println("Static B");  
15.     }  
16.     public B(){  
17.         System.out.println("constructor B");  
18.     }  
19. }  

结果：

Static B
Static A
constructor B
constructor A

（4.2）只有直接定义静态字段X的类才会被初始化

[java]  view plain  copy

1. public class A  extends B{  
2.     static{  
3.         System.out.println("Static A");  
4.     }  
5.     public A(){  
6.         System.out.println("constructor A");  
7.     }  
8.       
9. }  
10. class B {  
11.     public static int x = 10;  
12.     static{  
13.         System.out.println("Static B");  
14.     }  
15.     public B(){  
16.         System.out.println("constructor B");  
17.     }  
18. }  
19. public class C {  
20.     public static void main(String args[]){  
21.          System.out.println(A.x);  
22.     }  
23. }  

结果：

Static B
10