6. Vezérlési szerkezetek

A vezérlési szerkezetek segítségével az egyes utasítások végrehajtási sorrendjét határozhatjuk meg.

6.1. A while és a do-while ciklusok

Elől tesztelő ciklus

A while ciklus utasításblokk végrehajtására használható, amíg a feltétel igaz. A while ciklus szintaxisa:

while (feltétel) {
    utasítások
}

A while ciklus először kiértékeli a feltételt, amely művelet egy boolean értéket ad vissza. Ha a kifejezés értéke igaz, a while ciklus végrehajtja while blokkjában szereplő utasításokat. A while ciklus addig értékeli ki a kifejezést és hajtja végre az utasításblokkot, amíg a kifejezés hamis értékű nem lesz.

A következő WhileDemo nevű példaprogram a while ciklust használja fel, amely megvizsgálja a sztring karaktereit, hozzáfűzi a sztring minden karakterét a sztring puffer végéhez, amíg ’g’ betűvel nem találkozik.

public class WhileDemo {
    public static void main(String[] args) {

        String copyFromMe = "Copy this string until you " +
                            "encounter the letter 'g'.";
        StringBuffer copyToMe = new StringBuffer();

        int i = 0;
        char c = copyFromMe.charAt(i);

        while (c != 'g') {
            copyToMe.append(c);
            c = copyFromMe.charAt(++i);
        }
        System.out.println(copyToMe);
    }
}

Az érték, amelyet az utolsó sor ír ki:

Copy this strin

Hátul tesztelő ciklus

A Java nyelv egy a while ciklushoz hasonló utasítást is biztosít — a do-while ciklust. A do-while szintaxisa:

do {
    utasítás(ok)
} while (feltétel);

Ahelyett, hogy a feltételt a ciklus végrehajtása előtt értékelné ki, a do-while ezt a ciklusmag lefutása után teszi meg. Így a do-while magjában szereplő utasítások minimum egyszer végrehajtódnak.

Itt látható az előző program do-while ciklussal megvalósítva, ami a DoWhileDemo nevet kapta:

public class DoWhileDemo {
    public static void main(String[] args) {

        String copyFromMe = "Copy this string until you " +
                            "encounter the letter 'g'.";
        StringBuffer copyToMe = new StringBuffer();

        int i = 0;
        char c = copyFromMe.charAt(i);

        do {
            copyToMe.append(c);
            c = copyFromMe.charAt(++i);
        } while (c != 'g');
        System.out.println(scopyToMe);
    }
}

Az érték, amelyet az utolsó sorban kiír:

Copy this strin

6.2. A for ciklus

A for utasítás jó módszer egy értéktartomány bejárására. A for utasításnak van egy hagyományos formája, és a Java 5.0-tól kezdődően egy továbbfejlesztett formája is, amit tömbökön és gyűjteményeken való egyszerű bejárásnál használhatunk. A for utasítás általános formája a következőképpen néz ki:

for (inicializálás; feltétel; növekmény) {
    utastás(ok)
}

Az inicializálás egy olyan kifejezés, amely kezdőértéket ad a ciklusnak – ez egyszer, a ciklus elején fut le. A feltétel kifejezés azt határozza meg, hogy meddig kell a ciklust ismételni. Amikor a kifejezés hamisként értékelődik ki, a ciklus nem folytatódik. Végezetül a növekmény egy olyan kifejezés, amely minden ismétlődés után végrehajtódik a ciklusban. Mindezen összetevők opcionálisak. Tulajdonképpen ahhoz, hogy egy végtelen ciklust írjunk, elhagyjuk mindhárom kifejezést:

for ( ; ; ) {
    ...
}

A for ciklusokat gyakran arra használjuk, hogy egy tömb elemein vagy egy karakterláncon végezzünk iterációt. Az alábbi példa, ForDemo, egy for utasítást használ arra, hogy végighaladjon egy tömb elemein és kiírja őket.

public class ForDemo {
    public static void main(String[] args) {
        int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };

        for (int i = 0; i < arrayOfInts.length; i++) {
            System.out.print(arrayOfInts[i] + " ");
        }
        System.out.println();
    }
}

A program futási eredménye:

32 87 3 589 12 1076 2000 8 622 127

