Usi per il tipo di riferimento Java Void?

Esiste un tipo di riferimentoVoid V maiuscolo Java . L'unica situazione che io abbia mai visto usato è parametrizzare s Callable

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

Ci sono altri usi per il Voidtipo di riferimento Java ? Può mai essere assegnato qualcosa di diverso da null? Se sì, hai degli esempi?

Voidè diventato una convenzione per un argomento generico che non ti interessa. Non vi è alcun motivo per cui dovresti usare qualsiasi altro tipo non istanziale, come System.

È anche spesso usato per esempio in Mapvalori (sebbene gli Collections.newSetFromMapusi Booleancome mappe non debbano accettare nullvalori) e java.security.PrivilegedAction.

Ho scritto una voce sul weblogVoid qualche anno fa.

Puoi creare un'istanza di Void usando le riflessioni, ma non sono utili a nulla. Void è un modo per indicare che un metodo generico non restituisce nulla.

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

stampa qualcosa di simile

I have a java.lang.Void@75636731

Future<Void>funziona come il fascino. :)

Dato che non ci sono costruttori pubblici , direi che non può essere assegnato altro null. L'ho usato solo come segnaposto per "Non ho bisogno di usare questo parametro generico", come mostra il tuo esempio.

Potrebbe anche essere usato in riflessione, da quello che dice il suo Javadoc :

La classe Void è una classe segnaposto non attendibile per contenere un riferimento all'oggetto Class che rappresenta il vuoto della parola chiave Java.

Tutte le classi wrapper primitive ( Integer, Byte, Boolean, Double, etc.) contengono un riferimento alla classe primitiva corrispondente statica TYPEcampo, ad esempio:

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

Voidè stato inizialmente creato come da qualche parte per mettere un riferimento al voidtipo:

Void.TYPE == void.class

Tuttavia, non guadagni davvero nulla usando Void.TYPE. Quando usi void.classè molto più chiaro che stai facendo qualcosa con il voidtipo.

A parte questo, l'ultima volta che l'ho provato, BeanShell non ha riconosciuto void.class, quindi devi usarlo Void.TYPE.

Quando si utilizza il modello visitatore , può essere più pulito utilizzare Void invece di Object quando si desidera essere sicuri che il valore restituito sia null

Esempio

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

   OUT visit(Leaf2 leaf);
}

Quando implementerai il tuo visitatore, puoi impostare esplicitamente OUT su Void in modo che tu sappia che il tuo visitatore restituirà sempre null, invece di usare 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;
    }
}

Prima dei generici, era stato creato per l'API di riflessione, per contenere TYPE restituito da Method.getReturnType () per un metodo void, corrispondente alle altre classi di tipi primitivi.

EDIT: Da JavaDoc di Void: "La classe Void è una classe segnaposto non attendibile per contenere un riferimento all'oggetto Class che rappresenta il vuoto della parola chiave Java". Prima di Generics, non sono a conoscenza di altro che della riflessione.

Poiché non è possibile creare un'istanza di Void, è possibile utilizzare l' oggetto Null commons di Apache , quindi

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

nella prima riga hai un oggetto, quindi aNullObject != nulldetiene, mentre nella seconda riga non vi è alcun riferimento, quindi noObjectHere == nulldetiene

Per rispondere alla domanda originale del poster, l'uso per questo è di distinguere tra "il nulla" e "niente", che sono cose completamente diverse.

PS: Di 'di no al modello di oggetti Null

Void è creato per avvolgere il suo tipo di vuoto primitivo. Ogni tipo primitivo ha il suo tipo di riferimento corrispondente. Void viene utilizzato per creare un'istanza di una classe generica o l'uso di un metodo generico, Argomenti generici che non ti interessano. Ecco un esempio ...

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

qui, come puoi vedere, non voglio nulla dal server che sto chiedendo di creare una nuova registrazione, ma public interface AsyncCallback<T> { .... }è un'interfaccia generica, quindi fornisco il Vuoto poiché i generici non accettano tipi primitivi

Viene anche comunemente utilizzato sui callback di completamento Async-IO quando non si ha la necessità di un Attachmentoggetto. In tal caso si specifica null per l'operazione IO e l'implementazione CompletionHandler<Integer,Void>.

Può essere un caso raro ma una volta l'ho usato Voidnelle classi di aspetto.

Questo era un aspetto che viene eseguito dopo i metodi che hanno @Logun'annotazione e registra il metodo restituito e alcune informazioni se il tipo restituito dal metodo non è nullo.

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