Usos para o tipo de referência do Java Void?

Existe um tipo de referência Java Void- V maiúsculo . A única situação que eu já vi usada é parametrizar s Callable

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

Existem outros usos para o Voidtipo de referência Java ? Pode ser atribuído algo além de null? Se sim, você tem exemplos?

Voidtornou-se uma convenção para um argumento genérico no qual você não está interessado. Não há motivo para usar qualquer outro tipo não instável, como System.

Também é frequentemente usado em por exemplo Mapvalores (embora os Collections.newSetFromMapusos Booleancomo mapas não precisem aceitar nullvalores) e java.security.PrivilegedAction.

Eu escrevi um post do blog em Voidalguns anos atrás.

Você pode criar uma instância do Void usando reflexos, mas eles não são úteis para nada. Vazio é uma maneira de indicar que um método genérico não retorna 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 charme. :)

Dado que não há construtores públicos , eu diria que não pode ser atribuído nada além de null. Eu apenas o usei como espaço reservado para "Não preciso usar esse parâmetro genérico", como mostra seu exemplo.

Também poderia ser usado na reflexão, pelo que diz o Javadoc :

A classe Void é uma classe de espaço reservado instável para manter uma referência ao objeto Class que representa a palavra-chave Java void.

Todos os classe empacotadora ( Integer, Byte, Boolean, Double, etc.) conter uma referência para a classe correspondente primitiva em um estático TYPEcampo, por exemplo:

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

Voidfoi criado inicialmente como um local para colocar uma referência ao voidtipo:

Void.TYPE == void.class

No entanto, você realmente não ganha nada usando Void.TYPE. Quando você usa void.class, é muito mais claro que você está fazendo algo com o voidtipo.

Como um aparte, a última vez que tentei, o BeanShell não reconheceu void.class, então você precisa usá Void.TYPE-lo.

Quando você usa o padrão de visitante , pode ser mais limpo usar Void, em vez de Object, quando quiser ter certeza de que o valor de retorno será nulo.

Exemplo

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

   OUT visit(Leaf2 leaf);
}

Quando você implementa seu visitante, pode explicitamente definir OUT como nulo, para que saiba que seu visitante sempre retornará nulo, em vez de usar Objeto

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 dos genéricos, ele era criado para a API de reflexão, para manter TYPE retornado por Method.getReturnType () para um método nulo, correspondente às outras classes de tipos primitivos.

EDIT: No JavaDoc do Void: "A classe Void é uma classe de espaço reservado instável para manter uma referência ao objeto Class que representa a palavra-chave Java void". Antes da Genéricos, não tenho outra utilidade além da reflexão.

Como você não pode instanciar o Void, você pode usar o objeto nulo do Apache commons , então

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

na primeira linha, você tem um objeto, então aNullObject != nullmantém, enquanto na segunda linha não há referência, então noObjectHere == nullmantém

Para responder à pergunta original do pôster, o uso para isso é diferenciar entre "o nada" e "nada", que são coisas completamente diferentes.

PS: Diga não ao padrão de objeto nulo

Vazio é criar para quebrar seu tipo de vazio primitivo. Todo tipo primitivo tem seu tipo de referência correspondente. O void é usado para instanciar uma classe genérica ou o uso de um método genérico. Argumentos genéricos nos quais você não está interessado. E aqui está um exemplo ...

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

aqui, como você pode ver, não quero nada do servidor que estou pedindo para criar um novo registro, mas public interface AsyncCallback<T> { .... }é uma interface genérica, então forneço o Void, pois os genéricos não aceitam tipos primitivos

Também é comumente usado em retornos de chamada de conclusão de Async-IO quando você não precisa de um Attachmentobjeto. Nesse caso, você especifique nulo para a operação IO e implementar CompletionHandler<Integer,Void>.

Pode ser um caso raro, mas uma vez eu usei Voidnas classes de aspecto.

Esse era um aspecto que é executado após os métodos que possuem uma @Loganotação e registra o método retornado e algumas informações se o tipo de retorno do método não for 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
         }
}