2
votes

What I want to achieve is something like this:

MyClass object = null;
doStuff(&object);

// `object` can now be non-null

What I'm currently doing is this, but I think there must be a better way to achieve this behavior in Java:

MyClassPointer pointer = new MyClassPointer(null);
// pointer.object is null
doStuff(pointer);

// pointer.object can now be non-null
5
Take a look here. - Sotirios Delimanolis
How about MyClass object = doStuff()? - JB Nizet
There are no pointers in Java. The only way to achieve some form of "out" or "by ref" calling semantics is to mutate an object that is supplied as an argument - as is shown in the latter case. I would recommend making doStuff simply return a useful (compound) value. - user2864740
doStuff() has a different return value. Think of the function as returning two values, one directly via return and one with this hack. - Christian Schnorr
Create a class containing both values as fields. And return an instance of this class. - JB Nizet

5 Answers

2
votes

If you really want doStuff to return two values: There may well be a better way to design this. Nevertheless, if you've decided that having doStuff return two values is really the best design, it can be done with a simple helper class:

static class MyClassAndBoolean {
    public MyClass obj;
    public boolean b;
    public MyClassAndBoolean(MyClass obj, boolean b) { this.obj = obj; this.b = b; }
}

and then change doStuff's return type to MyClassAndBoolean. This is one of the very few cases where I think public fields in a class are OK. Since you're defining a simple class just to use as a function result, rather than representing a coherent concept, the usual concerns about defining accessors instead of exposing fields, etc., don't really apply. (P.S. I just guessed at boolean for the other type, but it can be anything, of course.)

Another workaround:

MyClass[] obj = new MyClass[1];
result = doStuff(obj);

Change doStuff's parameter type to MyClass[], and have it stuff the new object into parameter[0]. I do see this idiom used in some of the Java and Android library methods.

1
votes

Why not simply:

MyClass object = doStuff();

which is much more intuitive IMHO. Otherwise you have to pass a reference (not pointer!) to a container object to your method, as you've identified. That's not a common pattern in the Java world.

0
votes

As far as I know java language it is the only way to do that. But you can simply implement method into your class. And in your method also there is possibility to return your object.

public MyObject myFunction(){
//do stufff...
return new MyObject();
}
MybObject object = myFucntion();

Or you can do it in your way. Also using Reflection you can invoke your method.

Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);
0
votes

No, there is no better way since in Java you don't have pointers the way you have them in C++.

In Java references (much like pointers in C++) can't be directly accessed and are always passed by value. Thus you can't change the value of a reference within a method.

0
votes

Use the Visitor pattern, your MyClass being what have to be 'visited' by dostuff