Usos para el tipo de referencia Java Void?

Puede crear instancia de Void usando reflexiones, pero no son útiles para nada. Void es una forma de indicar que un método genérico no devuelve nada.

Constructor<Void> constructor = Void.class.getDeclaredConstructor();
constructor.setAccessible(true);
Void v = constructor.newInstance();
System.out.println("I have a " + v);

Imprime algo como

I have a java.lang.Void@75636731

Future<Void> funciona como un encanto. :)

Dado que no hay constructores públicos, yo diría que no se le puede asignar nada que no sea null. Solo lo he usado como marcador de posición para "No necesito usar este parámetro genérico", como muestra su ejemplo.

También podría ser utilizado en la reflexión, de lo que su Javadoc dice:

La clase Void es una clase de marcador de posición insustanciable para contener una referencia al objeto de Clase que representa la palabra clave Java void.

Todas las clases de envoltura primitivas(Integer, Byte, Boolean, Double, etc.) contiene una referencia a la clase primitiva correspondiente en un campo estático TYPE, por ejemplo:

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

Void fue creado inicialmente como un lugar para poner una referencia al tipo void:

Void.TYPE == void.class

Sin embargo, realmente no ganas nada usando Void.TYPE. Cuando usas void.class es mucho más claro que estás haciendo algo con el tipo void.

Como un aparte, la última vez que lo intenté, BeanShell no reconocer void.class, así que tienes que usar Void.TYPE allí.

Cuando se utiliza el patrón de visitante puede ser más limpio usar Void en lugar de Object cuando se quiere estar seguro de que el valor devuelto será null

Ejemplo

public interface LeavesVisitor<OUT>
{
   OUT visit(Leaf1 leaf);

   OUT visit(Leaf2 leaf);
}

Cuando implemente su visitante, puede establecer explícitamente que sea Nulo para que sepa que su visitante siempre devolverá nulo, en lugar de usar 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;
    }
}

Antes de los genéricos, se creó para la API de reflexión, para contener el TIPO devuelto por el Método.getReturnType () para un método void, correspondiente a las otras clases de tipo primitivo.

EDIT: From the JavaDoc of Void: "La clase Void es una clase de marcador de posición inustanciable para contener una referencia al objeto de Clase que representa la palabra clave Java void". Antes de los Genéricos, soy consciente de que no sirve más que la reflexión.

Como no puedes instanciar Void, puedes usar Apache commons Null object , así que

Null aNullObject = ObjectUtils.Null;
Null noObjectHere = null;

En la primera línea, tienes un objeto, por lo que aNullObject != null sostiene, mientras que en la segunda línea no hay referencia, por lo que noObjectHere == null sostiene

Para responder a la pregunta original del póster, el uso para esto es diferenciar entre "la nada" y "nada", que son cosas completamente diferentes.

PD: Di no al patrón de objeto nulo

Void se crea para envolver su tipo de vacío primitivo. Cada tipo primitivo tiene su correspondiente tipo de referencia. Void se utiliza para instanciar una clase genérica o el uso de un método genérico, un argumento genérico que no le interesa. y aquí hay un ejemplo ...

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());
      }
    });
  } 

Aquí, como puedes ver, no quiero nada del servidor al que estoy pidiendo crear un nuevo registro, pero public interface AsyncCallback<T> { .... } es una interfaz genérica por lo que proporciono Void ya que los genéricos no aceptan tipos primitivos

También se usa comúnmente en devoluciones de llamada de finalización Async-IO cuando no se necesita un objeto Attachment. En ese caso se especifica null a la operación IO y se implementa CompletionHandler<Integer,Void>.

Puede ser un caso raro, pero una vez, usé Void en las clases de aspecto.

Este era un aspecto que se ejecuta después de métodos que tienen una anotación @Log, y registra el método devuelto y algo de información si el tipo de retorno del método no es nulo.

 @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
         }
}