Effective Java：使可变性最小化

浅浅的花香味﹌ 2022-02-02 06:47 151阅读 0赞

# 1.什么是不可变类 #

1.  需要的所有参数必须在实例化的时候都传进去。
2.  对象中所有信息在对象的整个生命周期中都保持不变。

# 2.使类不可变的原则 #

1.  **不要提供任何修改对象状态的方法。**
2.  **保证类不会被继承。**
3.  **使所有的域都是final类型的。**
4.  **使所有的域都是私有类型的。**
5.  **确保对于任何可变组件的互斥性。** 即，确保在该类的外部不会获取到该类中可变对象的引用。比如下面这个例子：

public class MyObject{
        
      private final List<String> list = new ArrayList<>;//可变对象
      public List<String> getList() {
        
        return new ArrayList(list);
      }
      public void setList(List<String> list) {
        
        this.list = new ArrayList(list);
      }
    }

# 3.不可变类的优点 #

1.  不可变类简单。  
    　　不可变类只有一种状态，就是它被创建出来时候的状态，如果你要根据这个类进行一系列复杂操作，那么这个操作无论在什么时候结果都是相同的，所以你可以直接将结果缓存起来，在下一次执行同样操作的时候取出来，而不必再进行下一次操作。
2.  不可变类本质上是线程安全的，它不需要同步锁。
3.  对于不可变类，你永远都不需要实现拷贝方法。拷贝方法对它来说是没有意义的。
4.  不可变类可以被自由的共享。

# 4.不可变类的缺点 #

对于每一个不同的值都需要创建一个新的对象。

# 5.缺点的弥补办法 #

1.  **先猜测一下经常用到哪些多步骤的操作，然后将它们作为基本数据类型提供。** 比如Integer,它将值为-128到127的对象缓存起来，但调用valueOf(int i)的时候，直接从缓存中拿，不用再重复创建提高效率。
2.  **我们可以创建一个可变配套类。** 例如String是一个不可变类，它的可变配套类为StirngBuilder和StringBuffer。下面是一个例子，我们现在实现一个复数类，对外提供一个相加的方法如下：

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);
      }
    
      public double realPart() {
        
        return re;
      }
      public double imaginaryPart() {
        
        return im;
      }
    
      //复数相加
      public Complex add(Complex c) {
        
        return new Complex(re + c.re, im + c.im);
      }
    }

我们可以为它创建一个配套类：

public class ComplexBuilder {
        
      private double re;
      private double im;
    
      private ComplexBuider(double re, double im) {
        
        this.re = re;
        this.im = im;
      }
      public static ComplexBuider newInstance(Complex c) {
        
        return new ComplexBuilder(c.realPart(), c.imaginaryPart());
      }
    
      public void add(Complex c) {
        
        this.re = this.re + c.realPart();
        this.im = this.im + c.imaginaryPart();
      }
    
      public Complex toComplex() {
        
        return Complex.valueOf(this.re, this.im);
      }
    }

在客户端中我们如果需要用一个复数和另一个复数相加100次，我们如果不用ComplexBuilder的话就像下面这样，算上最开始穿件的两个实例，我们将会创建102个实例：

public class Test {
        
      @Test
      public void addNoBuiderTest() throws Exception{
        
        Complex c1 = Complex.valueOf(1, 2);
        Complex c2 = Complex.valueOf(2, 3);
        for (int i = 0 ; i < 100 ; i++) {
        
          c1 = c1.add(c2);
        }
      }
    }

现在改用ComplexBuilder，现在我们只会创建4个实例:

public class Test {
        
      @Test
      public void addNoBuiderTest() throws Exception{
        
        Complex c1 = Complex.valueOf(1, 2);
        Complex c2 = Complex.valueOf(2, 3);
        ComplexBuilder cb = ComplexBuider.newInstance(c1);
        for (int i = 0 ; i < 100 ; i++) {
        
          cb.add(c2);
        }
        c1 = cb.toComplex();
      }
    }

# 6.总结 #

1.  **坚决不要为每个getter都生成setter。**
2.  **能将类做成不可变的就做成不可变的。**
3.  **一般比较小的值类都是需要做成不可变的。**
4.  **对于一些比较大的值类尽量考虑实现成不可变类。**
5.  **性能方面很有必要的时候才需提供配套类。**
6.  **如果真的不能作为不可变类，那就尽量限制其可变性。**
7.  **对于一个类的初始化只能在构造器或是静态工厂中完成。** 也就是说类的初始化操作（赋值之类的）只能执行一次，就是在构造器或是静态工厂中。这一点参考java类库中的TimerTask类。