Megjegyezzük, hogy egy lokális változó is deklarálható a for ciklus inicializáló kifejezésében. Ennek a változónak az érvényessége a deklarációjától a for utasítás által vezérelt blokk végéig terjed, tehát mind a lezáró és a növekmény kifejezéseiben is használhatók. Ha a for ciklust vezérlő változóra nincs szükség a cikluson kívül, a legjobb, ha a változót az értékadó kifejezésben deklaráljuk. Az i, j és k neveket gyakran a for ciklusok vezérlésére használjuk, ezeknek a for ciklus értékadó kifejezésén belül való deklarálása leszűkíti élettartamukat, és csökkenti a hibalehetőségeket.

Gyűjteményeken és tömbökön való bejárás a kibővített for ciklussal

Az 5.0-ban egy újfajta for utasítást hoztak létre kifejezetten gyűjteményekhez és tömbökhöz. Az utasítás általános alakja:

for (elemtípus elem : tároló) {
    utasítás(ok)
}

Itt egy kis kódrészlet, ami ugyanazt a feladatot végzi, mint az előző kódrészlet.

public class ForEachDemo {
    public static void main(String[] args) {
        int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
        for (int element : arrayOfInts) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

A kibővített for utasítás igazán akkor előnyös, amikor gyűjteményekre alkalmazzuk (osztályok, amik a Collection interfészt implementálják). Itt látható egy régi típusú for utasítás, ami iterátor segítségével egy gyűjteményen halad végig:

void cancelAll(Collection<TimerTask> c) {
    for (Iterator<TimerTask> i = c.iterator(); i.hasNext(); )
        i.next().cancel();
}

Most nem kell aggódnunk a különös <TimerTask> kódrészlet miatt. Később fogunk magyarázatot adni a részletekre. A lényeg az, hogy elkerülhetjük ezt a kibővített for ciklus használatával:

void cancelAll(Collection<TimerTask> c) {
    for (TimerTask t : c)
        t.cancel();
}

Amikor iterációkat ágyazunk egybe, a kibővített for utasítás még jobb, mivel fölösleges kódrészeket kerülhetünk el. Például:

for (Suit suit : suits) {
    for (Rank rank : ranks)
        sortedDeck.add(new Card(suit, rank));
}

A kibővített for utasítás sajnos nem működik mindenhol. Hogyha pl. tömbindexekhez akarunk hozzáférni, a kibővített for nem fog működni. Amikor csak lehet, a továbbfejlesztett for-t használjuk, több programhibát is kiküszöbölhetünk, és a forráskódunk rendezettebb lesz.

6.3. Az if-else szerkezet

Az if utasítás lehetővé teszi a programunk számára, hogy valamilyen kritérium szerint kiválasztva futtasson más utasításokat. Például tegyük fel azt, hogy a programunk hibakereső (debugging) információkat ír ki egy DEBUG nevű, boolean típusú változó értéke alapján. Ha a DEBUG igaz, a program kiírja az információt, az x változó értékét. Különben a program futása normálisan folytatódik. Egy ilyen feladatot implementáló programrész a következőképpen nézhet ki:

if (DEBUG) {
    System.out.println("DEBUG: x = " + x);
}

Ez az if utasítás legegyszerűbb formája. Az if által vezérelt blokk végrehajtódik, ha a feltétel igaz. Általában az if egyszerű alakja így néz ki:

if (feltétel) {
    kifejezések
}

Mi van akkor, ha az utasítások más változatát akarjuk futtatni, ha a feltétel kifejezés hamis? Erre az else utasítást használhatjuk. Vegyünk egy másik példát. Tegyük fel azt, hogy a programunknak különböző műveleteket kell végrehajtania attól függően, hogy a felhasználó az OK gombot vagy más gombot nyom meg a figyelmeztető ablakban. A programunk képes lehet erre, ha egy if utasítást egy else utasítással együtt használunk.

if (response == OK) {
    //code to perform OK action
} else {
    //code to perform Cancel action
}

Az else blokk akkor kerül végrehajtásra, ha az if feltétele hamis. Az else utasítás egy másik formája az else if egy másik feltételen alapulva futtat egy utasítást. Egy if utasításnak lehet akárhány else if ága, de else csak egy. Az alábbi IfElseDemo program egy teszt pontszámot alapul véve egy osztályzatot határoz meg: 5-ös 90%-ért vagy afölött, 4-es 80%-ért vagy afölött és így tovább:

public class IfElseDemo {
    public static void main(String[] args) {
        int testscore = 76;
        int grade;
        if (testscore >= 90) {
            grade = 5;
        } else if (testscore >= 80) {
            grade = 4;
        } else if (testscore >= 70) {
            grade = 3;
        } else if (testscore >= 60) {
            grade = 2;
        } else {
            grade = 1;
        }
        System.out.println("Grade = " + grade);
    }
}

Ennek a programnak a kimenete:

Grade = 3

Megfigyelhetjük, hogy a testscore értéke több kifejezés feltételének is eleget tehet az alábbi if utasítások közül: 76 >= 70 és 76 >= 60. Azonban, ahogy a végrehajtó rendszer feldolgoz egy olyan összetett if utasítást, mint ez, amint egy feltétel kielégül, lefutnak a megfelelő utasítások (grade = 3), és a vezérlés kikerül az if utasításból anélkül, hogy a további feltételeket kiértékelné.

A Java programozási nyelv támogat egy háromoperandusú operátort, ami egyszerű esetekben az if utasítás helyett alkalmazható. Az operátor általános alakja:

logikai kifejezés ? kifejezés-ha-igaz : utasítás-ha-hamis

Idézzük fel ezt az utasítást a MaxVariablesDemo programból:

if (Character.isUpperCase(aChar)) {
    System.out.println("The character " + aChar
                       + " is upper case.");
} else {
    System.out.println("The character " + aChar
                       + " is lower case.");
}

Itt látható, hogyan használhatjuk ezt az operátort:

System.out.println("The character " + aChar + " is " +
    (Character.isUpperCase(aChar) ? "upper" : "lower")
     + "case.");

A ?: operátor kiértékelésének eredménye az upper karaktersorozat lesz, ha az isUpperCase metódus igaz értéket ad vissza, egyébként pedig a lower karaktersorozat. Az eredmény össze lesz fűzve a megjeleníteni kívánt üzenet más részeivel. Ha megszokjuk ezt a szerkezetet, bizonyos esetekben könnyebben olvashatóbbá és tömörebbé teheti a kódunkat.

Megjegyzés: Érdemes megfigyelni, hogy miért is lehetett itt az if-else szerkezetet kiváltani a háromoperandusú operátorral: az if és else ágon is ugyanazt akartuk tenni egy bizonyos kifejezéssel: ki akartuk írni. Ha ez a közös felhasználás nem áll fenn, akkor maradnunk kell az if-else utasításnál.

Megjegyzés: Általában nem feltétlenül szükséges, mégis sok alkalommal zárójelezzük az egyes operandusokat, és időmként az egész operátor-kifejezést is. (Az előző példa az egész kifejezést zárójeleni.)

6.4. A switch-case szerkezet

Akkor használhatjuk a switch utasítást, ha egy egész szám értéke alapján akarunk végrehajtani utasításokat. A következő SwitchDemo példaprogram egy month nevű egész típusú változót deklarál, melynek értéke vélhetőleg a hónapot reprezentálja egy dátumban. A program a switch utasítás használatával a hónap nevét jeleníti meg a month értéke alapján.

public class SwitchDemo {
    public static void main(String[] args) {
        int month = 8;
        switch (month) {
            case 1:  System.out.println("January"); break;
            case 2:  System.out.println("February"); break;
            case 3:  System.out.println("March"); break;
            case 4:  System.out.println("April"); break;
            case 5:  System.out.println("May"); break;
            case 6:  System.out.println("June"); break;
            case 7:  System.out.println("July"); break;
            case 8:  System.out.println("August"); break;
            case 9:  System.out.println("September"); break;
            case 10: System.out.println("October"); break;
            case 11: System.out.println("November"); break;
            case 12: System.out.println("December"); break;
            default: System.out.println("Not a month!");
                    break;
        }
    }
}

A switch utasítás kiértékeli kifejezést, ez esetben a month értékét, és lefuttatja a megfelelő case utasítást. Ezáltal a program futási eredménye az August lesz. Természetesen ezt az if utasítás felhasználásával is megoldhatjuk:

int month = 8;
if (month == 1) {
    System.out.println("January");
} else if (month == 2) {
    System.out.println("February");
}
...

Annak eldöntése, hogy az if vagy a switch utasítást használjuk, programozói stílus kérdése. Megbízhatósági és más tényezők figyelembevételével eldönthetjük, melyiket használjuk. Míg egy if utasítást használhatunk arra, hogy egy értékkészlet vagy egy feltétel alapján hozzunk döntéseket, addig a switch utasítás egy egész szám értéke alapján hoz döntést. Másrészt minden case értéknek egyedinek kell lennie, és a vizsgált értékek csak konstansok lehetnek.

Egy másik érdekesség a switch utasításban a minden case utáni break utasítás. Minden egyes break utasítás megszakítja az épp bezáródó switch utasítást, és a vezérlés szála a switch blokk utáni első utasításhoz kerül. A break utasítások szükségesek, mivel nélkülük a case utasítások értelmüket vesztenék. Vagyis egy explicit break nélkül a vezérlés folytatólagosan a rákövetkező case utasításra kerül (átcsorog). Az alábbi SwitchDemo2 példa azt illusztrálja, hogyan lehet hasznos, ha a case utasítások egymás után lefutnak.

public class SwitchDemo2 {
    public static void main(String[] args) {
        int month = 2;
        int year = 2000;
        int numDays = 0;
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                numDays = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                numDays = 30;
                break;
            case 2:
                if ( ((year % 4 == 0) && !(year % 100 == 0))
                     || (year % 400 == 0) )
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                numDays = 0;
                   break;
        }
        System.out.println("Number of Days = " + numDays);
    }
}

A program kimenete:

Number of Days = 29

Technikailag az utolsó break nem szükséges, mivel a vezérlés amúgy is befejeződne, kilépve a switch utasításból. Azonban javasolt ekkor is a break használata, mivel így a kód könnyebben módosítható és kevésbé hajlamos a hibára. Később még látni fogjuk a ciklusok megszakítására használt break-et.
Végül a switch utasításban használhatjuk a default utasítást, hogy mindazokat az értékeket is kezelhessük, amelyek nem voltak egy case utasításban sem kezelve.

Megjegyzés: A default utasításnak nem kell feltétlenül az utolsónak lenni, bár így a leglogikusabb és így is szokás általában elhelyezni. Ugyanígy a case ágak sorrendjének is csak akkor lehet jelentősége, ha van olyan ág, amelyiket nem zártunk le breakkel.

6.4.1 A switch utasítás és a felsorolt típus

A felsorolt adattípus az 5.0-ban bevezetett újdonság, amiről később olvashat majd. Ez a rész csak azt mutatja be, hogyan használhatjuk őket egy switch utasításban. Szerencsére ez pont olyan, mint a switch használata az egész típusú változók esetén.

Az alábbi SwitchEnumDemo kódja majdnem megegyezik azzal a kóddal, amit korábban a SwitchDemo2-ben láttunk. Ez az egész típusokat felsorolt típusokkal helyettesíti, de egyébként a switch utasítás ugyanaz.

public class SwitchEnumDemo {
    public enum Month { JANUARY, FEBRUARY, MARCH, APRIL,
                        MAY, JUNE, JULY, AUGUST, SEPTEMBER,
                        OCTOBER, NOVEMBER, DECEMBER }
    public static void main(String[] args) {
        Month month = Month.FEBRUARY;
        int year = 2000;
        int numDays = 0;
        switch (month) {
            case JANUARY:
            case MARCH:
            case MAY:
            case JULY:
            case AUGUST:
            case OCTOBER:
            case DECEMBER:
                numDays = 31;
                break;
            case APRIL:
            case JUNE:
            case SEPTEMBER:
            case NOVEMBER:
                numDays = 30;
                break;
            case FEBRUARY:
                if ( ((year % 4 == 0) && !(year % 100 == 0))
                     || (year % 400 == 0) )
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                numDays=0;
                break;
        }
        System.out.println("Number of Days = " + numDays);
    }
}

Ez a példa csak egy kis részét mutatta be annak, amire a Java nyelvi felsorolások képesek. A továbbiakat később olvashatja el.

6.5. Vezérlésátadó utasítások

Kivételkezelő utasítások

A Java programozási nyelv egy kivételkezelésnek nevezett szolgáltatást nyújt, hogy segítse a programoknak a hibák felderítését és kezelését. Amikor egy hiba történik, a program „dob egy kivételt”. Ez azt jelenti, hogy a program normális végrehajtása megszakad, és megkísérel találni egy kivételkezelőt, vagyis egy olyan kódblokkot, ami a különféle típusú hibákat le tudja kezelni. A kivételkezelő blokk megkísérelheti a hiba kijavítását, vagy ha úgy tűnik, hogy a hiba visszaállíthatatlan, akkor szabályosan kilép a programból.

Alapvetően három utasítás játszik szerepet a kivételkezelésekben:

