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

Java 21. switch-ի հզորության միացումը

Հոդվածը ուրվագծում է, թե ինչպես է զարգացել Java-ի switch հրամանը, և ցույց է տալիս, թե ինչպես օգտագործել Java 21-ի նոր հնարավորությունները՝ ներդրված record-ների նուրբ pattern matching-ի համար

10 րոպե
javajava21uncoverjavapattern matchingswitch

Վերանայված switch արտահայտությունը (այլևս ոչ թե հրաման) հասանելի է Java 14-ից։ Այն ժամանակ, սակայն, այն կարող էր համընկնում փնտրել միայն հաստատուն արժեքների վրա։ Java 21-ը բերում է pattern matching switch-ի համար, որը switch-ը հասցնում է բոլորովին նոր մակարդակի։

Այս հոդվածում ես ձեզ կուղեկցեմ նոր հնարավորությունների միջով և ցույց կտամ, թե որքան հզոր է դառնում նոր switch-ը, երբ զուգակցվում է record տիպերի և sealed տիպերի հիերարխիաների հետ։ Սկսենք։

Հիմունքները

Սկսենք մի կարճ հիշեցումով, թե ինչ կարող է անել switch արտահայտությունը։ Նայեք առաջին օրինակին, իսկ հետո կանցնենք հիմնական մասերին.

enum Direction {
    NORTH, SOUTH, EAST, WEST;

    int bearing() {
        return switch (this) {                          // (1)
            case NORTH -> 0;                            // (2), (3)
            case SOUTH -> 180;
            case EAST -> 90;
            case WEST -> {
                System.out.println("Go west!");
                yield 270;                              // (4)
            }
        };
    }
}

Արտահայտություն սլաքային պիտակներով

Եթե նկատել եք ձևակերպման փոքր տարբերությունը, այսինքն՝ «հրաման» և «արտահայտություն», ապա դա միտումնավոր է։ Java 14-ից առաջ switch-ը միայն հրաման էր, այսինքն՝ կառավարման կառուցվածք, իսկ նոր switch-ը արտահայտություն է. այն արժեք է արտադրում, ուստի կարելի է այն վերագրել փոփոխականին կամ ուղղակիորեն վերադարձնել, ինչպես (1)-ում։

Նոր switch-ը գալիս է թարմ շարահյուսությամբ՝ այսպես կոչված «սլաքային պիտակներով» (2), որոնց կարող է հաջորդել կա՛մ մեկ արտահայտություն, կա՛մ բլոկ։ Սլաքի աջ կողմի մեկ արտահայտությունը (3) վերադարձվող արժեքն է (հիշեք, որ հիմա դա արտահայտություն է)։ Երբ սլաքի աջ կողմում անհրաժեշտ է մի քանի հրաման պարունակող բլոկ, պետք է օգտագործել նոր yield հիմնաբառը (4)։

Առանց fall-through

Նկատե՞լ եք, որ break հրամաններ չկան։ Սլաքային պիտակների դեպքում դրանք այլևս անհրաժեշտ չեն։ Fall-through-ը լռելյայն տեղի չի ունենում, ուստի հաշվարկը կանգ է առնում առաջին համընկնող case-ի վրա, ինչն իր հերթին նշանակում է, որ կարգը կարևոր է, այսինքն՝ ավելի կոնկրետ դեպքերը պետք է գան առաջինը։

Սպառիչության ստուգում

Փորձեք մեկնաբանել case NORTH -> 0;-ը. ի՞նչ արդյունք կստանաք։ Կոմպիլյատորը պետք է սկսի բողոքել.

java: the switch expression does not cover all possible input values

Սա գալիս է սպառիչության ստուգումից, այսինքն՝ կոմպիլյատորը ստուգում է, որ switch արտահայտությունը մշակում է յուրաքանչյուր հնարավոր արժեք, ինչը ձեզ փրկում է աշխատանքի ընթացքում անակնկալներից։ Ավելին, «ամեն դեպքում» default ճյուղ պետք չէ. երբ կոդը կոմպիլյացվում է, կարող եք վստահ լինել, որ բոլոր դեպքերը մշակված են։

Դեռ կարող եք ավելացնել default դեպք՝ այս կոմպիլյացիայի սխալը շրջանցելու համար, բայց կոմպիլյացիայի ժամանակվա ստուգման շնորհիվ դա պետք է լինի գիտակցված ընտրություն։

Սպառիչության ստուգման մեջ հիանալի է այն, որ այն սահմանափակված չէ enum-ներով. դրան կվերադառնանք ավելի ուշ։

Pattern matching (նմուշների համապատասխանեցում)

