不可变类:其实例不可以被修改的类.每个实例中包含的所有信息都必须在创建该实例的时候就提供,并在对象的整个生命周期内固定不变.
常见的不可变类: String, 基本类型的包装类, BigInteger, BigDecimal.
不可变类比可变类 更加易于设计,实现和使用. 不容易出错,且更加安全.
不可变类5条规则:
- 不要提供任何会修改对象状态的方法;
- 保证类不会被扩展;(2.1 final 类 2.2 构造器私有,公有的静态工厂类)
- 所有域都是final的.
- 所有域都是私有的.
- 确保对于任何可变组件的互斥访问.(类具有指向可变对象的域,则必须确保该类的客户端无法获得指向这些对象的引用)
不可变对象比较简单.
不可变对象本质上是线程安全的, 它们不要求同步.
不可变对象可以被自由共享. => 不需要进行保护性拷贝. => 不需要clone() 和 拷贝构造器.
不可变的类可以提供一些静态工厂,它们把频繁被请求的实例缓存起来,从而当现有实例可以符合请求时,就不必创建新的实例.
不仅可以共享不可变对象,甚至可以贡献它们的内部信息:
例如:BigInteger
public class BigInteger extends Number implements Comparable<BigInteger> {
final int signum; // 符号
final int[] mag; // 数值
BigInteger(int[] magnitude, int signum) {
this.signum = (magnitude.length == 0 ? 0 : signum);
this.mag = magnitude;
if (mag.length >= MAX_MAG_LENGTH) {
checkRange();
}
}
....
/**
* Returns a BigInteger whose value is {@code (-this)}.
* @return {@code -this}
*/
public BigInteger negate() {
return new BigInteger(this.mag, -this.signum);
}
}
negate 方法产生一个新的BigInteger,其中数值是一样的,符号则是相反的.
它并不需要拷贝数组.新建的BigInteger也指向原始实例中的一个内部数组.
不可变对象为其他对象提供了大量的构件.
不可变类真正唯一的缺点是:对于每个不同的值都需要一个单独的对象.
例如, BigInteger moby 的长度有上百万位长.
moby = moby.flipBit(0);
操作将会创建一个新的BigInteger对象,虽然它与原来的对象几百万位里只差了一位.
BigSet 是可变的,代表一个任意长度的位序列.
当使用不可变类会导致性能瓶颈时(例如String 拼接), 这时比较好的方法就是提供一个"公有的可变配套类"(StringBuilder).
让类成为不可变, 除了让类成为final的, 还有一种方法就是: 让类的所有构造器都变成私有的(或包级私有的),并添加公有的静态工厂类来代替公有的构造器:
// Immutable class with static factories instead of constructors
public class Complex {
private final double re;
private final double im;
private Complex(double re, double im) {
this.re = re;
this.im = im;
}
public static Complex valueOf(double re, double im) {
return new Complex(re, im);
}
}
这种写法的另外一个好处是, 当你需要添加另外一种"基于极坐标创建复数"的方式, 如果使用构造器,因为函数名一样, 且参数都是两个double值,这样会很凌乱. 使用静态工厂方法就比较容易:
public static Complex valueOfPolar(double r, double theta){
return new Complex(r * Math.cos(thera), r * Math.sin(theta));
}
总之,坚决不要为每一个get方法编写一个set方法. 除非有很好的理由要让类成为可变的类.否则就不应该是可变的.
不可变的类有许多优点,唯一的缺点就是在特定的情况下存在潜在的性能问题.
如果类不能被做成是不可变的,仍然应该尽可能的限制它的可变性.因此,除非有令人信服的理由要使域变成非final的,否则应该使每个域都是final的.