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

StackOverflow https://stackoverflow.com/questions/643906

  •  22-07-2019
  •  | 
  •  

Question

Il existe un Java Void - V majuscule - type de référence . La seule situation que je connaisse utilisée consiste à paramétrer Callable s 

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

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

Était-ce utile?

La solution

Void est devenu la convention d'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é par exemple dans les valeurs Map (bien que Collections.newSetFromMap utilise Boolean car les cartes n'ont pas à accepter les null valeurs) et java.security.PrivilegedAction.

J'ai écrit un entrée de blog sur <=> il y a quelques années.

Autres conseils

Vous pouvez créer une instance de Void en utilisant des réflexions, mais elles ne servent à rien. Void est un moyen d'indiquer qu'une méthode générique ne retourne 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 un charme. :)

Etant donné qu'il existe pas de constructeur public , Je dirais qu'il ne peut être attribué autre chose que null. Je ne l'ai utilisé que comme paramètre fictif pour & "Je n'ai pas besoin d'utiliser ce paramètre générique, &"; comme votre exemple le montre.

Il pourrait également être utilisé en réflexion, à partir de quoi Javadoc dit:

  

La classe Void est une classe fictive non instanciable destinée à contenir une référence à l'objet Class représentant le mot clé Java void.

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

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

Void a été créé à l'origine pour créer une référence au void type: 

Void.TYPE == void.class

Cependant, vous ne gagnez rien en utilisant Void.TYPE. Lorsque vous utilisez void.class, il est beaucoup plus clair que vous faites quelque chose avec le type <=>.

En passant, la dernière fois que j'ai essayé, BeanShell ne reconnaissait pas <=>, donc vous devez utiliser <=> ici.

Lorsque vous utilisez le modèle de visiteur , il peut être plus simple d'utiliser Void au lieu d'Object si vous voulez vous assurer que la valeur de retour sera null

Exemple 

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

   OUT visit(Leaf2 leaf);
}

Lorsque vous implémentez votre visiteur, vous pouvez explicitement définir OUT sur null afin que vous sachiez que votre visiteur retournera toujours la valeur 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 afin de conserver TYPE renvoyé par Method.getReturnType () pour une méthode void, correspondant aux autres classes de types primitives.

EDIT: à partir du JavaDoc de Void: & "La classe Void est une classe d’espace réservé non instanciable destinée à contenir une référence à l’objet Class représentant le mot clé Java void &" ;. Avant Generics, je ne connaissais aucune autre utilisation que la réflexion.

Comme vous ne pouvez pas instancier un vide, vous pouvez utiliser Objet Null commun Apache , donc 

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

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

Pour répondre à la question initiale de l'affiche, son utilisation est de différencier & "le rien &"; et & "rien &"; qui sont des choses complètement différentes.

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

Void est créé pour envelopper son type de vide primitif. Chaque type de primitive a son type de référence correspondant. Void est utilisé pour instancier une classe générique ou pour utiliser une méthode générique. Arguments génériques qui ne vous intéressent pas. 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 constater, je ne veux rien du serveur auquel je demande de créer un nouvel enregistrement, mais public interface AsyncCallback<T> { .... } est une interface générique, donc je fournis Void, car 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 objet Attachment. Dans ce cas, vous spécifiez null pour l'opération IO et implémentez CompletionHandler<Integer,Void>.

Cela peut être un cas rare mais jadis, j’ai utilisé Void dans des classes d’aspect.

Cet aspect est exécuté après les méthodes ayant une annotation @Log et enregistre la méthode renvoyée ainsi que des informations si le type de méthode est renvoyé. 

 @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
         }
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top