Tumalon Operator

Sinusuportahan ng Java ang tatlong jump operator - break, continueat return. Inilipat nila ang kontrol sa ibang bahagi ng iyong programa. Isaalang-alang natin ang bawat isa sa mga operator nang detalyado.

Gamit ang operatorbreak

Ang operator breaksa Java ay ginagamit sa tatlong kaso. Una, tulad ng nakita mo na, tinatapos nito ang pagkakasunud-sunod ng mga pahayag sa mga sangay ng pahayag switch. Pangalawa, maaari itong magamit upang lumabas sa isang loop. Pangatlo, maaari itong gamitin bilang isang "sibilisado" na anyo ng unconditional jump operator goto. Ipinapaliwanag ng seksyong ito ang huling dalawang kaso. Gamitin breakupang lumabas sa isang loop Sa pamamagitan ng paggamit ng break, maaari mong pilitin ang loop na wakasan kaagad, na lampasan ang conditional expression at anumang natitirang code sa loop body. Kapag ang isang pahayag breakay nakatagpo sa loob ng isang loop, ang pangalawa ay matatapos at ang kontrol ng programa ay ililipat sa pahayag na kasunod nito. Simpleng halimbawa:

// Использование break для выхода из цикла.
public class BreakLoop {

  public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
      if (i == 4) {
        break; // завершить цикл, если i = 4
      }
      System.out.println("i: " + i);
    }
    System.out.println("Цикл завершен.");
  }
}

Ang program na ito ay bumubuo ng sumusunod na output:

i: 0
i: 1
i: 2
i: 3
Цикл завершен.

Bagama't ang loop foray idinisenyo dito upang isakatuparan ang mga pahayag nito mula 0 hanggang 99 na beses, breakpinahihintulutan ng operator na tapusin ito nang maaga kapag ako ay 4. breakMaaaring gamitin ang operator sa alinman sa mga loop ng Java, kabilang ang mga sinadyang walang katapusan na mga loop. Halimbawa, nasa ibaba ang nakaraang program na naka-code gamit ang isang loop while. Ang output ng program na ito ay pareho sa hinalinhan nito.

// Использование break для выхода из while-цикла.
public class BreakLoop2 {

  public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
      if (i == 4) {
        break; // закончить цикл, если i = 4
      }
      System.out.println("i: " + i);
      i++;
    }
    System.out.println("Цикл завершен.");
  }
}

Kapag ginamit sa loob ng isang hanay ng mga nested na loop, breaklalabas lang ang statement sa pinakaloob na loop. Halimbawa:

// Использование break во вложенных циклах.
public class BreakLoop3 {

  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 10; j++) {
        if (j == 4) {
          break; // закончить цикл, если j = 4
        }
        System.out.print(j + " ");
      }
      System.out.println();
    }
    System.out.println("Цикл завершен.");
  }
}

Ang program na ito ay bumubuo ng sumusunod na output:

Итерация 0: 0 1 2 3
Итерация 1: 0 1 2 3
Итерация 2: 0 1 2 3
Цикл завершен.

Tulad ng nakikita mo, ang pahayag breaksa panloob na loop ay nagiging sanhi lamang ng loop na iyon upang wakasan. Ang panlabas na loop ay hindi apektado. Gumawa tayo ng dalawa pang komento tungkol sa break. Una, maaaring lumitaw ang maraming pahayag sa isang loop break. Gayunpaman, mag-ingat. Masyadong marami sa kanila ang may posibilidad na sirain ang iyong code. Pangalawa, ang break, na nagwawakas sa - operator switch, ay nakakaapekto lamang sa ibinigay na switch- operator (at hindi ang mga loop na kinabibilangan nito). Komento: Breakay hindi idinisenyo bilang isang normal na paraan ng pagwawakas ng loop. Ang layuning ito ay inihahatid ng conditional expression ng header ng loop. Ang operator breakay dapat lamang gamitin upang masira ang loop kapag lumitaw ang ilang mga espesyal na sitwasyon.

Gamitin breakbilang isang formgoto

