tags:

views:

4328

answers:

6

There is a Java Void -- uppercase V-- reference type. The only situation I have ever seen it used is to parameterize Callables

final Callable<Void> callable = new Callable<Void>() {
            public Void call() {
                foobar();
                return null;
            }
        };

Are there any other uses for the Java Void reference type? Can it ever be assigned anything other than null? If yes, do you have examples?

+3  A: 

Future<Void> works like charm. :)

Alexander Temerev
import org.sexpistols.godsavethequeen;
Tom Anderson
+6  A: 

Given that there are no public constructors, I would say it can't be assigned anything other than null. I've only used it as a placeholder for "I don't need to use this generic parameter," as your example shows.

It could also be used in reflection, from what its Javadoc says:

The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.

Michael Myers
+5  A: 

Void has become convention for a generic argument that you are not interested in. There is no reason why you should use any other non-instantiable type, such as System.

It is also often used in for example Map values (although Collections.newSetFromMap uses Boolean as maps don't have to accept null values) and java.security.PrivilegedAction.

I wrote a weblog entry on Void a few years back.

Tom Hawtin - tackline
+2  A: 

You can create instance of Void using reflections, but they are not useful for anything. Void is a way to indicate a generic method returns nothing.

Peter Lawrey
+1 for instantiating a class that the documentation says is uninstantiable. I've done this too and I agree that instantiated Voids are useless.
Pourquoi Litytestdata
Constructor<Void> cv = Void.class.getDeclaredConstructor(); cv.setAccessible(true); Void v = cv.newInstance(); System.out.println(v); // ;)
Peter Lawrey
As an exercise, try creating a new Class using reflections and see what happens.
Peter Lawrey
I got a java.lang.InstantiationException from sun.reflect.InstantiationExceptionConstructorAccessorImpl . :(
Pourquoi Litytestdata
The only way I know of is to access defineClass of ClassLoader, but this requires providing the byte code you want to load. 8-)
Peter Lawrey
+4  A: 

All the primitive wrapper classes (Integer, Byte, Boolean, Double, etc.) contain a reference to the corresponding primitive class in a static TYPE field, for example:

Integer.TYPE == int.class
Byte.TYPE == byte.class
Boolean.TYPE == boolean.class
Double.TYPE == double.class

Void was initially created as somewhere to put a reference to the void type:

Void.TYPE == void.class

However, you don't really gain anything by using Void.TYPE. When you use void.class it's much clearer that you're doing something with the void type.

As an aside, the last time I tried it, BeanShell didn't recognise void.class, so you have to use Void.TYPE there.

Pourquoi Litytestdata
So there's both a Void.class and a void.class!
Tom Anderson
+2  A: 

Before generics, it was created for the reflection API, to hold TYPE returned by Method.getReturnType() for a void method, corresponding to the other primitive type classes.

EDIT: From the JavaDoc of Void: "The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void". Prior to Generics, I am aware of no use other than reflection.

Software Monkey
I don't believe this. I don't have a 1.4 or earlier JVM in front of me now, but I believe that Method.getReturnType() has always returned void.class for a void method.
Pourquoi Litytestdata
@Pour: I am saying that *before* generics, the only use I am aware of is to hold TYPE (as in Void.TYPE), which was used in reflection's Method.getReturnType() for a void method.
Software Monkey