《疯狂Java讲义精粹》读书笔记8 不可变类

=======================《疯狂Java讲义精粹》读书笔记8 ------ 不可变类========================

　　当我们想创建一个实例后，要求该实例的成员不再发生改变的时候，就需要使用不可变类(immutable).

　　创建自定义的不可变类，应遵守如下规则：

　　　　· 使用private 和 final修饰该类的成员变量
　　　　· 提供带参数构造器，用于传入参数来初始化对象的成员变量
　　　　· 为该类提供getter方法，但不要提供setter方法
　　　　· 如果有必要重写Object 类的hashCode和equals方法

　　下面的程序试图定义一个不可变类(Person)，但因为包含一个引用类型的成员，且这个引用是可变类，所以导致了Person类也变成了可变类：

/**
* 一个失败的不可变类
* @author 《疯狂的Java讲义精粹》
*/
class Name{
    private String firstName;
    private String lastName;
    
    //构造方法
    public Name(){}
    public Name(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    //getter and setter
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
}

public class Person {
    private final Name name;
    
    //构造方法
    public Person(Name name){
        this.name = name;
    }
    //只提供getter方法
    public Name getName(){
        return name;
    }
    
    public static void main(String[] args) {
        Name n = new Name("Cocoon","Fan");
        Person p = new Person(n);
        
        //将输出CocoonFanFan
        System.out.println(p.getName().getFirstName()+p.getName().getLastName());
        
        //这时候依然可以改变Person对象的属性所指向的内容值，只是不能改变Person对象的属性
        //p.name = null;//这里编译不能通过
        p.getName().setFirstName("我的名字已经被改了！");
        //将输出：我的名字已经被改了！Fan
        System.out.println(p.getName().getFirstName() + p.getName().getLastName());
    }
}

　　很明显，Person对象的name的firstName已经被改了，这不符合要求创建一个不可变类的初衷。

　　下面对Person类做一些修改，使其满足不可变类的要求：

/**
 * 修改后的Person类满足不可变类的要求
 * @author 《疯狂的Java讲义精粹》
 *
 */
class Name{
    private String firstName;
    private String lastName;
    
    //构造方法
    public Name(){}
    public Name(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    //getter and setter
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
}

public class Person {
    private final Name name;
    
    public Person (Name name){
        //设置name 为临时创建的Name 对象，该对象的firstName 和 lastName与
        //传入的name对象的firstName 和 lastName相同
        this.name = new Name(name.getFirstName(), name.getLastName());
    }
    public Name getName(){
        //返回一个匿名对象，该对象的firstName 和 lastName 与该对象里的name 的firstName
        //和lastName相同
        return new Name(name.getFirstName(),name.getLastName());
    }
    
    public static void main(String[] args) {
        Name n = new Name("Cocoon","Fan");
        Person p = new Person(n);
        
        //将输出: CocoonFanFan
        System.out.println(p.getName().getFirstName()+p.getName().getLastName());
        
        //这时候改变不了Person对象的属性了
        p.getName().setFirstName("我的名字已经被改了！");
        //将输出：CocoonFan
        System.out.println(p.getName().getFirstName() + p.getName().getLastName());
        
    }
}

　　不可变类的实例状态不可改变，可以很方便的、地被多个对象共享。如果程序要使用相同的不可变类实例，则应考虑缓存这种不可变类的实例，因为重复创建相同的对象对系统的开销会很大。如果可能，应将已经创建的不可变类的实例进行缓存。

　　本例将使用一个数组来作为缓存池，从而实现一个缓存实例的不可变类：

/**
 * 缓存实例不可变类
 * @author 《疯狂Java讲义精粹》
 * @date 3/7/2013
 */

class CacheImmutale {
    private static int MAX_SIZE = 10;//缓存的大小
    //穿件缓存池
    private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
    
    //记录缓存实例在缓存中的位置
    private static int pos = 0;
    
    private final String name;
    private CacheImmutale(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    public static CacheImmutale valueOf(String name){
        //遍历缓存对象
        for (int i = 0; i < MAX_SIZE; i++) {
            //如果已经存在相同的缓存实例，直接返回该缓存实例
            if(cache[i] != null && cache[i].getName().equals(name)){
                return cache[i];
            }
        }
        
        //如果缓存池已满
        if(pos == MAX_SIZE){
            //把缓存的第一个对象覆盖
            cache[0] = new CacheImmutale(name);
            pos = 1;
        } else {
            //把新创建的对象缓存起来
            cache[pos++] = new CacheImmutale(name);
        }
        return cache[pos-1];
    }
    
    //重写equals方法
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj != null && obj.getClass() == CacheImmutale.class){
            CacheImmutale c = (CacheImmutale)obj;
            return name.equals(c.getName());
        }
        return false;
    }
    
    //重写hashCode 方法
    public int hashCode(){
        return name.hashCode();
    }
}


public class TestCacheImmutale{
    public static void  main(String []args){
        CacheImmutale c1 = CacheImmutale.valueOf("Hello");
        CacheImmutale c2 = CacheImmutale.valueOf("Hello");
        
        //将输出true
        System.out.println("c1 == c2:" + (c1==c2));
    }
}

　　Java提供的java.lang.Integer类，就采用了与上面CacheImmutable类类似的处理策略，如果采用new 构造器来创建Integer对象，则每次返回全新的Integer对象，如果采用valueOf()方法来创建对象，则会缓存该方法创建的对象。应该注意的是Integer只是缓存-128~127之间的Integer 对象，例如两次通过Integer.valueOf(200);方法生成的对象就是两个不同的对象。