Hi,

Thomas schrieb:

Perhaps you should read about references as well! ;-)

Your example does not work of course:

This will *not* change the value of the parameter of the caller. e.g.:

Integer x=2;
test(x);
System.out.println(x);

This will print "2" of course, and not "1".

Your example would work, if you had declared your method like this:

void test(MyInteger x) {
  x.setValue(1);
}

Unfortunately, java.lang.Integer does not have a set-method (that's why
I called the parameter-type "MyInteger").

Of course, it is not difficult to implement such a class.

Ciao,
Ingo

...
int x = 0;
auto.test(x);
System.out.println(x);
...
public void test (int x)
{
 x = 1;
}

Output: 0

Oy! You left their message languishing at the bottom of yours
where we can't see it to set the context!

(fx:relocation)

Integer and Character etc are immutable. You can't change them once
they're created.

All /that/ will do is make the local variable `x` refer to an Integer
with value `1`. It won't change any argument passed to `test`.

You have to do it by hand -- create a mutable class that can hold
integer values and use instances of /that/.

   final class AnInteger { public int value = 0; }

   void test( AnInteger x ) { x.value = 17; }

   ... AnInteger y = new AnInteger();
       test( y );
       System.err.println( ">> " + y.value );

This is equivalent to:

void test(Integer x){
  x = new Integer(1);
}

It changes which Integer object is referenced by the formal parameter x.
It has no effect on which Integer is referenced by a, or on a.intValue().

Instead, a needs to reference something that offers value-changing
syntax or methods. For example, you can assign to a specified element of
any int[] array:

void setOne(int[] data, int index){
  data[index] = 1;
}

Similarly, if a references an object that has value-changing methods,
such as a StringBuilder:

void setOne(StringBuilder sb){
  sb.setLength(0);
  sb.append("ONE");
}

You can, of course, create a class of your own that has exactly the
value-changing methods you want.

Patricia

Not /quite/.

You can update the referred-to object, but you can't update the
/argument variable/.

On Nov 16, 11:37 pm, Roedy Green <see_webs...@mindprod.com.invalid>
wrote:

There's always the array hack (which I've used to simulate full-grown
closures, too).  It's kind of abusive to the language, and you gain a
few more things that can go wrong, but:

void test (Point[] p) {
 assert p.length == 1;
 p[0] = new Point (10, p.y);
}

void test (int[] i) {
 assert i.length == 1;
 i[0] = 10;
}

-o