Bilang karagdagan sa paggamit sa mga switch statement at loop, breakmaaari rin itong gamitin nang mag-isa bilang isang "sibilisado" na anyo ng goto. Ang Java ay hindi naglalaman ng operator gotodahil ginagawa nito ang sangay sa isang arbitrary at hindi nakaayos na paraan. gotoKaraniwang mahirap maunawaan at mapanatili ang code na gumagamit ng . masinsinang . Ino-override din nito ang ilang mga pag-optimize ng compiler. Gayunpaman, mayroong ilang mga lugar sa isang programa kung saan gotoang daloy ng kontrol ay isang mahalaga at lehitimong konstruksyon. Halimbawa, gotomaaari itong maging kapaki-pakinabang kapag lumalabas ka sa isang malalim na nested na hanay ng mga loop. Upang mahawakan ang mga ganitong sitwasyon, tinukoy ng Java ang pinahabang anyo ng operator break. Gamit ito, maaari kang lumabas sa isa o higit pang mga bloke ng code. Ang mga bloke na ito ay hindi kailangang maging bahagi ng isang loop o pahayag switch. Maaari itong maging anumang bloke. Susunod, matutukoy mo nang eksakto kung saan magpapatuloy ang pagpapatupad dahil breakgumagana ang form na ito kasama ang marka at nagbibigay ng mga benepisyo ng goto, na lampasan ang mga problema nito. Ang isang breakmay label na pahayag ay may sumusunod na pangkalahatang anyo: break label; Narito labelang pangalan ng isang label na tumutukoy sa ilang bloke ng code. Kapag ang form na ito breakay naisakatuparan, ang kontrol ay ililipat mula sa pinangalanang bloke ng code (na ang label ay tinukoy sa pahayag break) sa pahayag na sumusunod sa bloke na iyon. Ang isang minarkahang bloke ng code ay dapat isama ang pahayag na ito break, ngunit hindi kinakailangan na ang pagsasama na ito ay direktang (iyon ay, breakmaaari itong isama nang hindi direkta sa isang bloke na may sarili nitong label, ngunit sa isang bloke na naka-nest sa loob nito, posibleng may marka rin) . Nangangahulugan ito na maaari kang gumamit ng isang minarkahang operator breakupang makatakas mula sa isang hanay ng mga nested block. Ngunit hindi ka maaaring gumamit breakng isang bloke ng code na walang kasamang break. Upang pangalanan ang isang bloke, maglagay ng label sa simula ng bloke (bago ang pambungad na curly brace). Ang label ay anumang wastong Java identifier na sinusundan ng colon. Pagkatapos lagyan ng label ang isang bloke, maaaring gamitin ang label nito bilang argumento sa operator break. Ito ay magiging sanhi ng pagpapatupad upang magpatuloy mula sa dulo ng minarkahang bloke. Halimbawa, ang sumusunod na programa ay naglalaman ng tatlong nested block, bawat isa ay may sariling label. breakSumusulong ang operator , lampas sa dulo ng bloke na may markang label second, laktawan ang dalawang operator println().

// Использование break How цивorзованной формы goto.
public class Break {

  public static void main(String[] args) {
    boolean t = true;
    first:
    {
      second:
      {
        third:
        {
          System.out.println("Перед оператором break.");
          if (t) {
            break second; // выход из блока second
          }
          System.out.println("Данный оператор никогда не выполнится");
        }
        System.out.println("Данный оператор никогда не выполнится ");
      }
      System.out.println("Данный оператор размещен после блока second.");
    }
  }
}

Ang pagpapatakbo ng program na ito ay bumubuo ng sumusunod na output:

Перед оператором break.
Данный оператор размещен после блока second.

Isa sa mga pinakakaraniwang gamit ng may markang operator breakay ang pagtakas sa mga nested loop. Halimbawa, sa sumusunod na programa ang panlabas na loop ay isinasagawa nang isang beses lamang:

// Использование break для выхода из вложенных циклов.
public class BreakLoop4 {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 100; j++) {

        if (j == 10) {
          break outer; // выйти из обоих циклов
        }
        System.out.print(j + " ");
      }
      System.out.println("Эта строка никогда не будет выведена");
    }
    System.out.println("Цикл завершен.");
  }
}

Ang programa ay bumubuo ng sumusunod na output:

Итерация 0: 0 1 2 3 4 5 6 7 8 9 Цикл завершен.

Madaling makita na kapag ang panloob na loop ay nagambala bago ang dulo ng panlabas na isa, ang parehong mga loop ay nagtatapos. Tandaan na hindi ka makakagawa breakng -jump sa anumang label na hindi tinukoy para sa kalakip na bloke. Halimbawa, ang sumusunod na programa ay hindi wasto at hindi mag-compile:

// Эта программа содержит ошибку.
public class BreakErr {

  public static void main(String[] args) {
    one:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
    }
    for (int j = 0; j < 100; j++) {
      if (j == 10) {
        break one; //He верно!
      }
      System.out.print(j + " ");
    }
  }
}

Dahil ang isang loop na may marka ay walang kasamang pahayag break, hindi posibleng ilipat ang kontrol sa block na ito.

Gamit ang operatorcontinue

