不可变类
是指创建该类的实例后，该实例的实例变量是不可改变的。java中已有类例如Double和String等。
如果需要创建自定义的不可变类，遵守如下规则：
- 使用private和final修饰符来修饰该类的成员变量；
- 提供带参数的构造器，根据传入的参数来初始化类里的成员变量；
- 仅为该类的成员变量提供getter方法，不要提供setter方法，因为普通方法无法修改final修饰的成员变量；
- 如果有必要，重写Object类的hascode()和equals()方法。equals方法根据关键成员变量来作为两个对象是否相等的标准，除此之外，还应该保证两个用equals方法判断为相等的对象的hashCode()也相等。
package org.westos.practice;
public class String01 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
//99162322
//99162322
}
}
其中Object的equals方法比较的是两个对象的地址值，而String重写了equals这个方法，比较的是两个对象的内容值。
自定义一个不可变类Address：
package org.westos.practice;
public class Address {
private final String detail;
private final String postCode;
public Address() {
this.detail = "";
this.postCode = "";
}
public Address(String detail, String postCode) {
this.detail = detail;
this.postCode = postCode;
}
//仅为两个实例变量提供getter方法
public String getDetail() {
return detail;
}
public String getPostCode() {
return postCode;
}
//重写equals方法，判断两个对象是否相等
public boolean equals(Object obj){
//
if(this==obj){
return true;
}
//判断传入的对象是否为该类的对象并且该对象被初始化
//如果不是，则不必判断下面的，直接返回false
if(obj!=null&&obj.getClass()==Address.class){
Address ad=(Address)obj;
//当detail和pastCode相等时可以认为两个Address对象相等
if(this.getDetail().equals(ad.getDetail())&&
this.getPostCode().equals(ad.getPostCode())){
return true;
}
}
return false;
}
public int hashCode() {
return detail.hashCode()+postCode.hashCode()*31;
}
}
如果想定义一个不可变的类，但是该类中的成员变量是一个引用类型的成员变量，而且这个引用类是可变类，所以导致不可变类也变成了可变类；
实例：
package org.westos.practice;
public class Name {
private String firstname;
private String lastname;
public Name(String firstname, String lasename) {
this.firstname = firstname;
this.lastname = lasename;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lasename) {
this.lastname = lasename;
}
}
package org.westos.practice;
public class Person {
private final Name name;
public Person(Name name) {
this.name = name;
}
public Name getName(){
return name;
}
public static void main(String[] args) {
Name n=new Name("孙","悟空");
Person person = new Person(n);
//Person对象的name的firstname的值为“悟空”
System.out.println(person.getName().getLastname());
//改变Person对象的name的firstname值
n.setLastname("八戒");
System.out.println(person.getName().getLastname());
}
}
从上面的代码可以看到本来想定义的不可变类Person的成员变量name的值竟然可以被重新改变，这显然不符合不可变类的定义。
所以为了保持Person对象的不可变性，必须保护好Person对象的引用类型的成员变量：
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());
}
}
改写了设置name实例变量的方法，也改写了name的getter方法，当程序向Person构造器里传入一个Name对象时，该构造器创建Person对象时并不是直接利用已有的Name对象，而是重新创建一个Name对象来赋给Person对象的name实例变量。name，让程序无法访问到Person对象的name成员变量，也无法利用name成员变量来改变Person对象了。其实是不让实际传入的Name对象的setter方法被外界调用，而只获取外界传入用来初始化Name对象的值。
缓存实例的不可变类
不可变类的实例状态不可改变，可以很方便被多个对象共享。如果程序中经常需要使用相同的不可变类实例，则应该考虑缓存这种不可变类的实例。
例如Java提供的java.lang.Integer类，如果采用new构造器来创建Integer对象，则每次会返回全新的Integer对象；如果采用valueOf()方法来创建Integer对象，则会缓存该方法创建的对象。
package org.westos.practice;
public class IntegerCacheTest {
public static void main(String[] args) {
//生成新的integer对象
Integer i1 = new Integer(6);
//生成新的Integer对象并缓存
Integer i2 = Integer.valueOf(6);
//直接从缓存中取出已缓存的对象来使用
Integer i3=Integer.valueOf(6);
System.out.println(i1==i2);//false
System.out.println(i3==i2);//true
//由于Integer只缓存-128~127之间的值
//超出范围的值将不会被缓存
Integer i4=Integer.valueOf(222);
Integer i5=Integer.valueOf(222);
System.out.println(i4==i5);//false
}
}
自定义一个缓存实例的不可变类：
package org.westos.practice;
public 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;
public 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 instanceof CacheImmutale){
CacheImmutale ci=(CacheImmutale)obj;
return name.equals(ci.getName());
}
return false;
}
@Override
public int hashCode() {
return name.hashCode();
}
}
package org.westos.practice;
public class CacheImmutaleTest {
public static void main(String[] args) {
CacheImmutale ci1 = new CacheImmutale("hello");
CacheImmutale ci2 =CacheImmutale.valueOf("hello");
CacheImmutale ci3 =CacheImmutale.valueOf("hello");
System.out.println(ci1==ci2);//false
System.out.println(ci3==ci2);//true
}
}
当缓存池满的时候，将新创建的对象覆盖缓存数组的第一个对象，以后的新对象依次覆盖pos+1为索引的对象。
这种缓存机制适用于频繁使用的类，可以节省内存空间，而对于只是用一次，或重复概率不大的类，缓存实例就是弊大于利，所以不能盲目使用缓存实例
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
