Գնահատել նախագիծը
← Բոլոր հրապարակումները

Java 27. Պրիմիտիվ տիպերը pattern-ներում, instanceof-ում և switch-ում

Տեսեք, թե ինչպես է Java 27-ը պրիմիտիվ տիպերը բերում instanceof և switch, կոդն ավելի ընթեռնելի դարձնելով

4 րոպե
Javauncoverjavapattern matchingswitch

Ամեն վեց ամիսը մեկ Java-ի նոր, թարմ և համեղ տարբերակ է հայտնվում։ Այս անգամ դա Java 27-ն է, և այս հոդվածում կանդրադառնանք JEP-532-ին, որը պրիմիտիվ տիպերը բերում է pattern-ներ, instanceof և switch։ Հիշեք, որ դա preview հնարավորություն է։

JEP-ի վերնագիրը կարող է թվալ, թե ամեն ինչ ասում է, բայց արժե մի փոքր ավելի խորանալ։

Նշում. Այս հոդվածը առաջին անգամ հայտնվեց 2024-ի սեպտեմբերին։ Ես այն վերանայել եմ 2026-ի սեպտեմբերին՝ Java 27 թողարկմանը համապատասխանեցնելու համար, ուստի այն արտացոլում է այդ տարբերակի հետ եկած նորագույն փոփոխություններն ու բարելավումները։

Մինչև Java 25-ը

Տեսնենք, թե ինչպես էին գործերը մինչև այս JEP-ը։ switch-ի կամ instanceof-ների հետ աշխատելը ուներ զգալի սահմանափակումներ։ switch-ում ոչ բոլոր boxed տիպերը կարող էին օգտագործվել։

Եթե փորձեիք գրել այս կոդը,

Double d = 20.0d;
switch(d){
   case 20.0d -> log("double is 20");
   default -> log("wrong number" + d);
}

կստանայիք այս compile սխալը՝

java: constant label of type double is not compatible with switch selector type java.lang.Double

Պատճառն այն է, որ որոշ տիպեր սահմանափակված էին։ JLS-ը նշում է՝

«Այս Expression-ը կոչվում է selector expression։ Նրա տիպը պետք է լինի char, byte, short, int կամ reference տիպ. հակառակ դեպքում compile-time սխալ է առաջանում։»

Մեջբերումը մեզ ասում է, որ int տիպը կարող է օգտագործվել switch-ում։ Իսկապես, կարող եք գրել այսպիսի կոդ՝

int v = 20;
switch(v){
   case 20 -> log("int is 20");
   default -> log("wrong number" + v);
}

և ամեն ինչ լավ է աշխատում։ Ինչպես գուցե գիտեք, switch-ը Java 21-ում շատ բարելավումներ ստացավ՝ թույլ տալով գրել նման բան՝

Integer v = 20;
switch(v){
   case Integer i when i < 20-> log("This value is too low: " + i );
   case Integer i -> log("This value is perfect: " + i );
}

Լավն է, չէ՞։ Փորձենք նույնը պրիմիտիվ int-ով։

int v = 20;
switch(v){
   case int i when i < 20 -> log("This value is too low: " + i );
   case int i -> log("This value is perfect: " + i );
}

Այս կոդի գործարկումը ավարտվում է compile սխալով՝

java: unexpected type

  required: class or array

  found:    int

Ո՞րն է պատճառը։ JEP-507-ից առաջ switch pattern-ները Java-ում միայն մասամբ էին աջակցվում։

Այսպիսի Switch Pattern-ները կարող էին օգտագործվել Record Pattern-ների հետ։

record Value(int i){}
void test(){
   Value v = new Value(20);
   switch (v) {
       case Value(int i) when i < 20 -> log("This value is too low: " + i );
       case Value(int i) -> log("This value is perfect: " + i );
   }
}

Սա աշխատում է ինչպես սպասվում է։ Իսկ instanceof-ը ընդհանրապես չէր աջակցում որևէ պրիմիտիվ տիպ։

Java 25-ից հետո – preview-feature-ը միացված

switch-ն այժմ ընդունում է Long, Float, Double և Boolean, ուստի Double-ով նախորդ օրինակը աշխատում է։

Instanceof-ը նույնպես այլ կերպ է վարվում. այժմ կարող եք ստուգել՝ փոփոխականը պրիմիտիվ տիպի՞ է։

Այսուհետ նման կոդի գործարկումը՝

int i = 42;
if(i instanceof int){
   log("i is an instance of int");
}

կոնսոլում տպում է “i is an instance of int”։ Գերազանց։ Իսկ այս կոդի՞ մասին։

int i = 42;
if(i instanceof byte){
   log("i is an instance of byte?");
}

Բավական պարզ է, չէ՞։ Ոչինչ չի տպվի, քանի որ int-ը byte-ի instance չէ։ Բացառությամբ այն բանի, որ այս օրինակում մենք իսկապես ստանում ենք “i is an instance of byte?” տեքստը։

Ինչո՞ւ է այդպես։

Ամեն ինչ հանգում է casting-ին՝ Java-ի հիմնական մեխանիզմին, որով մեկ պրիմիտիվ տվյալների տիպի արժեքը վերագրվում է մեկ այլ տիպի։

Գիտեի՞ք, որ casting-ը անվտանգ չէ։ Նայեք այս օրինակին՝

int i = 42;
byte b = (byte) i;
log("b value is " + b);

Մեր b փոփոխականը կպահի 42, չէ՞։ Իսկ հիմա՞։

int i = 128;
byte b = (byte) i;
log("b value is " + b);

Հավանաբար զգում եք, որ այս հարցում որս կա, և ճիշտ եք. b-ն կլինի -128։ Դա տեղի է ունենում, քանի որ byte տիպը ընդգրկում է -128-ից մինչև 127 տիրույթը՝ ներառյալ։ Կարող եք ավելին կարդալ Integral Types and Values-ի մասին։

Սա հարց է առաջացնում. եթե casting-ը փոխում է արժեքը, արդյո՞ք դա ճիշտ տիպն է։ JEP-ի համաձայն՝ ոչ։

Ահա թե ինչու instanceof-ն այժմ ոչ միայն ստուգում է, որ տիպը ճիշտ է reference-ների համար, այլ պրիմիտիվ արժեքների համար նաև ստուգում է՝ արդյո՞ք արժեքը կարելի է անվտանգ cast անել։

Ինչի՞ է սա հանգեցնում։

Մինչև Java 25-ը նման կոդ փորձելը՝

Integer i = 42;
switch (i) {
   case Double d -> log("i is " + d); 
}

հանգեցնում էր սխալի՝

error: incompatible types: Integer cannot be converted to Double

Սակայն պրիմիտիվների դեպքում նման կոդը՝

int i = 42;
switch (i) {
   case double d -> log("i is " + d)
}

աշխատում է առանց խնդիրների, քանի որ ցանկացած int կարելի է անվտանգ cast անել double-ի։ Եթե նույնը փորձեք ավելի նեղ տիպերով, ձեր switch-ը պետք է exhaustive լինի, այսպես՝

int i = 10_0000;
switch (i) {
   case short v -> log("i is " + v);
   default -> log("not in scope of short" + i);
}

Պարզելու համար՝ արդյո՞ք պրիմիտիվ տիպը մեկ այլի cast անելը անվտանգ է, տեսեք Casting Contexts in JLS-ը։

Ամփոփում

switch pattern-ները շարունակում են ավելի օգտակար դառնալ առօրյա աշխատանքում։ Project Amber-ը այժմ թույլ է տալիս պրիմիտիվները մշակել ավելի հեշտ և ավելի քիչ ծավալուն մեթոդներով։