不可变类和缓存实例的不可变类

不可变类:创建该类实例后，该类的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()方法创建对象则会缓存该方法创建的对象