Inferenza del tipo di compilatore Java

1. Zucchero sintattico

I programmatori adorano quando un codice o una logica complessi possono essere scritti in un paio di righe, rendendo il codice compatto e leggibile. E i creatori di linguaggi di programmazione a volte aiutano in questo.

Una caratteristica del linguaggio semplice che ti consente di prendere una scorciatoia (scrivere meno codice) si chiama syntactic sugar . Ma, ad essere onesti, in Java ce n'è ben poco.

I creatori di Java hanno fatto tutto il possibile per eliminare qualsiasi ridondanza in Java. Se il C++ ti consente di fare qualcosa in 20 modi, allora Java ti consente di farlo solo in un modo.

Ma né ai programmatori Java né ai creatori di Java piaceva la mancanza di libertà. E a volte lo zucchero rende la vita più facile alle persone comuni come te e me.

A proposito, hai già incontrato un po' di zucchero sintattico: autoboxing e unboxing . Confrontiamo:

Integer a = new Integer(5);
int b = a.intValue();

Integer a = 5;
int b = a;

int b = 5;
Integer c = new Integer(b);

int b = 5;
Integer c = b;

Integer a = new Integer(1);
int b = 1;
if (a.intValue() == b)
{
   ...
}

Integer a = 1;
int b = 1;
if (a == b)
{
   ...
}

Invece del codice lungo come a sinistra, puoi scrivere il codice più compatto a destra. E il compilatore Java intelligente genererà la versione dettagliata del codice in base alla versione breve del codice. Questo è esattamente ciò che è lo zucchero sintattico.

2. Inferenza del tipo di una variabile: la varparola chiave

In Java 11, il compilatore è diventato ancora più intelligente e ora può determinare il tipo di una variabile dichiarata in base al tipo del valore ad essa assegnato . Nel codice, assomiglia a questo:

var name = value;

Dove nameè il nome di una nuova variabile, value è il suo valore iniziale ed varè una parola chiave utilizzata per dichiarare la variabile. Il tipo della variabile nome sarà uguale al tipo del valore ad essa assegnato.

Esempi:

var i = 1;

int i = 1;

var s = "Hello";

String s = "Hello";

var console = new Scanner(System.in);

Scanner console = new Scanner(System.in);

var list = new ArrayList<String>();

ArrayList<String> list = new ArrayList<String>();

var data = new int[]{1, 2, 3};

int[] data = new int[]{1, 2, 3};

Il compilatore stesso determina, o deduce, il tipo della variabile in base al valore ad essa assegnato.

I programmatori hanno discusso animatamente sull'opportunità di aggiungere una tale funzionalità al linguaggio. Molte persone temevano che varsarebbe stato abusato e che la leggibilità del codice ne avrebbe risentito.

C'è un granello di verità in questo, quindi è meglio usarlo vardove aumenta la leggibilità del codice. Ad esempio, questi in due casi:

Caso 1: Guardando il valore assegnato alla variabile, il tipo della variabile è immediatamente chiaro

var stream = url.getInputStream();

var name = person.getFullName();

In questi casi, non dovresti usare var. Bene, qual è il tipo di variabile?

var result = task.execute();

var status = person.getStatus();

Caso 2: il tipo di variabile non è importante per la comprensione del codice

Il codice spesso non ha bisogno di chiamare metodi su una variabile, ad esempio quando una variabile viene semplicemente utilizzata per memorizzare temporaneamente qualcosa. In questo caso, l'utilizzo varsicuramente non riduce la leggibilità del codice:

var data = stream.getMetaData();
storage.save(data)

Il mezzo aureo

Ora darò tre modi per scrivere lo stesso codice. Usare varsarebbe l'opzione migliore.

dest.writeHeaderInfo(src.getFileMetaInfo());

var headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

FileMetaInfo headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

Passando dalla versione con 1 riga alla versione su 2 righe, abbiamo reso il codice un po' più leggibile utilizzando un nome di variabile ( headerInfo). Ora è chiaro che il metodo restituisce non solo meta informazioni, ma informazioni di intestazione.

La terza versione è eccessivamente prolissa. Il fatto che headerInfosia a FileMetaInfoè già abbastanza chiaro dal getFileMetaInfo()metodo. Lo scopo delle meta informazioni è molto più interessante.

3. Omettendo il tipo con l'operatore diamante:<>

Anche prima che varcomparisse l'operatore, ci sono stati tentativi di insegnare al compilatore come dedurre i tipi di raccolta. Sarai d'accordo che questa notazione sembra un po' ridondante:

ArrayList<String> list = new ArrayList<String>();

A partire dalla settima versione di Java, durante la scrittura di un tipo di raccolta, era possibile omettere il tipo degli elementi della raccolta se specificato durante la dichiarazione di una variabile. In altre parole, il codice sopra può essere scritto in forma leggermente abbreviata:

ArrayList<String> list = new ArrayList<>();

Come puoi vedere, non è più necessario scrivere String una seconda volta. Non così bello come con l'operatore var, ma all'epoca sembrava un progresso.

Le parentesi angolari vuote nel tipo di raccolta erano chiamate operatore diamante , poiché le due parentesi angolari assomigliano vagamente a un diamante.

Non è auspicabile utilizzare contemporaneamentevar la parola chiave e l' operatore diamante :

var list = new ArrayList<>();

Non ci sono informazioni sul tipo di elementi memorizzati nella raccolta e il tipo di raccolta sarà ArrayList < Object >.

4. Doppie parentesi graffe

Ricordi l'inizializzazione rapida dell'array?

Abbiamo appena elencato i valori tra parentesi graffe, in questo modo:

int[] data = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] data = {1, 2, 3, 4, 5, 6, 7};

I creatori di Java adoravano l'idea di usare le parentesi graffe per semplificare la scrittura degli elementi di un array. Ma per quanto riguarda le collezioni?

I creatori di Java avevano abbastanza pensiero creativo anche per le collezioni, permettendo loro di usare un trucco con doppie parentesi graffe.

var list = new ArrayList<String>()
{{
   add("Hello");
   add("How's");
   add("Life?");
}};

var list = new ArrayList<String>();

list.add("Hello");
list.add("How's");
list.add("Life?");

Se il compilatore incontra il codice come nell'esempio a sinistra, lo converte nel codice a destra.

Il codice non diventa molto più compatto. I risparmi qui sono abbastanza insignificanti: non devi scrivere listogni volta. Questo può essere utile se il nome della variabile è molto lungo.

Ma se ti imbatti in un codice come questo in un progetto, non essere sorpreso 🙂