Discussion 6 Immutable Rocks

CS61B

第一题，判断哪些classes是immutable的，我第一次选的是Pebble和MommaRock, 结果全错，说明我完全不懂Immutable：

解析：

第一个Pebble,只需要一个简单的setter就可以改变weight了，肯定是mutable的， 如下：

public class Pebble{
    public int weight；
    public Pebble() {
        weight = 1
    }
    public void setWeight(int weight){
        this.weight = weight
    }

第三个，仔细阅读一下以下结论：

If a final variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object.

就是说，一个final变量是一个对象的引用，而这个变量永远都是指向这个对象，不能够变成指向别的对象，即这个引用无法改变。但是，这个对象使可以改变的。

'final' simply makes the object reference unchangeable. The object it points to is not immutable by doing this. INSTANCE can never refer to another object, but the object it refers to may change state.

例子：

/*Java中很多class都是immutable，像String，Integer等，它们通常用来作为Map的key.
那么在实现自定义的Immutable的Class的时候，应该注意哪些要点呢？
a)Class 应该定义成final，避免被继承。
b)所有的成员变量应该被定义成final。
c)不要提供可以改变类状态(成员变量)的方法。【get 方法不要把类里的成员变量让外部客服端引用,当需要访问成员变量时，返回成员变量的copy】
d)构造函数不要引用外部可变对象。如果需要引用可以在外部改变值的变量，应该在构造函数里进行defensive copy。*/
//Wrong way to write a constructor:  
public final class MyImmutable {  
    private final int[] myArray;  
    public MyImmutable(int[] anArray) {  
        this.myArray = anArray; // wrong  
    }  
    public String toString() {  
        StringBuffer sb = new StringBuffer("Numbers are: ");  
        for (int i = 0; i < myArray.length; i++) {  
            sb.append(myArray[i] + " ");  
        }  
        return sb.toString();  
    }  
}  
// the caller could change the array after calling the  
//constructor.  
    int[] array = {1,2};  
    MyImmutable myImmutableRef = new MyImmutable(array) ;  
    System.out.println("Before constructing " + myImmutableRef);  
    array[1] = 5; // change (i.e. mutate) the element  
    System.out.println("After constructing " + myImmutableRef);  

Out put:
Before constructing Numbers are: 1 2
After constructing Numbers are: 1 5

//Right way to write an immutable class  
//Right way is to copy the array before assigning in the constructor.  
public final class MyImmutable {  
    private final int[] myArray;  
    public MyImmutable(int[] anArray) {  
        this.myArray = anArray.clone(); // defensive copy  
    }  
    public String toString() {  
        StringBuffer sb = new StringBuffer("Numbers are: ");  
        for (int i = 0; i < myArray.length; i++) {  
             sb.append(myArray[i] + " ");  
        }  
        return sb.toString();  
    }  
}  
// the caller cannot change the array after calling the constructor.  
    int[] array = {1,2};  
    MyImmutable myImmutableRef = new MyImmutable(array) ;  
    System.out.println("Before constructing " + myImmutableRef);  
    array[1] = 5; // change (i.e. mutate) the element  
    System.out.println("After constructing " + myImmutableRef);  

Out put:
Before constructing Numbers are: 1 2
After constructing Numbers are: 1 2

参考：
Java实现Immutable Class要点
Immutable class
How to Create immutable Class in java?
Java之不可变对象
Immutable Object and Types of Immutable Objects | Java Tutorial

那么回到我们的题目：

public class Rocks {
    public final Rock[] rocks;
    public Rocks (Rock[] rox) { 
        rocks = rox; 
    }
}

如果我们改变rox的内容，那么rocks虽然是final, 也会发生改变：

public class Rocks {
    public final Rock[] rocks;
    public Rocks (Rock[] rox) { 
        rocks = rox; 
    }
    Rock a = new Rock(8);
    Rock b = new Rock(9);
    Rock[] rox = {a,b};  
    public String toString() {  
        StringBuffer sb = new StringBuffer("The weight of the rock is: ");  
        for (int i = 0; i < rocks.length; i++) {  
            sb.append(rocks[i].weight + " ");  
        }  
        return sb.toString();  
    }  
    Rocks newRocks = new Rocks(rox) ;  
    System.out.println("Before constructing The weight of the rock is: " + newRocks);  
    rox[0] = new Rock(16); // change (i.e. mutate) the element  
    System.out.println("After constructing The weight of the rock is: " + newRocks); 
}

output:
Before constructing The weight of the rock is: 8 9
After constructing The weight of the rock is: 16 9

所以第三个也是mutable的.

第四个跟第三个类似；
第五个要特别注意：

public class PunkRock{
    private final Rock[] band;
    public PunkRock (Rock yRoad) {
        band = {yRoad};
    }
    public Rock[] myBand() {
        return band;
    }
}

The problem with the above code is, that the ArrayL can be obtained through myBand() and be manipulated, leading to the state of the object itself to be altered, therefore, not immutable.

比如下面这样：

public class PunkRock{
    private final Rock[] band;
    public PunkRock (Rock yRoad) {
        band = {yRoad};
    }
    public Rock[] myBand() {
        return band;
    }
    //newPunkRock contains : Rock which weight is 8;
    PunkRock newPunkRock = new PunkRock(new Rock(8));
    //now the array contains Rock which weight is 9 -- this array is mutable.
    newPunkRock.myBand().weight = 9;
}

One way to get around this problem is to return a copy of an array or collection when called from a getter:

public  Rock[] myBand() {
  // return a copy of the list so the internal state cannot be altered
  return new Rock [] {yRoad};
}