kifejezést váltani

Az ismétlés a tanulás anyja. Bár korábban már beszéltünk a Java switch kulcsszóról, ma áttekintjük az alapokat, és beleásunk néhány új információba.

A Java kétféle switch konstrukcióval rendelkezik: a switch utasítás és a switch kifejezés. A switch kifejezés a Java 14-ben vált hivatalossá, miután két nem hivatalos "előzetes" változatban létezett a 12-es és 13-as verziókban.

De kezdjük elölről. Idézzük fel, hogyan nézett ki egy jó öreg kapcsoló a 12-es verzió előtt:

public String getProductTypeByName(String product) {
    String productType = "";

    switch (product) {
        case "Apple":
            productType = "Fruit";
            break;

        case "Peach":
            productType = "Fruit";
            break;

        case "Raspberry":
            productType = "Berry";
            break;

        case "Cherry":
            productType = "Berry";
            break;

        case "Tomato":
            productType = "Vegetable";
            break;

        default:
            productType = "other";
            break;
    }
        
    return productType;
}

A switch utasítás konstrukciók halmaza, amelyek egymás után kerülnek végrehajtásra. Nem engedi visszaadni az értéket. A switch utasítás használatával a fő probléma az, hogy végtelen számú esetkifejezést adhat hozzá , és ezzel a képességgel a programozók gyakran visszaélnek.

A Java 12 egy kísérleti funkcióval bővült: a switch új verziójával – nem switch utasítással, hanem switch kifejezéssel –, amely értéket adhat, funkcionális programozást használhat belsőleg, és egyesítheti a közös értékkel rendelkező esetutasításokat, ezáltal kompakt konstrukció.

Java 12-ben a getProductTypeByName() metódus a következőképpen írható át :

public String getProductTypeByName(String product) {
    return switch (product) {
        case "Apple", "Peach" -> "Fruit";
        case "Raspberry", "Cherry" -> "Berry";
        case "Tomato" -> "Vegetable";
        default -> "other";

    };
}

Most a kód tisztábbnak tűnik. A funkcionális programozásból származó nyíl szintaxis lehetővé teszi, hogy a break kulcsszó nélkül adjunk vissza értékeket, és általában a váltás végrehajtásának eredménye elmenthető egy változóba, vagy visszaadható a return kulcsszóval.

Ha nem csak egy eredményt kell visszaadnunk, hanem több soros kóddal is rendelkeznünk kell, akkor a kapcsolónk így néz ki:

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            break "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            break "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            break "Vegetable";
        }
        default -> {
            break "other";
        }

    };
     return result;
}

A Java 13-ban a switch kifejezés még csak kísérleti funkció volt. Ahhoz, hogy elérhetővé váljon, csakúgy, mint a Java 12-ben, az --enable-preview parancsot kell használnia fordításkor és futtatásakor. A Java 13-ban a switch fő, és lényegében egyetlen "innovációja" a hozam kulcsszó, amely a break kifejezést váltotta fel .

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            yield "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            yield "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            yield "Vegetables";
        }
        default -> {
            System.out.println("Other");
            yield "other";
        }

    };
    return result;
}

A fő különbség a hozam és a break között az, hogy a break végrehajtási vezérlést ad vissza egy case utasításból, de a return a teljes switch eredményét adja vissza , belső return utasításként viselkedve.

A Java 14-ben az instanceof operátor megváltozott, és most így használható:

if (o instanceof String s) {
s.toLowerCase();
}

A kissé csúnya régi módszer helyett, ahol nemcsak ellenőrizni kellett a változót az instanceof segítségével , hanem egy adott típusra is át kellett adni.

if(s instanceof String) {
((String) s).toLowerCase();
}

Ezek a változtatások az Amber projekt részét képezik, amelynek célja a Java mintaillesztési támogatása.

A 14-es verzióban az instanceof operátor változásának és a 16-os verzió kiterjesztésének köszönhetően a mintaillesztés végül is bekerült a 17-es verzióba. Igaz, egyelőre csak előzetesként létezik. Kipróbálhatod az --enable-preview segítségével :

public String getObjectType(Object object) {
    return switch (object) {
        case Integer i -> "Integer";
        case Long l -> "Long";
        case String s -> "String";
        default -> object.toString();
    };
}

Általánosságban elmondható, hogy minden új verzió egyre több érdekességet visz be a nyelvbe, ami még menőbbé teszi a Java fejlesztést.