不可變類和緩存執行個體的不可變類

不可變類:建立該類執行個體後，該類的field是不可改變的

class Name{
	private String Name;
	public Name(){}
	publlic Nanme(String Name){
		this.Name=Name;
	}
	public void setName(String Name){
		this.Name=Name;
	}
	public String getName(){
		return Name;
	}
}
public class Person{
	//使用final讓name引用不可改變
	private final Name name;
	public Person(Name name){
		//設定name為臨時建立的Name對象
		this.name=new Name(name.getName());
	}
	public Name getName(){
		//傳回一個匿名對象，改對象和field各個字段相同
		return new Name(name.getName());
	}
}
           

不可變類的執行個體狀态是不可改變的，可以很友善的被對個對象共享，如果程式經常需要使用相同的不可變執行個體，則應 該考慮緩存這種不可變類的執行個體，畢竟重複建立沒有太大的 意義

class CacheImmutale{
	private static int MAX_SIZE=10;
	//使用數組來緩存執行個體
	private static CacheImmutale[]cache=new CacheImmutale[MAX_SIZE];
	//記錄緩存執行個體在緩存中的位置，cache[pos-1]是最新緩存的執行個體
	private static int pos=0;
	private final String name;
	//程式使用private修飾符來隐藏構造器，是外部無法通過new
	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{
			//把建立起來的對象緩存起來，pos+1
			cache[pos++]=new CacheImmutale(name);
		}
		return cache[pos-1];

	}
	public boolean equals(Object obj){
		if(this==obj){
			return true;
		}
		if(obj!=null&& obj.getclass()==CacheImmutale.class){
			CacheImmutale ci=(CacheImmutale)obj;
			return name.equals(ci.getName());
		}
		return false;
	}
	public int hashCode(){
		return name.hashCode();
	}
}
public class CacheImmutaleTest{
	public static void main(String []args){
		CacheImmutale c1=CacheImmutale.valueof("hello");
		CacheImmutale c2=CacheImmutale.valueof("hello");
		//true
		System.out.println(c1==c2);
	}
}
           

Java中的Integer類就采用了與CacheImmutale類相同的處理政策，如果采用new構造器來建立對象，則每次傳回都是 新的；使用valueof()方法建立對象則會緩存該方法建立的對象