Minsan ito ay kapaki-pakinabang upang simulan ang susunod na pag-ulit ng isang loop nang maaga. Iyon ay, kailangan mong ipagpatuloy ang pagpapatupad ng loop, ngunit itigil ang pagproseso ng natitirang code sa katawan nito para sa partikular na pag-ulit. Sa katunayan, ito ay isang gotopaglipat sa susunod na mga operasyon ng katawan sa dulo ng loop block. Ang aksyon na ito ay ginagawa ng operator continue. Sa mga loop, ang whileat do whileoperator continueay nagdudulot ng kontrol na mailipat nang direkta sa conditional expression na kumokontrol sa loop. Sa isang loop, forang control ay pumasa muna sa umuulit na bahagi ng pahayag forat pagkatapos ay sa conditional expression. Para sa lahat ng tatlong mga loop, ang anumang intermediate code ay na-bypass. Ang isang halimbawang programa na gumagamit continueupang mag-print ng dalawang numero sa bawat linya ay ibinigay sa ibaba:

// Демонстрирует continue.
public class Continue {

  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      System.out.print(i + " ");
      if (i % 2 == 0) {
        continue;
      }
      System.out.println("");
    }
  }
}

Ang code na ito ay gumagamit ng operasyon %(modulo) upang suriin kung ang isang bagay ay ipantay. Kung gayon, magpapatuloy ang loop nang hindi nagpi-print ng character na bagong linya. Output ng programa:

0 1
2 3
4 5
6 7
8 9

Tulad ng , operator break, continuemaaari mong tukuyin ang isang label na nagsasaad kung aling kalakip na loop ang magpapatuloy. Isang halimbawang programa na gumagamit continueupang mag-print ng triangular multiplication table mula 0 hanggang 9.

// Использование continue с меткой.
public class ContinueLabel {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 10; i++) {
      for (int j = 0; j < 10; j++) {
        if (j > i) {
          System.out.println();
          continue outer;
        }
        System.out.print(" " + (i * j));
      }
    }
    System.out.println();
  }
}

Ang pahayag continuesa halimbawang ito ay nagtatapos sa loop na pagsusuri j, at nagpapatuloy sa susunod na pag-ulit ng loop na hinimok ng i. Output mula sa programang ito:

0
 0 1
 0 2 4
 0 3 6 9
 0 4 8 12 16
 0 5 10 15 20 25
 0 6 12 18 24 30 36
 0 7 14 21 28 35 42 49
 0 8 16 24 32 40 48 56 64
 0 9 18 27 36 45 54 63 72 81

Ito ay lubhang bihirang kapaki - pakinabang continue. Ang isang dahilan para dito ay ang Java ay nagbibigay ng isang rich set ng looping statement na angkop sa karamihan ng mga application. Gayunpaman, para sa mga espesyal na sitwasyon kung saan kinakailangan na wakasan ang pag-ulit nang maaga, ang pahayag continueay nagbibigay ng nakabalangkas na paraan upang magawa ang gawaing ito.

Operatorreturn

Ang huling control statement ay return. Ito ay ginagamit upang tahasang bumalik mula sa isang paraan, iyon ay, inililipat nito ang kontrol ng programa pabalik sa programa ng pagtawag. Ang operator returnay inuri bilang isang transition operator. Bagama't ang buong talakayan nito ay kailangang maghintay hanggang sa pag-usapan ang mga pamamaraan, isang maikling pangkalahatang-ideya ang ibinigay dito return. Ang operator returnay maaaring gamitin kahit saan sa isang paraan upang tumalon pabalik sa programa na tumatawag sa pamamaraan. Ang pahayag returnay agad na nagtatapos sa pagpapatupad ng pamamaraan kung saan ito naroroon. Ang sumusunod na halimbawa ay naglalarawan nito:

// Демонстрирует return.
public class Return {

  public static void main(String[] args) {
    boolean t = true;
    System.out.println("Перед оператором return.");
    if (t) {
      return; // возврат в вызывающую программу
    }
    System.out.println("Этот оператор никогда не выполнится.");
  }
}

Bumalik ito returnsa Java system sa runtime, dahil ito ang system na tumatawag sa main(). Output mula sa programang ito:

Перед оператором return.

Maaari mong mapansin na ang huling pahayag println()ay hindi naisakatuparan. Sa oras ng pagpapatupad, returnang kontrol ay ililipat pabalik sa programa sa pagtawag. Isang huling tala. Sa nakaraang programa, ifkailangan ang (t) operator. Kung wala ito, ang Java compiler ay magtapon ng isang "hindi maabot na code" na error dahil malalaman nito na ang huling pahayag println()ay hindi kailanman isasagawa. Upang maiwasan ang error na ito, ginagamit ang (t) operator if; nililinlang nito ang compiler para sa kapakanan ng demonstrasyon na ito. Link sa orihinal na pinagmulan: Transition operator