Java 21-ը բերում է pattern matching՝ հզոր հնարավորություն, որը կա բազմաթիվ ծրագրավորման լեզուներում (ի թիվս այլոց՝ Scala, Haskell կամ Rust) և թույլ է տալիս քննել օբյեկտի կառուցվածքը, ոչ միայն նրա արժեքը։ Դրանից բացի, այն կարելի է օգտագործել ներդրված օբյեկտային կառուցվածքներից տվյալներ հանելու համար՝ միաժամանակ ստուգելով, թե արդյոք որոշակի պայմաններ կատարվում են։

Տվյալների հանում և ստուգում

Նայեք այս օրինակին.

public record Point(int x, int y) {
}

class Cartesian {

    static void printQuadrant(Point p) {
        switch (p) {
            case Point(var x, var y) when x > 0 && y > 0 -> 
                System.out.println("first");
            default -> 
                System.out.println("other");
        }
    }
}

Անշուշտ նկատել եք, որ այս տողում շատ նոր բաներ են կատարվում.

case Point(var x, var y) when x > 0 && y > 0 ->

Այստեղ մենք՝

  • ստուգում ենք, թե արդյոք համընկնող արժեքը Point տիպի է,
  • հանում ենք x և y դաշտերի արժեքները, որպեսզի դրանք կարելի լինի օգտագործել առանց Point օրինակով անցնելու (նկատեք, որ կոմպիլյատորը կարող է դուրս բերել x-ի և y-ի տիպերը, ուստի կարող եք գրել var իրական տիպի փոխարեն),
  • նոր when հիմնաբառով ստուգում ենք, թե արդյոք կետի կոորդինատները բավարարում են տրված պայմանին։

Java-ի ավելի հին տարբերակում համադրելի արդյունք ստանալու համար կգրեիք մոտավորապես այսպես.

if (p instanceof Point) {
    Point point = (Point) p;

    if (p.x() > 0 && p.y() > 0) {
        System.out.println("first");
    } else {
        System.out.println("other");
    }
}

Pattern matching-ի շարահյուսությունը շատ ավելի հակիրճ է, չէ՞։

Հիշեք, որ pattern matching-ը աշխատում է ոչ միայն switch արտահայտության, այլև instanceof հիմնաբառի հետ։ Այսպես, Java 21-ում այս օրինակը դեռ կարող եք գրել instanceof-ով, պարզապես շատ ավելի կարճ.

if (p instanceof Point(var x, var y) && x > 0 && y > 0) {
    // ...
}

Այստեղ when հիմնաբառ չկա, բայց դրանից բացի pattern matching-ը, հանումը և պայմանի ստուգումը շատ նման են switch-ի տարբերակին։

Null պիտակներ

Իսկ ի՞նչ կլինի, եթե printQuadrant-ին փոխանցված Point p-ն null է։ Ճիշտ է՝ կստանաք NullPointerException։ Դա Java 21-ում էլ նույնն է, բայց հիմա ունեք null դեպքը բացահայտ մշակելու հարմար միջոց՝ case null ->-ի միջոցով, որն օգնում է խուսափել NPE-ից։

Հիշեք, որ այս կոդում.

String test = null;

switch (test) {
    case String s -> System.out.println("String");
    case null -> System.out.println("null");
}

null պիտակն է, որ դեռ համընկնում է, թեև s-ը String տիպի է։

Բացեք switch-ի և pattern matching-ի ուժը

Մինչ այստեղ դիտարկեցինք մի քանի պարզ օրինակ, թե ինչպես են վարվում switch արտահայտությունը և pattern matching-ը։ Սակայն դրանց իրական ուժը դրսևորվում է միայն այն ժամանակ, երբ սկսում եք աշխատել ավելի բարդ տվյալների տիպերի հետ։

Սխալները որպես արժեքներ

Հետևյալ օրինակի համար ճամփորդենք ֆունկցիոնալ ծրագրավորման աշխարհ, որտեղ ամեն ինչ արժեք է, սխալներն էլ՝ ներառյալ։ Սա նկատի ունենալով՝ սխալները բացառություններով ազդարարելու փոխարեն ներկայացնենք դրանք որպես արժեքներ։

Այս մոտեցման առավելությունն այն է, որ մեկ մեխանիզմ (վերադարձվող արժեքը) արտահայտում է ձեր ծրագրի թե՛ հաջող, թե՛ ձախողվող վարքը, այլ ոչ թե հենվում է յուրաքանչյուր սցենարի համար առանձին մեխանիզմների վրա (վերադարձվող արժեքներ կամ բացառություններ)։

Քանի որ գործողությունը կարող է ավարտվել կա՛մ սխալով, կա՛մ հաջողությամբ (որի դեպքում այն վերադարձնում է արժեք), եկեք արդյունքը մոդելավորենք հատուկ տիպով.

public sealed interface Result<E, A> {

