Spiegazione dettagliata dell'analisi e dell'uso della classe java.lang.Void

Oggi, esaminando il codice sorgente, ho trovato la classe java.lang.Void. A cosa serve?

Prima esaminiamo il codice sorgente

package java.lang;
/**
 * La classe {@code Void} è una classe di placeholder non instanziabile per mantenere una
 * riferimento all'oggetto {@code Class} che rappresenta la parola chiave Java
 * void.
 *
 * @author senza nome
 * @since JDK1.1
 */
public final
class Void {
  /**
   * L'oggetto {@code Class} che rappresenta il tipo pseudo-corrispondente a
   * la parola chiave {@code void}.
   */
  @SuppressWarnings("unchecked")
  public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");
  /*
   * La classe Void non può essere istanziata.
   */
  private Void() {}
}

Dal codice sorgente si scopre che la classe è definita come final, non può essere ereditata e il costruttore è privato, non può essere utilizzato new.

Quindi, qual è la funzione di questa classe?

Di seguito esaminiamo il codice sorgente della classe java.lang.Integer

Sappiamo tutti che la classe di wrapper per int è java.lang.Integer

　

Da questo si può notare che java.lang.Integer è una classe di wrapper per int.

Analogamente, attraverso il codice sorgente di java.lang.Void è possibile vedere che java.lang.Void è una classe di wrapper per il concetto void.

public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");

Uso di Void

La classe Void è una classe di placeholder non instanziabile, se il tipo di ritorno del metodo è Void, allora il metodo può solo restituire il tipo null.

Esempio di seguito:

public Void test() { 
  return null;
}

Scena d'uso uno:

Future<Void> f = pool.submit(new Callable() {
  @Override
  public Void call() throws Exception {
    ......
    return null;
  }
});

Ad esempio, utilizzare l'interfaccia Callable, che deve restituire un valore, ma dopo l'esecuzione effettiva non ci sono dati da restituire. In questo caso, può essere utilizzato il tipo Void come tipo di ritorno.

Scena d'uso due:

Ottiene tutti i metodi che restituiscono void tramite reflection.

public class Test {
  public void ciao() { }
  public static void main(String args[]) {
    for (Method method : Test.class.getMethods()) {
      if (method.getReturnType().equals(Void.TYPE)) {
        System.out.println(method.getName());
      }
    }
  }
}

Risultato dell'esecuzione:

main
ciao
wait
wait
wait
notify
notifyAll

ps: di seguito si introduce la comparazione e l'uso di java.lang.Void con void

La parola chiave void indica che la funzione non ha risultati di ritorno, è una parola chiave in java.

java.lang.Void è un tipo. Ad esempio, assegnare null a un riferimento Void.

Void nil = null;

Dal codice della classe Void si può vedere che il tipo Void non può essere ereditato né istanziato.

public final
class Void {
  /**
   * L'oggetto {@code Class} che rappresenta il tipo pseudo-corrispondente a
   * la parola chiave {@code void}.
   */
  @SuppressWarnings("unchecked")
  public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");
  /*
   * La classe Void non può essere istanziata.
   */
  private Void() {}
}

La parola chiave Void come risultato di una funzione rappresenta null (a parte null, non possono essere restituiti altri tipi).

 Funzione vuota(int a, int b) {
  //fare qualcosa
  return null;
 }

Prima dell'introduzione dei generici, Void viene generalmente utilizzato nel reflection. Ad esempio, il seguente codice stampa il nome del metodo di ritorno void.

public class Test {
  public void print(String v) {}
  public static void main(String args[]){
    for(Method method : Test.class.getMethods()) {
      if(method.getReturnType().equals(Void.TYPE)) {
        System.out.println(method.getName());
      }
    }
  }
}

Dopo l'introduzione dei generici, il tipo Void viene utilizzato in alcune situazioni. Ad esempio, Future<T> viene utilizzato per salvare i risultati. Il metodo get di Future restituirà il risultato (di tipo T).

Ma cosa succede se l'operazione non restituisce un valore? In questo caso si può utilizzare Future<Void>. Dopo che il calcolo del risultato è completato e chiamato get, verrà restituito null.

Inoltre, Void viene utilizzato anche nei Map senza valore, ad esempio Map<T, Void>, in cui la map avrà la stessa funzione di Set<T>.

Pertanto, quando si utilizzano i generici, la funzione non deve restituire un risultato o un oggetto non necessita di un valore, in questo caso è possibile utilizzare il tipo java.lang.Void.

Sommario

Quello che è stato descritto sopra è la spiegazione dettagliata della classe java.lang.Void e del suo utilizzo che l'editor ha presentato agli utenti. Spero che sia utile a tutti. Se avete qualsiasi domanda, lasciate un commento e l'editor risponderà tempestivamente. In questo senso, ringrazio anche tutti i sostenitori del sito tutorial di URLa!

Dichiarazione: il contenuto di questo articolo è stato prelevato da Internet, i diritti d'autore appartengono agli autori originali, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare il problema, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.