🚀 go-pugleaf

Steve Holt wrote:

> this doesn't change the value of ok because its passed by value
> 
> change(boolean ok)
> {
>     ok = true;    // only has an effect in this methods scope
> }
> 
> So I figured using the Boolean class may achive this because its passed by
> reference
> 
> change(Boolean ok)
> {
>     // but no method to change value inside the class
> }
> 
> Please don't ask ne to use the return value as this returns something else.
> I'm probably going to get it to throw an exception instead but I'm
> interested to know how you would do this and why the Boolean 
> class doesn't provide a method to change the value - weird 
> if you ask me!

Yes, at first this might seem weird.  However, all of 
the classes which essentially "objectify" the primitives
(Boolean for boolean, Integer for int, etc.) are what
can be called "immutable" objects.  That means, once
you instantiate the object, its value is not changeable.
This is sort of a fundamental design pattern.  The same
is true for String -- once you instantiate a String object
with a given array of characters, you cannot change its
contents.  That's why, with String at least, if you
say 

   String s = "blah";
   s = s.replace("h", "b");

you actually get an entirely new object assigned to "s".
The original object reference of "s" is cut loose for
garbage collection.

Other frameworks, such Apple's Cocoa (java.lang.* might
be considered a framework, as much or more than it might
be thought of as a part of the language), have always
(since 1989 when it was NeXT) made the distinction between
mutable and immutable objects.  Unfortunately, Java 
didn't do this very well from the start and it leads
to some confusion, especially for neophytes.  Even arrays,
vectors, hashtables, etc., could be so distinguished, but
Java's inventors sort of overlooked that, too.

May I ask why you are trying to change the value in
this manner instead of just writing

  boolean b = [evaluate some condition];

?


Paul Furbacher (TeamB)

  Please send responses to the newsgroup only.
  That means, do not send email directly to me.
  Thank you.