Usos para o Java Tipo Referência vazio?

Question

Há uma Void Java - maiúsculas V-- tipo de referência . A única situação que eu já vi sendo utilizado é para parametrizar Callables

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

Existem outros usos para o tipo de referência Void Java? Nunca o poderia ser atribuído qualquer coisa diferente de null? Se sim, você tem exemplos?

Answer 1

Void se tornou convenção para um argumento genérico que você não está interessado. Não há nenhuma razão porque você deve usar qualquer outro tipo não instanciável, como System.

É também frequentemente usado em para valores exemplo Map (embora usos Collections.newSetFromMap Boolean como mapas não tem que aceitar valores null) e java.security.PrivilegedAction.

Eu escrevi um href="http://www.jroller.com/tackline/entry/void_references" rel="noreferrer"> weblog entrada Void alguns anos atrás.

Answer 2

Você pode criar instância de Vácuo usando reflexões, mas eles não são úteis para qualquer coisa. Vazio é uma forma de indicar um genérico método 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

Answer 3

Future<Void> funciona como charme . :)

Answer 4

Dado que existem há construtores públicos , eu diria que não pode ser atribuído qualquer coisa diferente de null. Eu só usou-o como um espaço reservado para "Eu não preciso usar este parâmetro genérico", como seu exemplo de shows.

Ele também poderia ser usado em reflexão, a partir do que a sua Javadoc diz:

A classe Vazio é uma classe de espaço reservado instanciados para manter uma referência ao objeto de classe que representa o Java palavra-chave void.

Answer 5

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

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

Void foi inicialmente criado como um lugar para colocar uma referência ao tipo void:

Void.TYPE == void.class

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

Como um aparte, a última vez que tentou fazê-lo, BeanShell não reconheceu void.class, então você tem para uso Void.TYPE lá.

Answer 6

Quando você usa o href="http://en.wikipedia.org/wiki/Visitor_pattern"> padrão pode ser mais limpo para usar vazio em vez de objeto quando você quer 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ê vai implementar o visitante pode definir explicitamente a ser tão vazio que você sabe que seu visitante irá 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;
    }
}

Answer 7

Antes de genéricos, que foi criado para a API reflexão, para TYPE espera retornado por Method.getReturnType () para um método vazio, correspondente às outras classes de tipo primitivo.

EDIT: Desde o JavaDoc do Vazio: "A classe Vazio é uma classe de espaço reservado instanciados para manter uma referência ao objeto de classe que representa o Java palavra-chave void". Antes de genéricos, estou ciente de nenhum outro uso de reflexão.

Answer 8

Como você pode não instanciar vazio, você pode usar Apache commons Null objeto , então

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

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

Para responder a pergunta original do cartaz, o uso para isso é para diferenciar entre "o nada" e "nada", que são coisas completamente diferentes.

PS: Diga não ao Null objeto padrão

Answer 9

é nula criar para embrulhar seu tipo vazio primitivo. Cada tipo primitivo tem o seu tipo de referência correspondente. Vazio é usado para instanciar uma classe genérica ou a utilização de um método genérico, A argumentos genéricos bruxa 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, eu não quero nada do servidor que eu estou pedindo para criar uma nova inscrições, mas public interface AsyncCallback<T> { .... } é uma interface genérica para que eu fornecer Vazio desde os genéricos não aceitam tipos primitivos

Answer 10

Ele também é comumente usado em chamadas de retorno de conclusão Async-IO quando você não tem a necessidade de um objeto Attachment. Nesse caso, você especifique nulo para a operação IO e implementar CompletionHandler<Integer,Void>.

Answer 11

Pode ser caso raro, mas uma vez, eu usei Void em aulas de aspecto.

Este foi um aspecto que corre atrás de métodos que possui uma anotação @Log, e registra o método retornou e algumas informações se o tipo de método de retorno não é nula.

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