Java --- static / final 常量初始化

1.static修饰一个属性字段,那么这个属性字段将成为类本身的资源,public修饰为共有的,可以在类的外部通过test.a来访问此属性;在类内部任何地方可以使用.如果被修饰为private私有,那么只能在类内部使用.

public class Test{       public static int a;       private Test(){       a=0;      }      }

如果属性被修饰为static静态类资源,那么这个字段永远只有一个,也就是说不管你new test()多少个类的对象,操作的永远都只是属于类的那一块内存资源.例如:

Test t1=new Test();     t1.a=10;     Test t2=new Test();     System.out.println(t1.a);     System.out.println(t2.a);           System.out.println(Test.a);

结果是3个0

2.final 用于声明属性，方法和类，分别表示属性一旦被分配内存空间就必须初始化并且以后不可变，方法一旦定义必须有实现代码并且子类里不可被覆盖，类一旦定义不能被定义为抽象类或是接口,因为不可被继承。

而你的代码里对final修饰的属性进行了修改,所以错误.

3. 被final修饰而没有被static修饰的类的属性变量只能在两种情况下初始化:

a.在它被定义的时候,例:

public class Test{         public final int a=0;         private Test(){         }            }

b.在构造函数里初始化,例:

public class Test{         public final int a;         private Test(){             a=0;         }            }

4.同时被final和static修饰的类的属性变量只能在两种情况下初始化:

a.在它被定义的时候,例:

public class Test{         public final int a=0;         private Test(){         }            }

b.在类的静态块里初始化,例:

public class Test{         public final int a;         static{             a=0;         }            }

5.分析第三第四原因:

第三条:当这个属性被修饰为final,而非static的时候,它属于类的实例对象的资源,当类被加载进内存的时候这个属性并没有给其分配内存空间,而只是定义了一个变量a,只有当类被实例化的时候这个属性才被分配内存空间,而实例化的时候同时执行了构造函数,所以属性被初始化了,也就符合了当它被分配内存空间的时候就需要初始化,以后不再改变的条件.

第四条:当类的属性被同时被修饰为static和final的时候，他属于类的资源,那么就是类在被加载进内存的时候(也就是应用程序启动的时候)就要已经为此属性分配了内存,所以此时属性已经存在,它又被final修饰,所以必须在属性定义了以后就给其初始化值.而构造函数是在当类被实例化的时候才会执行,所以用构造函数,这时候这个属性没有被初始化.程序就会报错.而static块是类被加载的时候执行,且只执行这一次,所以在static块中可以被初始化.

java代码：

public   class  FinalOriginalTest {  

2.     private   final   int  a;  
3.     private  String name;  
4.     public  FinalOriginalTest(){  
5.         a = 3 ;  
6.     }  
7.     public  FinalOriginalTest(String name){  
8.         this .name = name;  
9.     }  
10.     public   static   void  main(String[] args){  
11.         FinalOriginalTest ft = new  FinalOriginalTest();  
12.         FinalOriginalTest ft1 = new  FinalOriginalTest( "hello" );  
13.     }  
14. }  

[java] view plain copy

1. public class FinalOriginalTest {  
2.     private final int a;  
3.     private String name;  
4.     public FinalOriginalTest(){  
5.         a = 3;  
6.     }  
7.     public FinalOriginalTest(String name){  
8.         this.name = name;  
9.     }  
10.     public static void main(String[] args){  
11.         FinalOriginalTest ft = new FinalOriginalTest();  
12.         FinalOriginalTest ft1 = new FinalOriginalTest("hello");  
13.     }  
14. }  

问题1:上面的程序能否编译通过？如果不能，请说明理由。 
解答:不能编译通过，可能没有初始化变量a。因为对于final类型的成员变量的初始化，在构造方法中完成赋值，如果一个类有多个构造方法，就要 保证在每个构造方法中都要完成对该final类型变量的初始化工作。所以需要在public FinalOriginalTest(String name)构造方法中给a赋值。 
注意：final可以用在类、方法、变量上。 
     1、final用在类上，表明当前类它不能被继承，没有子类。 
     2、final用在方法上，表明当前方法不能被override，不能被重写。 
     3、final用在变量上，表明当前变量是一个终态的变量，是一个常量，这个变量的值一但被赋值后就不能被改变了。 
     对于final类型的成员变量的初始化方式: 
     1、声明变量时直接赋值 
     2、在构造方法中完成赋值，如果一个类有多个构造方法，就要保证在每个构造方法中都要完成对该final类型变量的初始化工作。 

问题2:上面的程序中，修正问题1之后，将private final int a;改为private static final int a;能否编译通过？如果不能，请说明理由。 
解答:不能编译通过，因为a是静态变量，在这个类还没有实例化的时候，它的值就已经有了。所以对于一个int类型的static final类型的变量a来说，我们只能在声明的时候就给它赋值private static final int a = 3;然后把构造方法里面的赋值给注释掉，这样编译就能通过了。 

总结：对于final类型的变量，对于不加static我们可以有两种方式给它赋值:声明变量时直接赋值;在构造方法中完成赋值，如果一个类有多 个构造方法，就要保证在每个构造方法中都要完成对该final类型变量的初始化工作。对于一个变量既是final又是static的，我们必须在声明变量 时直接赋值。