  • a try utasítás tartalmaz egy utasítás blokkot, amiben a kivétel dobása elképzelhető
  • a catch utasítás tartalmaz egy olyan utasításblokkot, ami le tudja kezelni az azonos típusú kivételeket. Az utasítások akkor hajtódnak végre, ha kivételtípus típusú kivétel váltódik ki a try blokkban
  • a finally egy olyan utasítás blokkot tartalmaz, ami végrehajtódik akkor is, ha a try blokkban hiba történt, és akkor is, ha hiba nélkül futott le a kód.

Az utasítások általános alakja:

try {
    utasítás(ok)
} catch (kivételtípus kivételobjektum) {
    utasítás(ok)
} finally {
    utasítás(ok)
}

A kivételkezelés módszerének részletes ismertetésére később kerül sor.

Feltétel nélküli vezérlésátadás

A Java programnyelv háromféle feltétel nélküli vezérlésátadást támogat:

  • a break utasítást
  • a continue utasítást
  • a return (visszatérés) utasítást

A break és a continue utasításokat használhatjuk címkével vagy anélkül. A címke egy azonosító, ami az utasítás előtt helyezkedik el. A címkét egy kettőspont (:) követi. A következő programrészletben láthatunk egy példát a címke alkalmazására:

statementName: someJavaStatement;

A break utasítás

A break utasításnak két alakja van: címke nélküli és címkés. A címke nélküli break utasítást korábban a switch-nél már használtuk. Ahol a címke nélküli break utasítással fejeztük be a sort, ott befejezi a switch utasítást, és átadja a vezérlést a switch után következő utasításnak. A címke nélküli break utasítás használható még a for, while vagy do-while ciklusokból való kilépésre is. A BreakDemo példaprogram tartalmaz egy for ciklust, ami egy bizonyos értéket keres egy tömbön belül:

public class BreakDemo {
    public static void main(String[] args) {
        int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
        int searchfor = 12;
        int i = 0;
        boolean foundIt = false;
        for ( ; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break;
            }
        }
        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i + '.');
        } else {
            System.out.println(searchfor + "not in the array");
        }
    }
}

