Írja be a Java fordító általi következtetést

1. Szintaktikus cukor

A programozók szeretik, ha néhány összetett kód vagy logika néhány sorban írható, így a kód kompakt és olvasható. A programozási nyelvek készítői pedig néha segítenek ebben.

Egy sima nyelvi funkciót, amely lehetővé teszi a parancsikon használatát (kevesebb kód írását), szintaktikai cukornak nevezzük . De, hogy őszinte legyek, nagyon kevés van belőle a Java-ban.

A Java készítői mindent megtettek annak érdekében, hogy kiküszöböljék a Java redundanciáját. Ha a C++ lehetővé teszi, hogy valamit 20 módon csinálj, akkor a Java csak egyféleképpen.

De sem a Java programozóknak, sem a Java alkotóinak nem tetszett a szabadság hiánya. És néha a cukor megkönnyíti az olyan hétköznapi emberek életét, mint te és én.

Egyébként már találkoztál néhány szintaktikai cukorral: autoboxing és unboxing . Hasonlítsuk össze:

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

A bal oldali hosszú kód helyett jobbra írhatjuk a kompaktabb kódot. Az intelligens Java fordító pedig a kód rövid verziója alapján generálja a kód bőbeszédű verzióját. Pontosan ez a szintaktikai cukor.

2. Következtetés a változó típusára: a varkulcsszó

A Java 11-ben a fordító még intelligensebbé vált, és most már képes meghatározni a deklarált változó típusát a hozzárendelt érték típusa alapján . Kódban így néz ki:

var name = value;

Ahol nameaz új változó neve, az érték a kezdeti értéke, és vara változó deklarálására használt kulcsszó. A névváltozó típusa megegyezik a hozzá rendelt érték típusával.

Példák:

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

A fordító maga határozza meg vagy következtet a változó típusára a hozzá rendelt érték alapján.

A programozók heves vitákat folytattak arról, hogy hozzáadjanak-e egy ilyen funkciót a nyelvhez. Sokan attól tartottak, hogy ezzel varvisszaélnek, és emiatt a kód olvashatósága megsérül.

Ebben van egy kis igazság, ezért a legjobb ott használni, varahol ez növeli a kód olvashatóságát. Például ezek két esetben:

1. eset: Ha megnézzük a változóhoz rendelt értéket, azonnal egyértelmű a változó típusa

var stream = url.getInputStream();

var name = person.getFullName();

Ezekben az esetekben nem szabad használni var. Nos, mi a változó típusa?

var result = task.execute();

var status = person.getStatus();

2. eset: A változó típusa nem fontos a kód megértéséhez

A kódnak gyakran nincs szüksége metódusok meghívására egy változón, pl. amikor egy változót egyszerűen valami ideiglenes tárolására használnak. Ebben az esetben a használat varhatározottan nem csökkenti a kód olvashatóságát:

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

Az arany középút

Most háromféleképpen írhatom le ugyanazt a kódot. Használata varlenne a legjobb megoldás.

dest.writeHeaderInfo(src.getFileMetaInfo());

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

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

Az 1 soros verzióról a 2 soros verzióra áttérve egy változónév ( ) használatával kicsit olvashatóbbá tettük a kódot headerInfo. Most már világos, hogy a metódus nem csak metainformációkat ad vissza, hanem fejléc információkat is.

A harmadik verzió túlságosan bőbeszédű. Az a tény, hogy headerInfoa, FileMetaInfomár eléggé világos a módszerből getFileMetaInfo(). A metainformáció célja sokkal érdekesebb.

3. A típus elhagyása a gyémánt operátorral:<>

Már az operátor megjelenése előtt is varvoltak kísérletek arra, hogy megtanítsák a fordítót a gyűjteménytípusok kikövetkeztetésére. Ön egyetért abban, hogy ez a jelölés kissé feleslegesnek tűnik:

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

A Java hetedik verziójától kezdve egy gyűjteménytípus írásakor elhagyható a gyűjteményelemek típusa, ha azt a változó deklarálásakor megadtuk. Más szavakkal, a fenti kód enyhén lerövidített formában írható:

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

Amint látja, többé nem kell másodszor írni a String-et. Nem olyan menő, mint a var operátornál, de akkoriban előrelépésnek tűnt.

A kollekciótípus üres szögletes zárójeleit gyémánt operátornak nevezték , mivel a két saroktartó homályosan hasonlít egy gyémántra.

varNem kívánatos a kulcsszó és a gyémánt operátor egyidejű használata :

var list = new ArrayList<>();

A gyűjteményben tárolt elemek típusáról egyáltalán nincs információ, a gyűjtemény típusa ArrayList < Object > lesz.

4. Dupla göndör nadrágtartó

Emlékszel a gyors tömb inicializálására?

Csak az értékeket soroltuk fel göndör kapcsos zárójelben, például:

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

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

A Java készítői szerették a göndör kapcsos zárójelek használatát a tömb íráselemeinek egyszerűsítésére. De mi a helyzet a gyűjteményekkel?

A Java készítőinek a kollekciókhoz is elég kreatív gondolkodásuk volt, lehetővé téve számukra a dupla göndör kapcsos fogszabályzós trükk használatát.

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

Ha a fordító olyan kóddal találkozik, mint a bal oldali példában, akkor azt konvertálja a jobb oldali kódra.

A kód nem lesz sokkal tömörebb. A megtakarítás itt meglehetősen jelentéktelen: nem kell listminden alkalommal írni. Ez akkor lehet hasznos, ha a változó neve nagyon hosszú.

De ha egy projektben ilyen kóddal találkozol, ne lepődj meg 🙂