如果一个对象的状态在它构建之后就不能被更改，我们就认为它是不可更改的对象。对不可更改对象的最大限度的依赖被广泛认为是一种建立简单、可信赖代码的好策略。
不可更改对象在并发的代码中显得格外有用。因为既然你不能更改它的状态，那线程混淆和内存不一致都不可能出现了。
开发人员总是不太乐意使用不可更改对象，因为他们担心创建一个新对象的代价会超过更新一个现有对象。对象新建的代价总是被过高估计，并且这个代价还可以被不可变对象的一些便利性所折中。包括减少垃圾收集的额外开销，和本来需要的用来保护可变更对象的代码。
接下来的一小节使用了一个类——它的实例是可更改的，然后从中衍生出一个有不可变实例的类。这样给出了转换的规则，也说明了不可变对象的几个优势。
一个同步类案例
SynchronizedRGB类，定义了颜色的对象。每个对象将颜色表示成为3个整数值，来表示三原色，以及一个字符串，表示该颜色的名字。
public class SynchronizedRGB {
// Values must be between 0 and 255.
private int red;
private int green;
private int blue;
private String name;
private void check(int red,
int green,
int blue) {
if (red < 0 || red > 255
|| green < 0 || green > 255
|| blue < 0 || blue > 255) {
throw new IllegalArgumentException();
}
}
public SynchronizedRGB(int red,
int green,
int blue,
String name) {
check(red, green, blue);
this.red = red;
this.green = green;
this.blue = blue;
this.name = name;
}
public void set(int red,
int green,
int blue,
String name) {
check(red, green, blue);
synchronized (this) {
this.red = red;
this.green = green;
this.blue = blue;
this.name = name;
}
}
public synchronized int getRGB() {
return ((red << 16) | (green << 8) | blue);
}
public synchronized String getName() {
return name;
}
public synchronized void invert() {
red = 255 - red;
green = 255 - green;
blue = 255 - blue;
name = "Inverse of " + name;
}
}
SynchronizedRGB必须非常小心地使用，为了防止不连续的状态被记录下来。假设，一个线程执行了以下的代码：
SynchronizedRGB color =
new SynchronizedRGB(0, 0, 0, "Pitch Black");
...
int myColorInt = color.getRGB(); //Statement 1
String myColorName = color.getName(); //Statement 2
如果另一个线程在语句1之后，语句2之前，调用了color.set方法，mycolorInt的值就不会和mycolorName的值相匹配。为了避免出现这样的结果，这两句语句必须要被绑定在一起：
synchronized (color) {
int myColorInt = color.getRGB();
String myColorName = color.getName();
}
这种不一致性只会出现在可变更的对象之上——它对不可变更的SynchronizedRGB来说，不是一个问题。
下面的几条规则定义了一个创建不可变对象的简单策略。不是所有被声明为不可变的类都遵循以下的规则。这不一定说明那些类的发明人水平不行——他们可能有足够的理由相信他们类的实例在构造之后不会改变。然而，这样那样的策略需要复杂的分析，对初学者太不友好。
- 不要提供setter方法——会更改域或对象的方法。
- 把所有的域声明为私有和final。
- 不要允许子类重写方法。实现这个最简单的方式就是把该类声明为final。一个更为复杂的方法，是把构造函数声明为私有，然后在工厂方法中构建实例。
- 如果实例域包含对可变更对象的引用，不要允许这些对象发生改变。
4.1 不要提供能改变能变更对象的方法。
4.2 不要和可变更对象共享引用。永远不要把外部可变的引用传递给构造器。 如果有必要，建立复制版本，然后把引用存储在复制版本中。同样的，创建你内部可变更对象的复制版本，来避免把原始的值直接返回给你的方法。
对SynchronizedRGB进行上面的策略，需要进行以下几个步骤：
- 在该类中有两个setter方法。第一个，set随意地改变对象，在不可变类中没有它的容身之地。第二个，invert，可以被改造成必须要新建一个新的对象，而不是在当前对象上进行修改。
- 所有的域已经都是私有了，它们需要进一步被声明为final。
- 类本身要被声明为final。
- 只有一个域引用了一个对象，而那个对象本身是不可变的。因此，来保证内部的可修改对象的安全卫士也不需要了。
经过这些修改之后，我们有了ImmutableRGB：
final public class ImmutableRGB {
// Values must be between 0 and 255.
final private int red;
final private int green;
final private int blue;
final private String name;
private void check(int red,
int green,
int blue) {
if (red < 0 || red > 255
|| green < 0 || green > 255
|| blue < 0 || blue > 255) {
throw new IllegalArgumentException();
}
}
public ImmutableRGB(int red,
int green,
int blue,
String name) {
check(red, green, blue);
this.red = red;
this.green = green;
this.blue = blue;
this.name = name;
}
public int getRGB() {
return ((red << 16) | (green << 8) | blue);
}
public String getName() {
return name;
}
public ImmutableRGB invert() {
return new ImmutableRGB(255 - red,
255 - green,
255 - blue,
"Inverse of " + name);
}
}