Uses for the Java Void Reference Type?
JavaVoidJava Problem Overview
There is a Java Void
-- uppercase V-- reference type. The only situation I have ever seen it used is to parameterize Callable
s
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?
Java Solutions
Solution 1 - Java
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
.
Solution 2 - Java
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.
Constructor<Void> constructor = Void.class.getDeclaredConstructor();
constructor.setAccessible(true);
Void v = constructor.newInstance();
System.out.println("I have a " + v);
prints something like
I have a java.lang.Void@75636731
Solution 3 - Java
Future<Void>
works like charm. :)
Solution 4 - Java
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.
Solution 5 - Java
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, http://www.beanshell.org/">BeanShell</a> didn't recognise void.class
, so you have to use Void.TYPE
there.
Solution 6 - Java
When you use the visitor pattern it can be cleaner to use Void instead of Object when you want to be sure that the return value will be null
Example
public interface LeavesVisitor<OUT>
{
OUT visit(Leaf1 leaf);
OUT visit(Leaf2 leaf);
}
When you will implement your visitor you can explicitly set OUT to be Void so that you know your visitor will always return null, instead of using Object
public class MyVoidVisitor implements LeavesVisitor<Void>
{
Void visit(Leaf1 leaf){
//...do what you want on your leaf
return null;
}
Void visit(Leaf2 leaf){
//...do what you want on your leaf
return null;
}
}
Solution 7 - Java
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.
Solution 8 - Java
As you can't instantiate Void, you can use Apache commons Null object, so
Null aNullObject = ObjectUtils.Null;
Null noObjectHere = null;
in the first line, you have an object, so aNullObject != null
holds, while in the second line there is no reference, so noObjectHere == null
holds
To answer the poster's original question, the usage for this is to differentiate between "the nothing" and "nothing", which are completely different things.
PS: Say no to Null object pattern
Solution 9 - Java
Void
was created to wrap its primitive void
type. Every primitive type has its corresponding Reference type. Void
is used to instantiate a generic class or use of a generic method, a generic argument which you are not interested in. Here is an example...
public void onNewRegistration() {
newRegistrationService.createNewUser(view.getUsername(), view.getPassword(),
view.getInitialAmount(), view.getCurrency(), new AsyncCallback<Void>() {
@Override
public void onFailure(Throwable caught) {
}
@Override
public void onSuccess(Void result) {
eventBus.fireEvent(new NewRegistrationSuccessEvent());
}
});
}
Here, as you can see, I don't want anything from the server that I am asking to create a new registration ,but public interface AsyncCallback<T> { .... }
is a generic interface, so i provide Void
since generics don't accept primitive types
Solution 10 - Java
It is also commonly used on Async-IO completion callbacks when you dont have the need for an Attachment
object. In that case you specify null to the IO operation and implement CompletionHandler<Integer,Void>
.
Solution 11 - Java
It may be rare case but once, I used Void
in aspect classes.
This was an aspect which runs after methods that has an @Log
annotation, and logs the method returned and some info if the method return type is not void.
@AfterReturning(value = "@annotation(log)",
returning = "returnValue",
argNames = "joinPoint, log, returnValue"
)
public void afterReturning(final JoinPoint joinPoint, final Log log,
final Object returnValue) {
Class<?> returnType = ((MethodSignature) joinPoint.getSignature())
.getReturnType();
if (Void.class.isAssignableFrom (returnType)) ) {
//Do some log
}
}