    record Success<E, A>(A value) implements Result<E, A> {
    }

    record Failure<E, A>(E error) implements Result<E, A> {
    }
}

Ֆունկցիոնալ ծրագրավորումը սա անվանում է disjoint union կամ coproduct տիպ՝ հայտնի Algebraic Data Types (ADTs)-ից մեկը, ինչը հիմնականում նշանակում է, որ Result-ը կա՛մ Success է, կա՛մ Failure։ Եթե աշխատել եք Vavr-ի և նրանց Either-ի հետ, սա ճիշտ նույնն է՝ այլ անվան տակ։

Նկատե՞լ եք sealed հիմնաբառը ինտերֆեյսի հայտարարության մեջ։ Շուտով կտեսնեք, թե ինչպես է այն հնարավոր դարձնում կոմպիլյացիայի ժամանակվա սպառիչության ստուգումը pattern matching-ում։

Իսկ ի՞նչ կասեք մեր Result-ի E սխալի տիպի մասին։ Այնտեղ կարող եք դնել ինչ-որ բան Throwable հիերարխիայից, բայց առայժմ թողնենք բացառությունները և ավելացնենք ևս մեկ coproduct տիպ՝ սխալները ներկայացնելու համար.

public sealed interface Error {

    record UserNotFound(String userName) implements Error {
    }

    record OtherError(Throwable cause) implements Error {
    }
}

Վերջապես կիրառենք այս տվյալների մոդելը մեր բիզնես տրամաբանության մեջ, որը՝ գործերը պարզ պահելու համար, կլինի մի կեղծ UserService.

public class UserService {

    Result<Error, User> findUser() {
        return new Result.Failure<>(
            new Error.OtherError(new RuntimeException("boom!"))
        );
    }
}

Սխալների մշակում switch-ով

Հիմա, երբ տվյալներն ու բիզնես տրամաբանությունն այսպես մոդելավորված են, մշակենք findUser()-ի տարբեր հնարավոր արդյունքները՝ բնականաբար, pattern matching-ով։

Հաջող արդյունքը կարելի է համապատասխանեցնել այսպես.

switch (userService.findUser()) {
    case Result.Success<?, User> success ->
        System.out.println(STR."User name is \{success.value().name()}");
}

Հետաքրքիր է՝ ի՞նչ է STR-ը։ Նայեք string templates-ը (հիշեք, որ դրանք preview հնարավորություն են)։

Առաջին բանը, որ կնկատեք այս կոդի մասին, այն է, որ այն չի կոմպիլյացվում, ինչը, բարեբախտաբար, հենց այն է, ինչ սպասում ենք։ Pattern matching-ում մշակել եք միայն հաջողության դեպքը, մինչդեռ կա նաև ձախողման սցենար, և կոմպիլյատորը դրա մասին տեղյակ է։ Ինչպե՞ս է տեղյակ։

Պատասխանը Result ինտերֆեյսի հայտարարության մեջ sealed հիմնաբառն է, որն այստեղ կոմպիլյատորին ասում է, որ Result-ի յուրաքանչյուր իրականացում գտնվում է նույն ֆայլում, ինչ Result-ը։ Եթե implements Result անող որևէ բան սահմանեիք մեկ այլ ֆայլում, կոմպիլյատորը կբողոքեր (permits հիմնաբառը թույլ է տալիս շրջանցել սա. sealed տիպերի հիերարխիաների մասին ավելին կարդացեք այստեղ)։ Ամեն դեպքում, հիմնական կետն այն է, որ կոմպիլյատորը գիտի (կոմպիլյացիայի ժամանակ, բնականաբար), թե արդյոք յուրաքանչյուր հնարավոր դեպք մշակված է, և կտեղեկացնի ձեզ, եթե ոմանք չեն (ճիշտ ինչպես սկզբի enum օրինակում)։

Երբ ավելացվում է սխալի դեպքը, կոդը կոմպիլյացվում է.

switch (userService.findUser()) {
    case Result.Success<?, User> success ->
        System.out.println(STR."User name is \{success.value().name()}");
    case Result.Failure<Error, ?> _ ->
        System.out.println("Something went wrong");    
}

Նկատեք, որ Failure օբյեկտի օրինակը անտեսվում է. դա արվում է _-ով, այսինքն՝ անանուն pattern-ով, որը դեռ preview-ում է։ Առանց preview հնարավորությունների միացման՝ դրա տեղում պետք է դնել վավեր նույնացուցիչ և պարզապես երբեք չօգտագործել այն։ Մեկ ընդգծման նշանը (_) վավեր նույնացուցիչ չէ ոչ-preview Java 21-ում, բայց կրկնակի ընդգծումը (__) վավեր է, ուստի վերջինս կարող եք դիտարկել որպես աղքատի անանուն pattern, մինչև իսկականը դուրս գա preview-ից։

