¿Usos para el tipo de referencia de Java Void?

Question

Hay un Java Void - mayúscula V-- tipo de referencia . La única situación que he visto que se usa es para parametrizar Callable s

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

¿Hay otros usos para el tipo de referencia Java null? ¿Se le puede asignar algo que no sea <=>? En caso afirmativo, ¿tiene ejemplos?

Answer 1

Void se ha convertido en una convención para un argumento genérico en el que no está interesado. No hay ninguna razón por la que deba usar cualquier otro tipo no instanciable, como System.

También se usa a menudo, por ejemplo, en valores Map (aunque Collections.newSetFromMap usa Boolean como los mapas no tienen que aceptar null valores) y java.security.PrivilegedAction.

Escribí una entrada de weblog en <=> hace unos años.

Answer 2

Puede crear una instancia de Void usando reflejos, 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

Answer 3

Future<Void> funciona como encanto :)

Answer 4

Dado que hay no hay constructores públicos , Diría que no se le puede asignar otra cosa que null. Solo lo he usado como marcador de posición para & Quot; No necesito usar este parámetro genérico, & Quot; como muestra tu ejemplo.

También podría usarse en la reflexión, por lo que es Javadoc dice:

  

La clase Void es una clase de marcador de posición que no se puede desinstalar para contener una referencia al objeto Class que representa la palabra clave Java void.

Answer 5

Todas las clases primitivas de contenedor (Integer, Byte, Boolean, Double, etc.) contienen 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 se creó 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 usa void.class es mucho más claro que está haciendo algo con el tipo <=>.

Además, la última vez que lo probé, BeanShell no reconoció <=>, así que tienes que usar <=> allí.

Answer 6

Cuando usa el patrón de visitante puede ser más limpio usar Void en lugar de Object cuando quiera asegurarse de que el valor de retorno será nulo

Ejemplo

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

   OUT visit(Leaf2 leaf);
}

Cuando implemente a su visitante, puede establecer explícitamente que OUT sea vacío 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;
    }
}

Answer 7

Antes de los genéricos, se creó para la API de reflexión, para contener TYPE devuelto por Method.getReturnType () para un método vacío, correspondiente a las otras clases de tipos primitivos.

EDIT: desde el JavaDoc de Void: " La clase Void es una clase de marcador de posición que no se puede desinstalar para contener una referencia al objeto Class que representa la palabra clave Java void " ;. Antes de Generics, no tengo conocimiento de otro uso que no sea la reflexión.

Answer 8

Como no puede crear una instancia de Void, puede usar Objeto nulo de Apache commons , entonces

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

en la primera línea, tiene un objeto, por lo que aNullObject != null se mantiene, mientras que en la segunda línea no hay referencia, por lo que noObjectHere == null se mantiene

Para responder la pregunta original del afiche, 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

Answer 9

Void es crear para envolver su tipo de vacío primitivo. Cada tipo primitivo tiene su tipo de referencia correspondiente. Void se usa para crear una instancia de 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 puede ver, no quiero nada del servidor al que le pido que cree 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

Answer 10

También se usa comúnmente en devoluciones de llamada de finalización de Async-IO cuando no tiene la necesidad de un objeto Attachment. En ese caso, especifique nulo para la operación IO e implemente CompletionHandler<Integer,Void>.

Answer 11

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

Este fue un aspecto que se ejecuta después de los métodos que tienen una anotación @Log, y registra el método devuelto y alguna 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
         }
}