可变和不可变的类

Question

I want to create mutable and immutable node in java, both should be the same in everything except the mutable. how to implement the base class and the two derived class of mutable and immutable classes ?

Answer 1

The difference between mutable and immutable classes is that immutable classes have no setters or any other methods that modify internal state. The state can only be set in the constructor.

It would be a bad idea to call the parent class Immutable because this would no longer be true when you have subclasses. The name would be misleading:

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

Answer 2

All you need to do is create a single base class with protected variables

public class Base{
     protected int foo;
}

The mutable one needs to be able to set the variable

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

The immmutable one needs to be able to set the variable only once

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

Most immutable classes, have methods to act on the variable inside without mutating the instance. String does this, you might want something like this

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

The cool thing about this is that you give the users of your class less control/worry over the internals of each instance. This makes it easier to work with, because in Java everything is passed by object reference, so if you're passing around a String or an ImmutableBase, you don't have to worry about it being changed.

Answer 3

Immutable class is a class which once created, it's contents can not be changed. Immutable objects are the objects whose state can not be changed.

A common example of immutable class in Java is String class .

Answer 4

for a class to be immutable it must be declared final, and it must not haver setter methods. the final declaration ensures that it cannot be extended and additional mutable properties added.

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

    }

Thats the little i can do? But why would you need such a scenario?

Answer 5

Another option is to use the same strategy as the UnmodifiableList . First, create an interface specifying the type.

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

Then you implement your mutable class with all the business logic:

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

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

    ...
}

And finally, create your immutable class to be a view of the mutable one. You implement the same interface but delegate all read method calls to the viewed object, and forbid any write access with an Exception.

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);
    }

    ...
}

This approach has the benefit that you implement the business logic only once, and can first build an Object using its own methods and validation checks before turning it into an imutable object.