Pattern matching ներդրված տիպերի վրա

Վերևի առաջին փորձը երկու տեղում բարելավման տեղ է թողնում.

  • հաջողության դեպքում օգտատիրոջ name դաշտին հասնելը,
  • սխալները ավելի նուրբ մշակելը (հիշեք, որ Error-ը գալիս է մի քանի տարբերակով)։

Քանի որ pattern matching-ը մշակում է նաև ներդրված տվյալների կառուցվածքները, հաջողության ճյուղը կարելի է վերագրել այսպես.

case Result.Success(User(var name, _)) -> 
    System.out.println(STR."User name is \{name}");

Result.Success-ի մեջ ներդրված User-ի վրա համընկնումը թույլ է տալիս հանել name դաշտը և օգտագործել այն անմիջապես սլաքի աջ կողմում։ Նկատեք, որ անանուն pattern-ը (որը Java 21-ում դեռ preview հնարավորություն է, հիշեք) կարելի է օգտագործել նաև ներդրված օբյեկտի դաշտը որպես անտեսվող նշելու համար։

Հիշեք, որ երբ համընկնում եք փնտրում կոնկրետ ներդրված տիպի (User) վրա, այլևս պետք չէ նշել Result.Success-ի ընդհանրացված (generic) տիպերը, քանի որ կոմպիլյատորը դուրս է բերում դրանք։ Նույն կերպ, ինչպես առաջվա Point օրինակում, User record-ի դաշտերի տիպերն էլ են դուրս բերվել, այդ պատճառով էլ var name-ը աշխատում է։

when պայմանները աշխատում են հենց այնպես, ինչպես սպասում եք, օրինակ.

case Result.Success(User(var name, var age)) when age > 18 ->
    System.out.println(STR."\{name} is an adult");

Ձախողման դեպքում մինչ այժմ համընկնում եք փնտրել միայն Error-ի վրա, որը գտնվում է սխալների հիերարխիայի գագաթին։ Սակայն ոչինչ ձեզ չի խանգարում լինել ավելի ճշգրիտ և համընկնում փնտրել առանձին սխալների վրա, որոնք, ի վերջո, պարզապես ներդրված record-ներ են.

case Result.Failure(Error.UserNotFound(var name)) ->
    System.out.println(STR."User \{name} not found");
case Result.Failure(Error.OtherError(var cause)) ->
    System.out.println(STR."Other error: \{cause.getMessage()}");

Հատկանշական է, որ սպառիչության ստուգումը շարունակում է աշխատել ինչպես սպասվում է նույնիսկ ներդրված record-ների դեպքում։ Եթե մեկնաբանեիք վերևի առաջին դեպքը, կոմպիլյատորը կհայտներ, որ համընկնում է միայն Result.Failure(Error.OtherError)-ը, և որ UserNotFound-ով ձախողումը մշակված չէ։ Եվս մեկ անգամ՝ կոմպիլյացիայի ժամանակվա երաշխիքը, որ յուրաքանչյուր հնարավոր դեպք մշակված է, անչափ օգտակար է։

Ամփոփում

Այս հոդվածը թարմացրեց ձեր գիտելիքները, թե ինչպես է զարգացել switch հրամանը։ Java 14-ից այն արտահայտություն է, որը արժեք է տալիս, հենվում է «սլաքային պիտակների» շարահյուսության վրա yield-ի հետ միասին, լռելյայն չի անցնում հաջորդ դեպքին (fall-through) և կոմպիլյացիայի ժամանակ ստուգում է, որ յուրաքանչյուր հնարավոր դեպք մշակված է։

Տեսաք նաև, թե ինչպես է pattern matching-ը թույլ տալիս ստուգել, արդյոք օբյեկտները ունեն սպասվող կառուցվածքը՝ ներառյալ NullPointerException-ներից խուսափելու ներկառուցված եղանակը null պիտակի միջոցով, և ինչպես հանել տվյալներ այդ կառուցվածքից՝ կոմպիլյատորի կողմից տիպերի դուրս բերմամբ։

Վերջապես սովորեցիք, թե ինչպես առավելագույնս օգտվել այս ամենից՝ նուրբ pattern matching անելու համար ներդրված record-ներից և sealed հիմնաբառից կառուցված coproduct տիպերի (Algebraic Data Types-ից մեկը) sealed հիերարխիայի վրա։

Ինչպե՞ս եք վերաբերվում այն նոր հնարավորություններին, որոնք switch-ը նոր ձեռք բերեց։ Ազատ զգացեք դիմել ցանկացած հարցով։

Պաշտոնական փաստաթղթերը հասանելի են Java Language Updates-ում, մասնավորապես switch արտահայտությունների և pattern matching-ի գլուխները։