Tulad ng alam natin, ang Java language ay isang object-oriented programming language. Sa madaling salita, ang pangunahing konsepto, ibig sabihin, ang pundasyon ng pundasyon, ay ang lahat ay isang bagay. Ang mga bagay ay inilarawan gamit ang mga klase. Ang mga klase, sa turn, ay tumutukoy sa estado at pag-uugali. Halimbawa, ang isang bank account ay maaaring may estado sa anyo ng halaga ng pera sa account at may mga gawi na nagpapataas at nagpapababa sa balanse ng account. Sa Java, ang mga pag-uugali ay ipinatupad sa pamamagitan ng mga pamamaraan. Ang pag-aaral kung paano tukuyin ang mga pamamaraan ay darating sa pinakasimula ng iyong pag-aaral sa Java. Halimbawa, sa opisyal na tutorial ng Oracle, sa ilalim ng heading na " Defining Methods ". Mayroong dalawang mahalagang bagay na dapat tandaan dito:
Ang bawat pamamaraan ay may pirma. Ang lagda ay binubuo ng pangalan ng pamamaraan at mga parameter ng pag-input nito.
Dapat tukuyin ang isang uri ng pagbabalik para sa mga pamamaraan. Idineklara mo ang uri ng pagbabalik ng isang pamamaraan sa deklarasyon ng pamamaraan nito.
Ang uri ng pagbabalik ay hindi bahagi ng lagda ng pamamaraan. Muli, ito ay bunga ng katotohanan na ang Java ay isang malakas na na-type na wika at ang compiler ay gustong malaman kung anong mga uri ang ginagamit at kung saan, nang maaga at hangga't maaari. Muli, ito ay para iligtas tayo sa mga pagkakamali. Talaga, lahat ng ito ay para sa isang mabuting layunin. At para sa akin, muli nitong itinatanim sa atin ang kultura ng paghawak ng data. Kaya, ang uri ng halaga ng pagbabalik ay tinukoy para sa mga pamamaraan. At ang return keyword sa Java ay ginagamit upang aktwal na gawin ang pagbabalik.
Ano ang ginagawa ng pagbabalik sa Java
Ang return keyword ay isang control flow statement, gaya ng inilarawan sa Oracle tutorial dito . Maaari mo ring basahin ang tungkol sa kung paano ibalik ang mga halaga sa seksyong " Pagbabalik ng Halaga mula sa Paraan " ng opisyal na tutorial. Maingat na sinusubaybayan ng compiler kung masisiguro nitong tumutugma ang value ng return ng isang method sa tinukoy na uri ng return ng method. Gamitin natin ang Online IDE ng Tutorialspoint upang isaalang-alang ang isang halimbawa. Tingnan natin ang unang halimbawa:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Tulad ng nakikita natin, ang pangunahing pamamaraan ay isinasagawa dito, na siyang entry point ng programa. Ang mga linya ng code ay isinasagawa mula sa itaas hanggang sa ibaba. Ang aming pangunahing pamamaraan ay hindi makapagbabalik ng halaga. Kung susubukan naming ibalik ang isang halaga doon, makakakuha kami ng isang error: "Error: Ang pangunahing pamamaraan ay dapat magbalik ng isang halaga ng uri na walang bisa" . Alinsunod dito, ang pamamaraan ay naglalabas lamang sa screen. Ngayon, ilipat natin ang literal na string sa isang hiwalay na paraan para sa pagbuo ng mensahe:
public class HelloWorld {
public static void main(String[] args) {
System.out.println(getHelloMessage());
}
public static String getHelloMessage() {
return "Hello World";
}
}
Tulad ng nakikita natin, ginamit namin ang return keyword upang ipahiwatig ang return value, na pagkatapos ay ipinasa namin sa println method. Ang deklarasyon ng getHelloMessage method ay nagpapahiwatig na ang pamamaraan ay magbabalik ng isang String . Ito ay nagpapahintulot sa compiler na suriin kung ang mga aksyon ng pamamaraan ay naaayon sa kung paano ito idineklara. Naturally, ang uri ng pagbabalik na tinukoy sa isang deklarasyon ng pamamaraan ay maaaring mas malawak kaysa sa uri ng halaga na aktwal na ibinalik sa code, ibig sabihin, ang mahalagang bagay ay posible ang isang uri ng conversion. Kung hindi, makakakuha tayo ng error sa oras ng pag-compile: "Error: mga hindi tugmang uri" . Siyanga pala, malamang na may tanong ka: Bakit ang pagbabalikitinuturing na isang control flow statement? Dahil maaari itong makagambala sa normal na top-down na daloy ng isang programa. Halimbawa:
public class HelloWorld {
public static void main(String[] args) {
if (args.length == 0) {
return;
}
for (String arg : args) {
System.out.println(arg);
}
}
}
Tulad ng makikita mo mula sa halimbawa, ginagambala namin ang pangunahing pamamaraan sa Java program kung ito ay tinatawag na walang mga argumento. Mahalagang tandaan na kung mayroon kang code pagkatapos ng return statement, hindi ito maa-access. Mapapansin ito ng aming matalinong compiler at pipigilan ka sa pagpapatakbo ng naturang programa. Halimbawa, ang code na ito ay hindi nag-compile:
public static void main(String[] args) {
System.out.println("1");
return;
// we use output method after return statement, which is incorrect
System.out.println("2");
}
Mayroong isang maruming hack upang maalis ito. Halimbawa, para sa mga layunin ng pag-debug, o para sa ibang dahilan. Ang code sa itaas ay maaaring maayos sa pamamagitan ng pagbabalot ng return statement sa isang if block:
if (2==2) {
return;
}
Return statement sa panahon ng paghawak ng error
May iba pang nakakalito — maaari naming gamitin ang pagbabalik kasabay ng paghawak ng error. Gusto kong sabihin kaagad na ang paggamit ng return statement sa isang catch block ay napaka, napakasamang anyo, kaya dapat mong iwasan ito. Ngunit kailangan natin ng isang halimbawa, tama ba? Heto na:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Value: " + getIntValue());
}
public static int getIntValue() {
int value = 1;
try {
System.out.println("Something terrible happens");
throw new Exception();
} catch (Exception e) {
System.out.println("Cached value: " + value);
return value;
} finally {
value++;
System.out.println("New value: " + value);
}
}
}
Sa unang sulyap, tila dapat ibalik ang 2, dahil sa wakas ay palaging isinasagawa. Ngunit hindi, ang ibabalik na halaga ay magiging 1, at ang pagbabago sa variable sa panghuling bloke ay hindi papansinin. Bukod dito, ipagpalagay na ang halaga ay naglalaman ng isang bagay at sinasabi namin ang halaga = null sa panghuling bloke. Pagkatapos ang bagay na iyon, hindi null, ay ibabalik sa catch block. Ngunit ang isang pahayag sa pagbabalik ay gagana nang tama sa panghuling bloke. Malinaw, ang iyong mga katrabaho ay hindi magpapasalamat sa iyo para sa maliliit na sorpresa na kinasasangkutan ng mga pahayag sa pagbabalik.
walang bisa.klase
At sa wakas. Mayroong kakaibang construct na maaari mong isulat: void.class . Hmm. Bakit at ano ang ibig sabihin nito? Talagang mayroong iba't ibang mga balangkas at nakakalito na mga kaso na kinasasangkutan ng Java Reflection API kung saan maaari itong maging lubhang kapaki-pakinabang. Halimbawa, maaari mong suriin kung anong uri ang ibinabalik ng isang pamamaraan:
import java.lang.reflect.Method;
public class HelloWorld {
public void getVoidValue() {
}
public static void main(String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == void.class);
}
}
}
Maaari itong maging kapaki-pakinabang sa mga balangkas ng pagsubok kung saan kailangan mong palitan ang aktwal na code sa mga pamamaraan. Ngunit para magawa ito, kailangan mong maunawaan kung paano kumikilos ang isang pamamaraan (ibig sabihin, anong uri ang ibinabalik nito). Mayroon ding pangalawang paraan upang ipatupad ang pangunahing pamamaraan sa code sa itaas:
public static void main(String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == Void.TYPE);
}
}
GO TO FULL VERSION