превключване на израза

Повторението е майката на ученето. Въпреки че вече говорихме за ключовата дума switch на Java по-рано, днес ще прегледаме основите и ще се заровим в нова информация.

Java има два типа конструкции за превключване : инструкция за превключване и израз за превключване. Изразът за превключване стана официален в Java 14, като съществуваше в два неофициални варианта „предварителен преглед“ във версии 12 и 13.

Но да започнем отначало. Нека си припомним How изглеждаше един добър стар суич преди version 12:

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

Инструкцията switch е набор от конструкции, които ще бъдат изпълнени една след друга. Не ви позволява да върнете стойност. Основният проблем при използването на команда switch е, че можете да добавите безкраен брой case изрази и тази възможност често се злоупотребява от програмистите.

В Java 12 беше добавена експериментална функция: нова version на switch — не оператор switch, а израз switch — който може да даде стойност, да използва функционално програмиране вътрешно и да обедини оператори case, които имат обща стойност, като по този начин прави конструирайте компактно.

В Java 12 можете да пренапишете метода getProductTypeByName() , Howто следва:

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

    };
}

Сега codeът изглежда по-чист. Синтаксисът на стрелката от функционалното програмиране ни позволява да връщаме стойности без ключовата дума break и като цяло резултатът от изпълнението на switch вече може да бъде записан в променлива or върнат чрез ключовата дума return .

Ако трябва не само да върнем резултат, но и да имаме няколко реда code, тогава нашият ключ ще изглежда така:

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

В Java 13 изразът за превключване все още беше експериментална функция. За да го направите достъпен, точно Howто в Java 12, трябва да използвате командата --enable-preview при компorране и изпълнение. Основната и по същество единствена „иновация“ на switch в Java 13 е ключовата дума yield , която замени break .

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

Основната разлика между yield и break е, че break връща контрола за изпълнение от оператор case , но yield връща резултата от целия switch , действайки като вътрешен оператор за връщане .

В Java 14 операторът instanceof е променен и вече може да се използва по следния начин:

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

Вместо донякъде грозния стар начин, при който трябваше не само да проверявате променливата с помощта на instanceof , но също така да я прехвърляте към определен тип.

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

Тези промени са част от проекта Amber, който има за цел да добави поддръжка за съвпадение на шаблони към Java.

Благодарение на промяната в оператора instanceof във version 14 и разширението във version 16, съпоставянето на шаблони все пак стигна до version 17. Вярно, засега съществува само като предварителен преглед. Можете да го изпробвате с --enable-preview :

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

Като цяло, всяка нова version носи все повече и повече интересни функции в езика, което прави разработката на Java още по-готина.