[disc]Design pattern - immutable objects.

Question

I`m working more often with immutable object because it doesn`t cost as much work to keep object consistent. But sometimes an object has to be build or a reference to his child objects has to be set.
eg
class A{
    private ArrayList bList = new ArrayList();  
    public A(){}
    public void addB(B b){
        bList.add(b);
class B{
    private A a;
    public B(A a){
         this.a = a;
}It`s now more complicated to make a immutable version of A.
My question is how this problem could be solved. One solution is to add an immutable flag that could be set to true if the last B is added. But this couldn`t be checked compile time.
Maybe there is a design pattern for this problem.
I would like to discuss about this problem, so every thought is welcome.

Answer 1

I have an Immutable Collection wrapper class that I use when I want to have a Collection be read-only.
If you look at the JavaDoc for AbstractCollection you'll see that the add and remove methods throw UnsuportedOperationException.
So all you have to do is implement the iterator() and size() methods. i.e.
public class ImmutableCollection extends AbstractCollection {     
     private Collection collection;
      * only constructor
     public ImmutableCollection(Collection collection) {
          this.collection = collection;
      * returns the size of the collection
     public int size() {
          return collection.size();
      * returns a non-modifiable iterator over the elements of the collection
     public Iterator iterator() {
          return new Iterator() {
               Iterator iterator = collection.iterator();
               public boolean hasNext() {
                    return iterator.hasNext();
               public Object next() {
                    return iterator.next();
               public void remove() {
                    throw new UnsupportedOperationException();
}