Why Java not allow C# "out" feature for method parameters

Question

Possible Duplicate:
Why there is no way to pass by reference in java

Can anybody tell me why exactly Java does not provide C# "out" type feature when dealing with method parameters to pass by reference ? I mean why would not it allow us to pass primitive data types like boolean for example, pass by reference. I have tried also with wrapper class java.lang.Boolean but still to no avail. It still wont allow me to pass variable by reference.
Is there any specific reason why Java still has not provided us with this even in version 7 ?

Answer 1

Java only has pass by value. This was a decision made when the language was designed.

• Why doesn't java support pass by reference like C++

There is exactly one parameter passing mode -- pass by value -- and that helps keep things simple.

-- James Gosling, et al., The Java Programming Language, 4th Edition

If you want you can put your boolean as a member inside a mutable class (you can't use Boolean because it is immutable), and pass a reference to that class. Apache Commons even has a class called MutableBoolean that you can use.

Answer 2

Only the language design team could tell you why, but I believe the reason for not allowing "out" parameters might be something like: If you want a method that calculates two things, what you really want is either two methods, or one method that returns an object. This supposedly leads to better design and more maintainable code.

Note that you if you really want "out parameters" you can easily use arrays of one element. For example:

void div(int a, int b, int[] q, int[] r) {
    if (q != null) q[0] = a/b;
    if (r != null) r[0] = a%b;
}

// elsewhere:
int[] quotient = new int[1];
int[] remainder = new int[1];
div(4, 3, quotient, remainder);

Answer 3

This is just my opinion but I feel that the designers of Java believed they could simplify programming by eliminating features rather than making them more intuitive and easier to handle.

Answer 4

Short answer is that it's a design decision and there's nothing you can do with passing by reference that you couldn't do with passing object references by value.

As for your particular problem, there are two solutions:

A mutable wrapper class:

final class BooleanRef {
    public boolean value;
}

And use it as:

// Function
void changeTheBoolean( BooleanRef b ){
    b.value = true;
}

// Call:
BooleanRef b = new BooleanRef();
changeTheBoolean( b );

OR, (more hackish but more lightweight) wrap in an array:

// Function
void changeTheBoolean( boolean[] b ){
    b[0] = true;
}

// Call:
boolean[] b = new boolean[1];
changeTheBoolean( b );