Pahayag ng Pagbabalik sa Java

Panimula

Tulad ng alam natin, ang Java ay isang object-oriented programming language. Iyon ay, ang pangunahing konsepto, dahil upang sabihin ang batayan ng mga batayan ay ang lahat ay isang bagay. Ang mga bagay ay inilarawan gamit ang mga klase. Ang mga klase naman ay may estado at pag-uugali. Halimbawa, ang isang bank account ay maaaring magkaroon ng estado sa anyo ng halaga ng pera sa account at may pag-uugali ng pagtaas at pagbaba ng balanse. Ang pag-uugali sa Java ay ipinatupad gamit ang mga pamamaraan. Paano ilarawan ang mga pamamaraan ay ipinakilala sa pinakadulo simula ng iyong paglalakbay sa pag-aaral ng Java. Halimbawa, sa opisyal na tutorial mula sa Oracle: " Defining Methods ". Mayroong dalawang mahalagang aspeto dito:

• Ang bawat pamamaraan ay may pirma. Ang lagda ay binubuo ng pangalan ng pamamaraan at mga parameter ng pag-input nito;
• Dapat tukuyin ng mga pamamaraan ang isang uri ng pagbabalik;
• 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 maunawaan nang maaga kung aling mga uri ang ginagamit kung saan hangga't maaari. Muli, para protektahan tayo sa mga pagkakamali. Sa pangkalahatan, ang lahat ay para sa ikabubuti. Well, ito ay muling nagtanim sa amin ng isang kultura ng paghawak ng data, tila sa akin. Kaya, para sa mga pamamaraan ang uri ng halaga ay tinukoy. At upang ibalik ang parehong halaga mula sa mga pamamaraan, ginagamit ang keyword return.

Pahayag ng pagbabalik ng keyword sa Java

Ang keyword ng pahayag returnay tumutukoy sa "mga control flow statement" gaya ng tinalakay sa oracle tutorial na " Control Flow Statements ". Maaari mo ring basahin ang tungkol sa kung paano ibalik ang mga halaga sa opisyal na tutorial: " Pagbabalik ng Halaga mula sa isang Paraan ". Maingat na sinusubaybayan ng compiler, sa abot ng makakaya nito, na ang halagang ibinalik mula sa isang pamamaraan ay tumutugma sa uri ng halaga ng pagbabalik na tinukoy ng pamamaraan. Gamitin natin ang Online IDE mula sa tutorialspoint bilang isang halimbawa . Tingnan natin ang orihinal na halimbawa:

public class HelloWorld {
    public static void main(String []args) {
        System.out.println("Hello World");
    }
}

Tulad ng nakikita natin, ang isang pamamaraan ay isinasagawa dito main, na siyang entry point sa programa. Ang mga linya ng code ay isinasagawa mula sa itaas hanggang sa ibaba. Hindi maibabalik ng aming mainpamamaraan ang mga halaga, kung hindi, makakatanggap kami ng error: " Error: Main method must return a value of type void". Samakatuwid, ang pamamaraan ay maglalabas lamang sa screen. Ilipat natin ngayon ang pagtanggap ng string sa isang hiwalay na paraan para sa pagtanggap ng mensahe:

public class HelloWorld {

    public static void main(String []args) {
        System.out.println(getHelloMessage());
    }

    public static String getHelloMessage() {
        return "Hello World";
    }

}

Gaya ng nakikita natin, gamit ang keyword returnna tinukoy namin ang return value, na ginamit namin sa ibang pagkakataon sa pamamaraan println. Sa paglalarawan (kahulugan) ng pamamaraan, getHelloMessageipinahiwatig namin na ibabalik nito sa amin String. Nagbibigay-daan ito sa compiler na suriin kung ang mga aksyon ng pamamaraan ay naaayon sa paraan ng pagdedeklara nito. Naturally, ang uri ng halaga ng pagbabalik na tinukoy sa kahulugan ng pamamaraan ay maaaring mas malawak kaysa sa uri ng halaga na ibinalik mula sa code, i.e. Ang pangunahing bagay ay ang mga uri ay nabawasan sa bawat isa. Kung hindi, makakakuha tayo ng error sa oras ng compilation: " error: incompatible types". Sa pamamagitan ng paraan, malamang na agad na lumitaw ang tanong: Bakit returnito nalalapat sa mga operator ng kontrol sa daloy ng programa? Ngunit dahil maaari itong makagambala sa normal na daloy ng programa mula sa itaas hanggang sa ibaba. 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 mula sa halimbawa, naaantala namin ang pagpapatupad ng pamamaraan mainkung ang aming java program ay tinatawag na walang mga parameter. Mahalagang tandaan na kung returnmayroon kang code, ito ay magiging hindi naa-access. At mapapansin ito ng aming matalinong compiler at hindi ka papayagan na magpatakbo ng naturang programa. Halimbawa, ang code na ito ay hindi mag-compile:

public static void main(String []args) {
        System.out.println("1");
        return;
        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 nito returnsa ifisang bloke:

if (2==2)  {
    return;
}

Ibalik ang pahayag sa paghawak ng error

May isang napakahirap na pangyayari - magagamit natin ito returnkasabay ng paghawak ng error. Gusto kong sabihin kaagad na ang paggamit nito returnsa catchisang bloke ay napaka, napakasamang anyo, kaya dapat mong iwasan ito. Ngunit kailangan natin ng isang halimbawa, tama ba? Narito siya:

public class HelloWorld  {

    public static void main(String []args) {
        System.out.println("Value is: " + getIntValue());
    }

    public static int getIntValue()  {
        int value = 1;
        try {
            System.out.println("Something terrible happens");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("Catched value: " + value);
            return value;
        } finally {
            value++;
            System.out.println("New value: " + value);
        }
    }

}

Sa unang tingin, parang dapat ibalik ang 2, dahil finallyito ay palaging pinaandar. Ngunit hindi, ang halaga ay magiging 1, at ang pagbabago sa variable sa finallyay hindi papansinin. Bukod dito, kung valuenaglalaman ito ng isang bagay at finallysinabi namin value = null, pagkatapos ay catchmagbabalik pa rin ito ng isang sanggunian sa bagay, hindi null. Ngunit mula sa block finallyang operator returnay gumana nang tama. Ang mga kasamahan ay malinaw na hindi magpapasalamat sa iyo para sa gayong regalo.

walang bisa.klase

At sa wakas. Maaari kang magsulat ng kakaibang konstruksyon tulad ng void.class. Mukhang, bakit at ano ang punto? Sa katunayan, sa iba't ibang mga balangkas at nakakalito na mga kaso kung saan ginagamit ang Java Reflection API , maaaring ito ay lubhang kailangan. 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 kinakailangang palitan ang tunay na code ng mga pamamaraan. Ngunit para magawa ito, kailangan mong maunawaan kung paano kumikilos ang pamamaraang ito (ibig sabihin, anong mga uri ang ibinabalik nito). Mayroong pangalawang paraan upang ipatupad ang pamamaraan mainmula sa code sa itaas:

public static void main (String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }

Ang isang medyo kawili-wiling talakayan ng pagkakaiba sa pagitan ng mga ito ay mababasa sa stackoverflow: Ano ang pagkakaiba sa pagitan ng java.lang.Void at void? #Viacheslav