可变和不可变类

Question

我想在java中创建可变和不可变节点，两者在除mutable之外的所有内容中都应该相同。如何实现基类和两个派生类的可变类和不可变类？

Answer 1

可变类和不可变类之间的区别在于不可变类没有setter或其他修改内部状态的方法。状态只能在构造函数中设置。

调用父类不可变将是一个坏主意，因为当你有子类时，这将不再是真的。这个名字会让人误解：

ImmutableNode node = new MutableNode(); 
((MutableNode)node).change(); 

Answer 2

不可变的类是一个曾经创建过的类，它的内容不能被改变。不可变的对象是其状态不能被改变的对象。

Java中不可变类的常见示例是String类。

Answer 3

所有你需要做的是建立一个单一的基类受保护的变量

public class Base{ 
    protected int foo; 
} 

易变的人需要能够设置变量

public class MutableBase extends Base{ 
    public void setFoo(){} 
} 

的immmutable一个需要能够只设置一次变量

public class ImmutableBase extends Base{ 
    public ImmutableBase(int foo){ 
      this.foo = foo; 
    } 
} 

大多数不可变的类，有​​方法来操作t他内部变量没有变异的实例。字符串这样做，你可能会想这样的事情

public ImmutableBase add(int bar){ 
    return new ImmutableBase(this.foo+bar); 
} 

关于这个很酷的事情是，你给你的类的用户少控制/忧每个实例的内部。这使得它更容易处理，因为在Java中，所有东西都是通过对象引用传递的，所以如果你传递一个String或一个ImmutableBase，你不必担心它被改变了。

Answer 4

对于一个类是不可变的，它必须被声明为final，并且它不得使用方法。最终的声明确保它不能被扩展，并添加额外的可变属性。

class Base { 
    protected int var1; 
    protected int var2; 

    public getVar1() {return var1;} 
    public getVar2() {return var2;} 
    } 

    class Mutable extends Base { 
     public setVar1(int var1) {this.var1 = var1} 
     public setVar2(int var2) {this.var2 = var2} 
    } 

    final class Immutable extends Base { //final to avoid being extended and then implement the setters 

    } 

那就是我可以做的小事？但为什么你需要这样一个场景？

Answer 5

另一种选择是使用与UnmodifiableList相同的策略。首先，创建一个指定类型的接口。

interface List<T>{ 
    List<T> add(T t); 
    T getAt(int i); 
    ... 
} 

然后你所有的业务逻辑实现你的可变类：

public class MutableList<T> implements List<T>{ 
    @Override 
    List<T> add(T t){ ... } 

    @Override 
    T getAt(int i){ ... } 

    ... 
} 

最后，创建不可变类是可变的一个景色。您可以实现相同的接口，但将所有读取方法调用委托给查看的对象，并禁止使用异常进行任何写入访问。

public class UnmodifiableList<T> implements List<T>{ 
    //This guy will do all hard work 
    private List delegate; 

    public UnmodifiableList(List<? extends T> delegate){ 
     this.delegate = delegate; 
    } 

    //Forbidden mutable operation: throw exception! 
    @Override 
    List<T> add(T t){ 
     throw new UnsupportedOperationException("List is unmodifiable!"); 
    } 

    //Allowed read operation: delegate 
    @Override 
    T getAt(int i){ 
     return delegate.getAt(i); 
    } 

    ... 
} 

这种方法，你实现业务逻辑只有一次，可以先用自己的方法和验证检查把它变成一个imutable对象之前建立一个对象的利益。