marcwentink@hotmail.com schrieb:

Self documenting code basically means that you use meaningfull names for
variables and methods.

See http://c2.com/cgi/wiki?SelfDocumentingCode for a lot of info and
interesting controversy.

That's all there is to it.

Yes:

  final StringBuilder x = new StringBuilder();
  x.append("abc"); // changes the state of object x
                   // const would not allow that
  x = new StringBuilder(); // error because x is final

 > Strange. But is not the operator = a method that changes the object

First, one often doesn't need something like const, if an object is
properly designed (e.g. is not a mixed bag of otherwise unrelated
things), and if it is properly so it itself ensures its internal state
is consistent regardless of which methods of it are called. Objects are
there to be used, and when passing an object around this is done for a
purpose, and there is nothing inherently wrong in using an object. This
is more a design and philosophical issue than a coding issue.

Second, if you really, really, badly need to protect a particular object
in certain situations, provide an immutable type of it or wrapper. This
is still no 100% protection, but often good enough. There are several
ways to implement such a mechanism. E.g. for a start with code like

    class Thing {
        int value;
        void setSomething(int value) {
            this.value = value;
        }
    }

    class ImmutableThing extends Thing {
        void setSomething(int value) {
            ; // do nothing
        }
    }

For a real-world example, see the collection classes, which have
synchronized an read-only wrappers.

Alternatively, you could pass a (deep) cloned version of the object
around. But that creates new problems (synchronizing the state of the
two objects when both are in use).

/Thomas