வெளிப்பாடு மாறு

திரும்பத் திரும்பச் சொல்வது கற்றலின் தாய். ஜாவாவின் ஸ்விட்ச் கீவேர்டைப் பற்றி நாம் முன்பே பேசியிருந்தாலும் , இன்று அடிப்படைகளை மதிப்பாய்வு செய்து சில புதிய தகவல்களைப் பெறுவோம்.

ஜாவா இரண்டு வகையான சுவிட்ச் கட்டுமானங்களைக் கொண்டுள்ளது: சுவிட்ச் அறிக்கை மற்றும் சுவிட்ச் வெளிப்பாடு. ஸ்விட்ச் வெளிப்பாடு ஜாவா 14 இல் அதிகாரப்பூர்வமானது, பதிப்புகள் 12 மற்றும் 13 இல் இரண்டு அதிகாரப்பூர்வமற்ற "முன்னோட்டம்" வகைகளில் இருந்தது.

ஆனால் ஆரம்பத்திலிருந்தே ஆரம்பிக்கலாம். பதிப்பு 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;
}

சுவிட்ச் ஸ்டேட்மெண்ட் என்பது ஒன்றன் பின் ஒன்றாக செயல்படுத்தப்படும் கட்டுமானங்களின் தொகுப்பாகும். இது ஒரு மதிப்பை திரும்ப அனுமதிக்காது. ஸ்விட்ச் ஸ்டேட்மெண்ட்டைப் பயன்படுத்துவதில் உள்ள முக்கிய பிரச்சனை என்னவென்றால், எண்ணற்ற கேஸ் எக்ஸ்ப்ரெஷன்களை நீங்கள் சேர்க்கலாம், மேலும் இந்த திறன் பெரும்பாலும் புரோகிராமர்களால் தவறாகப் பயன்படுத்தப்படுகிறது.

ஜாவா 12 ஒரு சோதனை அம்சத்தைச் சேர்த்தது: சுவிட்சின் புதிய பதிப்பு - ஒரு சுவிட்ச் அறிக்கை அல்ல, ஆனால் ஒரு சுவிட்ச் வெளிப்பாடு - இது ஒரு மதிப்பை அளிக்கும், செயல்பாட்டு நிரலாக்கத்தை உள்நாட்டில் பயன்படுத்தலாம் மற்றும் பொதுவான மதிப்பைக் கொண்ட வழக்கு அறிக்கைகளை ஒன்றிணைக்கலாம். கச்சிதமான கட்டமைக்க.

ஜாவா 12 இல், நீங்கள் getProductTypeByName() முறையை பின்வருமாறு மீண்டும் எழுதலாம் :

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

    };
}

இப்போது குறியீடு சுத்தமாக தெரிகிறது. செயல்பாட்டு நிரலாக்கத்திலிருந்து வரும் அம்பு தொடரியல், பிரேக் கீவேர்டு இல்லாமல் மதிப்புகளைத் திரும்பப் பெற அனுமதிக்கிறது , பொதுவாக, சுவிட்சை இயக்குவதன் விளைவாக இப்போது மாறியில் சேமிக்கப்படும் அல்லது திரும்பும் முக்கிய வார்த்தை வழியாக திரும்பப் பெறலாம்.

ஒரு முடிவை மட்டும் வழங்குவது மட்டுமல்லாமல், பல குறியீட்டு வரிகளையும் வைத்திருக்க வேண்டும் என்றால், எங்கள் சுவிட்ச் இப்படி இருக்கும்:

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

ஜாவா 13 இல், சுவிட்ச் வெளிப்பாடு இன்னும் ஒரு சோதனை அம்சமாக இருந்தது. ஜாவா 12 இல் உள்ளதைப் போலவே, அதைக் கிடைக்கச் செய்ய, தொகுத்து இயக்கும் போது --enable-preview கட்டளையைப் பயன்படுத்த வேண்டும் . ஜாவா 13 இல் உள்ள சுவிட்சின் "புதுமை" முக்கிய, மற்றும் ஒரே ஒரு "புதுமை" விளைச்சல் திறவுச்சொல் ஆகும், இது இடைவேளையை மாற்றியது .

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

மகசூல் மற்றும் இடைவெளிக்கு இடையேயான முக்கிய வேறுபாடு என்னவென்றால், ஒரு வழக்கு அறிக்கையிலிருந்து இடைநிறுத்தம் செயல்படுத்தல் கட்டுப்பாட்டை வழங்குகிறது , ஆனால் மகசூல் முழு சுவிட்சின் முடிவையும் வழங்குகிறது , இது ஒரு உள் வருவாய் அறிக்கையாக செயல்படுகிறது .

ஜாவா 14 இல், ஆபரேட்டரின் நிகழ்வு மாறிவிட்டது, இப்போது இதைப் பயன்படுத்தலாம்:

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

சற்றே அசிங்கமான பழைய முறைக்கு பதிலாக, நீங்கள் instanceof ஐப் பயன்படுத்தி மாறியைச் சரிபார்ப்பது மட்டுமல்லாமல், அதை ஒரு குறிப்பிட்ட வகைக்கு அனுப்பவும் வேண்டும்.

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

இந்த மாற்றங்கள் ஆம்பர் திட்டத்தின் ஒரு பகுதியாகும், இது ஜாவாவிற்கு பேட்டர்ன் மேட்சிங் ஆதரவைச் சேர்ப்பதை நோக்கமாகக் கொண்டுள்ளது.

பதிப்பு 14 இல் ஆபரேட்டரின் நிகழ்வில் ஏற்பட்ட மாற்றத்திற்கும் , பதிப்பு 16 இல் நீட்டிக்கப்பட்டதற்கும் நன்றி, வடிவ பொருத்தம் அதை பதிப்பு 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();
    };
}

பொதுவாக, ஒவ்வொரு புதிய பதிப்பும் மேலும் மேலும் சுவாரஸ்யமான அம்சங்களை மொழியில் கொண்டு வருகிறது, இது ஜாவா வளர்ச்சியை இன்னும் குளிர்ச்சியாக்குகிறது.