A break utasítás befejezi a for ciklust, ha megvan az érték. A vezérlés átadódik a for lezárása után lévő utasításnak, ami a print utasítást tartalmazó if a program végén.

A program kimenete:

Found 12 at index 4.

Megjegyzés: A for ciklusból break-kel való kilépést sokszor használjuk egy adott érték keresése érdekében. Érdemes megfigyelni, hogy ekkor a ciklus után meg kell állapítani (if utasítás), hogy miért is fejeződött be a ciklus: a találat miatt, vagy mert a végére értünk.

A break utasítás címke nélküli alakját használhatjuk a legbelső switch, for, while vagy do-while befejezésére. A címkézett alak befejez egy olyan külső utasítást, ami a break címkéje által van azonosítva. Másként fogalmazva: egyszerre több utasításból is képes kiugrani. A következő (BreakWithLabelDemo) program hasonló az előzőhöz, de itt kétdimenziós tömbben keressük az értéket. Kettő egymásba ágyazott for ciklus vizsgálja át a tömböt. Amikor az érték megvan, egy címkézett break befejezi a search-ként címkézett utasítást, ami a külső for ciklus:

public class BreakWithLabelDemo {
    public static void main(String[] args) {
        int[][] arrayOfInts = { { 32, 87, 3, 589 },
                                { 12, 1076, 2000, 8 },
                                { 622, 127, 77, 955 }
                              };
        int searchfor = 12;
        int i = 0;
        int j = 0;
        boolean foundIt = false;
    search:
        for ( ; i < arrayOfInts.length; i++) {
            for (j = 0; j < arrayOfInts[i].length; j++) {
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search;
                }
            }
        }
        if (foundIt) {
            System.out.println("Found " + searchfor + " at " + i + ", " + j + '.');
        } else {
            System.out.println(searchfor + "not in the array.");
        }
    }
}

