Utilisations pour le type de référence Java Void?

Il existe un type de référence Java Void- V majuscule - . La seule situation que j'ai jamais vue utilisée est de paramétrer s Callable

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

Existe-t-il d'autres utilisations du Voidtype de référence Java ? Peut-on lui attribuer autre chose que null? Si oui, avez-vous des exemples?

Voidest devenue une convention pour un argument générique qui ne vous intéresse pas. Il n'y a aucune raison pour que vous utilisiez un autre type non instanciable, tel que System.

Il est également souvent utilisé dans les Mapvaleurs d' exemple (bien que les Collections.newSetFromMaputilisations en Booleantant que mappes ne doivent pas accepter de nullvaleurs) et java.security.PrivilegedAction.

J'ai écrit une entrée blog sur Voidquelques années en arrière.

Vous pouvez créer une instance de Void en utilisant des réflexions, mais elles ne sont utiles pour rien. Void est un moyen d'indiquer qu'une méthode générique ne renvoie rien.

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

imprime quelque chose comme

I have a java.lang.Void@75636731

Future<Void>fonctionne comme du charme. :)

Étant donné qu'il n'y a pas de constructeurs publics , je dirais que rien d'autre ne peut lui être attribué null. Je ne l'ai utilisé que comme espace réservé pour "Je n'ai pas besoin d'utiliser ce paramètre générique", comme le montre votre exemple.

Il pourrait également être utilisé en réflexion, d'après ce que dit son Javadoc :

La classe Void est une classe d'espace réservé non instable pour contenir une référence à l'objet Class représentant le mot clé Java void.

Toutes les classes d'emballage primitives ( Integer, Byte, Boolean, Double, etc.) contiennent une référence à la classe primitive correspondante dans un statique TYPEchamp, par exemple:

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

Voida été initialement créé comme un endroit pour mettre une référence au voidtype:

Void.TYPE == void.class

Cependant, vous ne gagnez vraiment rien à utiliser Void.TYPE. Lorsque vous utilisez, void.classil est beaucoup plus clair que vous faites quelque chose avec le voidtype.

En passant, la dernière fois que je l'ai essayé, BeanShell ne l'a pas reconnu void.class, vous devez donc l'utiliser Void.TYPE.

Lorsque vous utilisez le modèle de visiteur, il peut être plus simple d'utiliser Void au lieu d'Object lorsque vous voulez être sûr que la valeur de retour sera nulle

Exemple

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

   OUT visit(Leaf2 leaf);
}

Lorsque vous implémenterez votre visiteur, vous pouvez définir explicitement OUT pour être Void afin que vous sachiez que votre visiteur retournera toujours null, au lieu d'utiliser 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;
    }
}

Avant les génériques, il était créé pour l'API de réflexion, pour contenir TYPE renvoyé par Method.getReturnType () pour une méthode void, correspondant aux autres classes de type primitif.

EDIT: Du JavaDoc de Void: "La classe Void est une classe d'espace réservé non instable pour contenir une référence à l'objet Class représentant le mot clé Java void". Avant Generics, je suis conscient de toute utilité autre que la réflexion.

Comme vous ne pouvez pas instancier Void, vous pouvez utiliser l' objet Null Apache commons , donc

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

dans la première ligne, vous avez un objet, donc aNullObject != nulldétient, alors que dans la deuxième ligne il n'y a pas de référence, donc noObjectHere == nulldétient

Pour répondre à la question originale de l'affiche, il s'agit de faire la distinction entre «le rien» et «rien», qui sont des choses complètement différentes.

PS: Dites non au modèle d'objet nul

Void est créé pour envelopper son type de vide primitif. Chaque type primitif a son type de référence correspondant. Void est utilisé pour instancier une classe générique ou utiliser une méthode générique, Un argument générique qui ne vous intéresse pas. Et voici un exemple ...

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

ici, comme vous pouvez le voir, je ne veux rien du serveur auquel je demande de créer de nouvelles inscriptions, mais public interface AsyncCallback<T> { .... }c'est une interface générique donc je fournis Void puisque les génériques n'acceptent pas les types primitifs

Il est également couramment utilisé sur les rappels d'achèvement Async-IO lorsque vous n'avez pas besoin d'un Attachmentobjet. Dans ce cas, vous spécifiez null à l'opération IO et implémentez CompletionHandler<Integer,Void>.

C'est peut-être un cas rare mais une fois, je l'ai utilisé Voiddans des classes d'aspect.

C'était un aspect qui s'exécute après les méthodes qui ont une @Logannotation, et enregistre la méthode retournée et quelques informations si le type de retour de méthode n'est pas void.

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