final应用说明

1、final用在类上表示该类不能被继承

2、final用在方法上表示该方法不能被重写（override）

3、final用在变量上表示该变量一旦被赋值后它的值将不能被改变



对于final类型的成员变量的初始化方式

1、声明变量时直接赋值

2、在构造方法中完成赋值

3、对于static的final类型的成员变量，只能通过在变量声明时直接赋值，不能通过在构造方法中完成赋值，因为static的变量是优先于构造方法执行的，而static的final类型的成员变量在声明时有点特殊：不会被设置成默认的值（如int a;本应该在声明时会自动设置成默认的值"0"）

4、对于final类型的引用变量来说，所谓的不能改变指的是该引用不能被改变，而不是该引用的内容不能被改变

在构造方法中完成赋值的注意点：

如果一个类有多个构造方法，那么必须在每个构造方法中对final类型的成员变量赋值，否则将通不过编译

java 代码

   1. package com.test;  
   2.  
   3. public class FinalTest {  
   4.       
   5.     private final int a;  
   6.     private String name;  
   7.       
   8.     public FinalTest()  
   9.     {  
  10.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  11.         a = 3;  
  12.     }  
  13.       
  14.     public FinalTest(String name)  
  15.     {  
  16.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  17.         a = 5;  
  18.         this.name = name;  
  19.     }  
  20.       
  21.     public static void main(String[] args){  
  22.         FinalTest ft = new FinalTest();  
  23.         FinalTest ft2 = new FinalTest("hello");  
  24.     }  
  25. }  


java 代码

   1. package com.test;  
   2.  
   3. public class FinalTest {  
   4.       
   5.     private static final int a = 3;  
   6.     //private final int a;  
   7.     private String name;  
   8.       
   9.     public FinalTest()  
  10.     {  
  11.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  12.         //a = 3;  
  13.     }  
  14.       
  15.     public FinalTest(String name)  
  16.     {  
  17.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  18.         //a = 5;  
  19.         this.name = name;  
  20.     }  
  21.       
  22.     public static void main(String[] args){  
  23.         FinalTest ft = new FinalTest();  
  24.         FinalTest ft2 = new FinalTest("hello");  
  25.     }  
  26. }  


java 代码

   1. package com.test;  
   2.  
   3. public class FinalTest {  
   4.       
   5.     private static final StringBuffer s = new StringBuffer();  
   6.     //private static final int a = 3;  
   7.     //private final int a;  
   8.     private String name;  
   9.       
  10.     public FinalTest()  
  11.     {  
  12.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  13.         //a = 3;  
  14.     }  
  15.       
  16.     public FinalTest(String name)  
  17.     {  
  18.         //如果final成员变量未在声明时直接赋值，那么每个构造方法里必须要对它进行赋值，否则将通不过编译  
  19.         //a = 5;  
  20.         this.name = name;  
  21.     }  
  22.       
  23.     public static void main(String[] args){  
  24.         //此时可以通过编译，因为改变的只是引用内容，而不是引用的内存地址，但是如果这里的代码是 s = new StringBuffer();就通不过编译了，因为如果这样的话，s指向了新的引用地址，这是final所不允许的  
  25.         s.append("hello");  
  26. //      FinalTest ft = new FinalTest();  
  27. //      FinalTest ft2 = new FinalTest("hello");  
  28.     }  
  29. }