A program kimenete:

Found 12 at 1, 0.

Ez a szintaxis egy kicsit zavaró lehet. A break utasítás befejezi a címkézett utasítást, és nem a címkének adja át a vezérlést. A vezérlés annak az utasításnak adódik át, ami közvetlen a (befejezett) címkézett utasítás után van.

A continue utasítás

A continue utasítás arra használható, hogy átugorjuk a ciklusmag hátralevő részét egy for, while vagy do-while ciklusnak. A címke nélküli alakja átugrik a legbelső ciklusmag végére és kiértékeli a logikai kifejezés értékét, ami a ciklust vezérli. A következő ContinueDemo program végigfut egy StringBuffer-en, megvizsgálva az összes betűt. Ha a vizsgált karakter nem ’p’, a continue utasítás átugorja a ciklus hátralevő részét és vizsgálja a következő karaktert. Ha ez egy ’p’, a program megnöveli a számláló értékét és átalakítja a ’p’-t nagybetűssé.

public class ContinueDemo {
    public static void main(String[] args) {
        StringBuffer searchMe = new StringBuffer(
            "peter piper picked a peck of pickled peppers");
        int max = searchMe.length();
        int numPs = 0;
        for (int i = 0; i < max; i++) {
            //interested only in p's
            if (searchMe.charAt(i) != 'p')
                continue;
            //process p's
            numPs++;
            searchMe.setCharAt(i, 'P');
        }
        System.out.println("Found " + numPs + " p's in the string.");
        System.out.println(searchMe);
    }
}

