Type gevolgtrekking door de Java-compiler

1. Syntactische suiker

Programmeurs houden ervan wanneer een complexe code of logica in een paar regels kan worden geschreven, waardoor code compact en leesbaar wordt. En de makers van programmeertalen helpen daar soms bij.

Een gelikte taalfunctie waarmee je een kortere weg kunt nemen (minder code schrijven) wordt syntactische suiker genoemd . Maar om eerlijk te zijn, er is er heel weinig van op Java.

De makers van Java hebben er alles aan gedaan om redundantie in Java te elimineren. Als je met C++ iets op 20 manieren kunt doen, dan kun je het met Java maar op één manier doen.

Maar noch Java-programmeurs, noch de makers van Java hielden van het gebrek aan vrijheid. En soms maakt suiker het leven gemakkelijker voor gewone mensen zoals jij en ik.

Trouwens, je bent al wat syntactische suiker tegengekomen: autoboxing en unboxing . Laten we vergelijken:

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)
{
   ...
}

In plaats van de lange code zoals aan de linkerkant, kun je de compactere code aan de rechterkant schrijven. En een intelligente Java-compiler genereert de uitgebreide versie van de code op basis van de korte versie van de code. Dit is precies wat syntactische suiker is.

2. Inferentie van het type van een variabele: het varsleutelwoord

In Java 11 is de compiler nog slimmer geworden en kan nu het type van een gedeclareerde variabele bepalen op basis van het type waarde dat eraan is toegewezen . In code ziet het er zo uit:

var name = value;

Waar nameis de naam van een nieuwe variabele, waarde is de beginwaarde en varis een sleutelwoord dat wordt gebruikt om de variabele te declareren. Het type van de naamvariabele is hetzelfde als het type waarde dat eraan is toegewezen.

Voorbeelden:

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

De compiler bepaalt zelf het type van de variabele of leidt dit af op basis van de waarde die eraan is toegewezen.

Programmeurs debatteerden fel over het al dan niet toevoegen van een dergelijke functie aan de taal. Veel mensen vreesden dat varmisbruik zou worden gemaakt en dat de leesbaarheid van de code daardoor zou afnemen.

Hier zit een kern van waarheid in, dus het is het beste om te gebruiken varwaar het de leesbaarheid van de code vergroot. Deze bijvoorbeeld in twee gevallen:

Geval 1: kijkend naar de waarde die aan de variabele is toegekend, is het type van de variabele meteen duidelijk

var stream = url.getInputStream();

var name = person.getFullName();

In deze gevallen mag u geen var. Wat is het type van de variabele?

var result = task.execute();

var status = person.getStatus();

Geval 2: het type van de variabele is niet belangrijk voor het begrijpen van de code

Code hoeft vaak geen methodes op een variabele aan te roepen, bijvoorbeeld wanneer een variabele gewoon wordt gebruikt om tijdelijk iets op te slaan. In dit geval varvermindert het gebruik zeker niet de leesbaarheid van de code:

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

De gulden middenweg

Nu geef ik drie manieren om dezelfde code te schrijven. Gebruiken varzou de beste optie zijn.

dest.writeHeaderInfo(src.getFileMetaInfo());

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

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

Door van de versie met 1 regel naar de versie met 2 regels te gaan, hebben we de code iets leesbaarder gemaakt door een variabelenaam ( headerInfo) te gebruiken. Nu is het duidelijk dat de methode niet alleen meta-informatie retourneert, maar ook header-informatie.

De derde versie is overdreven uitgebreid. Dat headerInfohet a is FileMetaInfoblijkt al vrij duidelijk uit de getFileMetaInfo()methode. Het doel van de meta-informatie is veel interessanter.

3. Type weglaten met de diamantoperator:<>

Zelfs voordat de varoperator verscheen, waren er pogingen om de compiler te leren verzamelingstypen af ​​te leiden. U zult het ermee eens zijn dat deze notatie een beetje overbodig lijkt:

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

Vanaf de zevende versie van Java kon je bij het schrijven van een verzamelingstype het type van de verzamelingselementen weglaten als dit was opgegeven bij het declareren van een variabele. Met andere woorden, de bovenstaande code kan in een enigszins verkorte vorm worden geschreven:

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

Zoals u kunt zien, hoeft u String niet langer een tweede keer te schrijven. Niet zo cool als bij de var-operator, maar het leek op dat moment vooruitgang.

De lege punthaken in het verzamelingstype werden de diamantoperator genoemd , omdat de twee punthaken vaag op een diamant lijken.

Het is onwenselijk om het vartrefwoord en de diamantoperator tegelijkertijd te gebruiken :

var list = new ArrayList<>();

Er is helemaal geen informatie over het type elementen dat in de verzameling is opgeslagen en het verzamelingstype is ArrayList < Object >.

4. Dubbele accolades

Herinner je je snelle array-initialisatie?

We hebben zojuist waarden tussen accolades weergegeven, zoals deze:

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

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

De makers van Java hielden van het idee om accolades te gebruiken om het schrijven van elementen van een array te vereenvoudigen. Maar hoe zit het met collecties?

De makers van Java hadden ook genoeg creatief denkvermogen voor collecties, waardoor ze een trucje met dubbele accolades konden gebruiken.

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?");

Als de compiler code tegenkomt zoals in het voorbeeld aan de linkerkant, dan converteert hij deze naar de code aan de rechterkant.

Veel compacter wordt de code niet. De besparingen zijn hier vrij onbeduidend: u hoeft niet listelke keer te schrijven. Dit kan handig zijn als de naam van de variabele erg lang is.

Maar als je dergelijke code tegenkomt in een project, wees dan niet verbaasd 🙂