What exactly is the difference between Void
, void
, and can I just use null
instead?
I'm asking this is because I'm looking at sample Android code where they used Void but Eclipse errors on it (it says Void cannot be resolved to a variable
).
My code that breaks is
public class MyAsyncTask extends AsyncTask<Void, Void, Boolean>{
...
}
I use it like this
MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute((Void),null);//this is the line that breaks "Void cannot be resolved to a variable"
Void : Wrapper around void. It extends Object class. null indicates no values. Used for objects as comparison to void which is used for methods.
The java. lang. Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.
As shown above, in order to return from a method with the Void return type, we just have to return null.
void is not a valid type. However, void is a valid keyword used to indicate that a method does not return a value. Contrast that to the Integer JavaDoc: The Integer class wraps a value of the primitive type int in an object.
The most common use of Void
is for reflection, but that is not the only place where it may be used.
void
is a keyword that means that a function does not result a value.
java.lang.Void
is a reference type, then the following is valid:
Void nil = null;
(so far it is not interesting...)
As a result type (a function with a return value of type Void
) it means that the function *always * return null
(it cannot return anything other than null
, because Void
has no instances).
Void function(int a, int b) {
//do something
return null;
}
Why would I like a function that always returns null?
Before the invention of generics, I didn't have an use case for Void
.
With generics, there are some interesting cases. For instance, a Future<T>
is a holder for the result of an asynchronous operation performed by other thread. Future.get
will return the operation value (of type T
), and will block until the computation is performed.
But... what if there is nothing to return? Simple: use a Future<Void>
. For instance, in Google App Engine the Asyncronous Datastore Service delete
operation returns a Future<Void>
. When get()
is invoked on that future, null
is returned after the deletion is complete. One could write a similar example with Callables.
Another use case is a Map
without values, i.e. a Map<T,Void>
. Such a map behaves like a Set<T>
, then it may be useful when there is no equivalent implementation of Set
(for instance, there is no WeakHashSet
, then one could use a WeakHashMap<T,Void>
).
Void
is "an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void." (from http://docs.oracle.com/javase/6/docs/api/java/lang/Void.html)
void
is a return type signifying no return.
null
is the absence of value.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With