Ennek a programnak a kimenete:

Found 9 p's in the string.
Peter PiPer Picked a Peck of Pickled PePPers

A continue utasítás címkés alakja átugorja a címkézett ciklus ciklusmagjának hátralevő részét. A következő ContinueWithLabelDemo példaprogram egymásba ágyazott ciklusokat használ egy szövegrész keresésére egy másik szövegben. Két egymásba ágyazott ciklus szükséges: egy, hogy ismételje a szövegrészt, és egy, hogy addig ismételje, amíg át nem vizsgálta a szöveget. Ez a program a continue címkézett alakját használja, hogy átugorjon egy ismétlést a külső ciklusban:

public class ContinueWithLabelDemo {
    public static void main(String[] args) {
        String searchMe = "Look for a substring in me";
        String substring = "sub";
        boolean foundIt = false;
        int max = searchMe.length() - substring.length();
    test:
        for (int i = 0; i <= max; i++) {
            int n = substring.length();
            int j = i;
            int k = 0;
            while (n-- != 0) {
                if (searchMe.charAt(j++)
                        != substring.charAt(k++)) {
                    continue test;
                }
            }
            foundIt = true;
                    break test;
        }
        System.out.println(foundIt ? "Found it" : "Didn't find it");
    }
}

Ennek a programnak a kimenete:

Found it

Megjegyezés: Ahogy a korábbi példából is láthatjuk, a címke nélküli continue mindig kiváltható a ciklus átszervezésével, ilyen esetben ritkán is alkalmazzuk.

A return (visszatérés) utasítás

Ez az utasítás az utolsó a feltétlen vezérlésátadó utasítások közül. A return-t az aktuális metódusból vagy konstruktorból való kilépésre használjuk. A vezérlés visszaadódik annak az utasításnak, ami az eredeti hívást követi. A return utasításnak két formája van: ami visszaad értéket, és ami nem. Hogy visszatérjen egy érték, egyszerűen tegyük az értéket (vagy egy kifejezést, ami kiszámítja azt) a return kulcsszó után:

return ++count;

A visszaadott érték adattípusa meg kell, hogy egyezzen a függvényben deklarált visszatérési érték típusával. Ha a függvényt void-nak deklaráltuk, használjuk a return azon alakját, ami nem ad vissza értéket:

return;

6.6. Ellenőrző kérdések

  • Mi az if utasítás?
  • Mit jelent, ha az if utasításnak else ága van?
  • Mi a while utasítás?
  • Mi a ciklusmag?
  • Mit jelent, hogy a while elöltesztelő ciklus?
  • Hogyan lehet hátultesztelő while ciklust írni?
  • Mi a for ciklus?
  • Elől-, vagy hátultesztelő a for ciklus?
  • Mit jelent az egymásba ágyazott ciklus?
  • Mit nevezünk címkének, hogyan címkézhetünk utasításokat?
  • Ismertesse a többszörös elágazás készítésére alkalmas utasítást!
  • Ismertesse a break utasítás használatát!
  • Mire használhatjuk a continue utasítást?

Lefordul-e hiba nélkül a következő kódrészlet? Ha nem, indokolja!

int i=0;
if(i) {
    System.out.println("Hello");
}

Lefordul-e hiba nélkül a következő kódrészlet? Ha nem, indokolja!

boolean b=true;
boolean b2=true;
if(b==b2) {
    System.out.println("So true");
}

Lefordul-e hiba nélkül a következő kódrészlet? Ha nem, indokolja!

int i=1;
int j=2;
if(i==1 || j==2)
    System.out.println("OK");

<44>Lefordul-e hiba nélkül a következő kódrészlet? Ha nem, indokolja!

int i=1;
int j=2;
if(i==1 &| j==2)
    System.out.println("OK");