Ang pag-uulit ay ang ina ng pag-aaral. Bagama't napag-usapan na natin ang tungkol sa switch ng Java kanina, susuriin natin ngayon ang mga pangunahing kaalaman at maghuhukay sa ilang bagong impormasyon.
Ang Java ay may dalawang uri ng switch construct: ang switch statement at ang switch expression. Naging opisyal ang switch expression sa Java 14, na umiral sa dalawang hindi opisyal na "preview" na variant sa bersyon 12 at 13.
Ngunit magsimula tayo sa simula. Alalahanin natin kung ano ang hitsura ng isang magandang lumang switch bago ang bersyon 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;
}
Ang switch statement ay isang set ng mga construct na isasagawa nang sunud-sunod. Hindi ka nito hinahayaang magbalik ng halaga. Ang pangunahing problema sa paggamit ng switch statement ay maaari kang magdagdag ng walang katapusang bilang ng mga case expression, at ang kakayahang ito ay madalas na inaabuso ng mga programmer.
Nakita ng Java 12 ang pagdaragdag ng isang pang-eksperimentong tampok: isang bagong bersyon ng switch — hindi isang switch statement, ngunit isang switch expression — na maaaring magbunga ng isang halaga, gumamit ng functional programming sa loob, at pagsamahin ang mga case statement na may isang karaniwang halaga, sa gayon ay ginagawa ang bumuo ng compact.
Sa Java 12, maaari mong muling isulat ang getProductTypeByName() na pamamaraan tulad ng sumusunod:
public String getProductTypeByName(String product) {
return switch (product) {
case "Apple", "Peach" -> "Fruit";
case "Raspberry", "Cherry" -> "Berry";
case "Tomato" -> "Vegetable";
default -> "other";
};
}Ngayon ang code ay mukhang mas malinis. Ang arrow syntax mula sa functional programming ay nagbibigay-daan sa amin na magbalik ng mga halaga nang walang break na keyword, at sa pangkalahatan, ang resulta ng pagsasagawa ng switch ay maaari na ngayong i-save sa isang variable o ibalik sa pamamagitan ng return keyword.
Kung kailangan nating hindi lamang magbalik ng resulta, ngunit mayroon ding maraming linya ng code, magiging ganito ang hitsura ng ating switch :
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;
}Sa Java 13, ang switch expression ay isang pang-eksperimentong tampok pa rin. Upang gawin itong available, tulad ng sa Java 12, kailangan mong gamitin ang --enable-preview command kapag nag-compile at tumatakbo. Ang pangunahing, at mahalagang lamang, "makabagong ideya" ng switch sa Java 13 ay ang yield keyword, na pumalit sa 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;
}Ang pangunahing pagkakaiba sa pagitan ng yield at break ay ang break ay nagbabalik ng execution control mula sa isang case statement, ngunit ibinabalik ng yield ang resulta ng buong switch , na kumikilos bilang isang internal return statement.
Sa Java 14, ang instanceof operator ay nagbago at maaari na ngayong gamitin tulad nito:
if (o instanceof String s) {
s.toLowerCase();
}Sa halip na medyo pangit na lumang paraan kung saan kailangan mong hindi lamang suriin ang variable gamit ang instanceof , ngunit i-cast din ito sa isang partikular na uri.
if(s instanceof String) {
((String) s).toLowerCase();
}Ang mga pagbabagong ito ay bahagi ng proyektong Amber, na naglalayong magdagdag ng suporta sa pagtutugma ng pattern sa Java.
Salamat sa pagbabago sa instanceof operator sa bersyon 14 at isang extension sa bersyon 16, ang pagtutugma ng pattern ay ginawa itong bersyon 17 pagkatapos ng lahat. Totoo, ito ay umiiral lamang bilang isang preview sa ngayon. Maaari mong subukan ito gamit ang --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();
};
}Sa pangkalahatan, ang bawat bagong bersyon ay nagdadala ng higit pa at mas kawili-wiling mga tampok sa wika, na ginagawang mas cool ang pag-unlad ng Java.