Java_final关键字，不可变类，缓存不可变类实例（缓存池技术）

最新推荐文章于 2019-07-12 21:37:03 发布

转载最新推荐文章于 2019-07-12 21:37:03 发布 · 558 阅读

java基础专栏收录该内容

29 篇文章

订阅专栏

本文详细介绍了Java中final关键字的使用方法，包括final变量、方法和类的特点，如何创建不可变类及其实例缓存策略。

1. final变量：final修饰的变量一旦获得了初始值之后就不可被改变。final可以修饰成员变量，局部变量，形参。

1.1 final成员变量：final修饰的类属性(static)可以在静态初始化块或声明时指定初始值；final修饰的实例属性可以在非静态初始化块，构造器或声明时指定初始值。

[html]view plaincopy 
   
print?
 class TestFinal {  
     final int a = 1;    //声明时指定初始值  
     final int b;  
     final int c;  
     static final String NAME_1 = "MengLei"; //声明时指定初始值  
     static final String NAME_2;  
       
     {  
         b = 2;  //使用非静态初始化块为实例属性b指定初始值  
     }  
     TestFinal() {  
         c = 3;  //使用构造器为实例属性c指定初始值  
     }  
     static {  
         NAME_2 = "MengChen";    //使用静态初始化块为类属性指定初始值  
     }  
 }  

1.2 final修饰局部变量：如果final休斯的局部变量在声明时没有指定初始值，则可以在后面代码中指定，但只能一次。

[html]view plaincopy 
   
print?
 public class Temp {  
     public static void main(String[] args) {  
         final int a = 1;    //声明时指定初始值  
         final int b;  
         b = 2;  //后来指定初始值  
         b = 3;  //报错：不能重复指定       
     }  
     public void test(final int a) {  
         a = 3;  //报错：不能对final形参赋值  
     }  
 }  

1.3 final修饰基本类型变量和引用类型变量的区别：当final修饰基本类型变量时，不能对基本类型变量重新赋值，因此变量值不能被改变；但对于引用变量而言，它保存的仅仅是一个引用，final只保证这个引用不能指向别的地址空间，但是被引用的对象的内容是可以改变的。

2. final方法：final修饰的方法不能被重写。但是可以重载。

3. final类：final修饰的类不可以有子类。

4. 不可变类：创建类的实例后，实例的属性是不可改变的。Java提供的包装类和String类都是不可变类。

[html]view plaincopy 
   
print?
 Double d = new Double(1.1);  
 String s = new String("ML");  

上面这两个类通过传入的参数实例化各自的对象，但是他们的属性是不可改变的。

如果需要创建自定义的不可变类，需要：

a. 使用private和final修饰成员属性。

b. 提供带参数的构造器，并通过传入的参数初始化成员属性。

c. 仅为类属性提供getter方法，不要提供setter方法。

d. 最好重写Object类的hashCode和equals方法。equals方法根据关键属性作为判断相等的标准，此外还需要保证两个用equals方法判断相等的对象的hashCode也相等。

5. 缓存不可变类实例：不可变类的实例不可改变，可以很方便的被多个对象共享。如果程序经常需要使用相同的不可变类实例，则应该考虑缓存这种不可变类的实例。毕竟多次重复创建相同对象没有太大意义，而且加大了系统开销。

[java]view plaincopy 
   
print?
 public class Temp {  
     public static void main(String[] args) {  
         CacheImmutale ci1 = CacheImmutale.valueOf("MengLei");  
         CacheImmutale ci2 = CacheImmutale.valueOf("MengLei");  
         System.out.println(ci1==ci2);   //输出：true，说明两者是同个对象  
     }  
 }  
   
 class CacheImmutale {  
     private final String name;  
     private static CacheImmutale [] cache = new CacheImmutale [10];   //缓存池，保存10个实例  
     private static int pos = 0;   //记录最新创建的缓存实例在缓存数组中的位置  
       
     public CacheImmutale(String name) {   
         this.name = name;   //name通过构造器指定初始值  
     }  
     public String getName() {  
         return this.name;  
     }  
     public static CacheImmutale valueOf(String value) {  
         for (int i=0;i<pos;i++) {    //遍历缓存对象  
             if (cache[i] != null && cache[i].getName().equals(value)) { //如果发现相同的对象，则返回  
                 return cache[i];  
             }  
         }  
         if (pos == 10) {  
             pos = 0;  
             cache[pos++] = new CacheImmutale(value);    //如果没有在缓存池中发现相同的对象，但缓存池满了，则建立新对象，添加到缓存池的第一个对象（先进先出），并返回该对象  
             return cache[pos-1];  
         }  
         else {  
             cache[pos++] = new CacheImmutale(value);    //如果没有在缓存池中发现相同的对象，而且缓存池也没有满，则建立新对象，添加进缓存池，并返回该对象  
             return cache[pos-1];  
         }  
     }  
     public boolean equals(Object obj) {   //重写equals方法，name属性相等即为相等  
         if (obj instanceof CacheImmutale) {  
             CacheImmutale ci = (CacheImmutale)obj;  
             if (ci.getName().equals(this.getName()))  
                 return true;  
             else  
                 return false;  
         }  
         else  
             return false;  
     }  
     public int hashCode() {   //重写hashCode方法  
         return this.getName().hashCode();  
     }  
 }  