Java รองรับตัวดำเนินการกระโดดสามตัว
การใช้ตัวดำเนินการ
โอเปอเรเตอร์ใช้
นอกจากจะใช้ใน คำสั่ง switchและลูปแล้วการใช้ตัวดำเนินการ
บางครั้งการเริ่มต้นวนซ้ำครั้งถัดไปตั้งแต่เนิ่นๆ ก็มีประโยชน์ นั่นคือ คุณต้องดำเนินการวนซ้ำต่อไป แต่หยุดประมวลผลโค้ดที่เหลือในส่วนเนื้อหาของมันเพื่อการวนซ้ำนี้โดยเฉพาะ ที่จริงแล้ว นี่คือผู้ดำเนินการ
คำสั่งควบคุมสุดท้ายคือ
break
- continue
และreturn
. พวกเขาถ่ายโอนการควบคุมไปยังส่วนอื่นของโปรแกรมของคุณ ลองพิจารณาโอเปอเรเตอร์แต่ละรายโดยละเอียด การใช้ตัวดำเนินการbreak
โอเปอเรเตอร์break
ใน Java ถูกใช้ในสามกรณี ขั้นแรก อย่างที่คุณเห็นแล้ว มันจะสิ้นสุดลำดับของคำสั่งที่สาขาของคำswitch
สั่ง ประการที่สอง สามารถใช้เพื่อแยกออกจากวงได้ ประการที่สาม มันสามารถใช้เป็นรูปแบบ "อารยะ" ของตัวดำเนินการกระโดดแบบไม่มีgoto
เงื่อนไข ส่วนนี้จะอธิบายสองกรณีสุดท้าย ใช้break
เพื่อออกจากลูป โดยการใช้break
คุณสามารถบังคับให้ลูปยุติได้ทันที โดยข้ามนิพจน์เงื่อนไขและโค้ดที่เหลืออยู่ในเนื้อหาของลูป เมื่อพบคำสั่งbreak
ภายในลูป คำสั่งที่สองจะสิ้นสุดและการควบคุมโปรแกรมจะถูกถ่ายโอนไปยังคำสั่งที่ตามมา ตัวอย่างง่ายๆ:
// Использование 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("Цикл завершен.");
}
}
โปรแกรมนี้สร้างผลลัพธ์ต่อไปนี้:
i: 0
i: 1
i: 2
i: 3
Цикл завершен.
แม้ว่าลูปfor
ได้รับการออกแบบที่นี่เพื่อดำเนินการคำสั่งตั้งแต่ 0 ถึง 99 ครั้ง ตัวดำเนินbreak
การจะทำให้สิ้นสุดก่อนเวลาเมื่อ i อายุ 4 ตัวดำเนินการbreak
สามารถใช้กับลูปของ Java ใดก็ได้ รวมถึงการวนซ้ำแบบไม่มีที่สิ้นสุดโดยเจตนา ตัวอย่างเช่น ด้านล่างนี้คือโปรแกรมก่อนหน้าที่เขียนโค้ดโดยใช้ลูwhile
ป ผลลัพธ์ของโปรแกรมนี้เหมือนกับรุ่นก่อน
// Использование 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("Цикл завершен.");
}
}
เมื่อใช้ภายในชุดของลูปที่ซ้อนกัน คำสั่งbreak
จะออกจากลูปในสุดเท่านั้น ตัวอย่างเช่น:
// Использование 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("Цикл завершен.");
}
}
โปรแกรมนี้สร้างผลลัพธ์ต่อไปนี้:
Итерация 0: 0 1 2 3
Итерация 1: 0 1 2 3
Итерация 2: 0 1 2 3
Цикл завершен.
อย่างที่คุณเห็น คำสั่งbreak
ในวงในจะทำให้เฉพาะวงนั้นยุติลง วงนอกไม่ได้รับผลกระทบ ให้เราแสดงความคิดเห็นเพิ่มเติมสองเกี่ยวbreak
กับ ขั้นแรก หลายคำสั่งอาจปรากฏขึ้นในวงbreak
วน อย่างไรก็ตามระวังด้วย มีมากเกินไปมีแนวโน้มที่จะทำลายโค้ดของคุณ ประการที่สอง , break
ที่ยุติคำสั่ง - switch
มีผลกับคำสั่ง - เท่านั้นswitch
(และไม่ใช่ลูปที่รวมคำสั่งนั้นไว้) ความคิดเห็น: Break
ไม่ได้ได้รับการออกแบบให้เป็นวิธีการสิ้นสุดแบบวนซ้ำตามปกติ วัตถุประสงค์นี้ให้บริการโดยนิพจน์เงื่อนไขส่วนหัวของลูป break
ควรใช้ ตัวดำเนินการ เพื่อแยกลูปเมื่อมีสถานการณ์พิเศษเกิดขึ้นเท่านั้น
ใช้break
เป็นแบบฟอร์มgoto
นอกจากจะใช้ใน คำสั่ง switchและลูปแล้วbreak
ยังสามารถใช้เป็นรูปแบบ "อารยะ" ของไฟล์goto
. Java ไม่มีโอเปอเรเตอร์goto
เพราะมันดำเนินการสาขาในลักษณะที่กำหนดเองและไม่มีโครงสร้าง โค้ดที่ใช้ . อย่างเข้มข้นgoto
มักจะเข้าใจและบำรุงรักษาได้ยาก นอกจากนี้ยังแทนที่การปรับแต่งคอมไพเลอร์บางอย่างอีกด้วย อย่างไรก็ตาม มีหลายแห่งในโปรแกรมที่goto
โฟลว์การควบคุมเป็นโครงสร้างที่มีคุณค่าและถูกต้องตามกฎหมาย ตัวอย่างเช่นgoto
อาจมีประโยชน์เมื่อคุณแยกออกจากชุดลูปที่ซ้อนกันลึก เพื่อจัดการกับสถานการณ์ดังกล่าว Java กำหนดรูปแบบเพิ่มเติมของตัวดำเนินbreak
การ เมื่อใช้มันคุณสามารถออกจากโค้ดหนึ่งหรือหลายบล็อคได้ บล็อกเหล่านี้ไม่จำเป็นต้องเป็นส่วนหนึ่งของการวนซ้ำหรือคำswitch
สั่ง นี่อาจเป็นบล็อกใดก็ได้ ถัดไป คุณสามารถกำหนดได้อย่างชัดเจนว่าการดำเนินการจะดำเนินการต่อไปที่ใด เนื่องจากแบบฟอร์มนี้break
ใช้งานได้โดยมีเครื่องหมายและให้ประโยชน์ของgoto
โดยไม่ผ่านปัญหาต่างๆ คำbreak
สั่งที่มีป้ายกำกับมีรูปแบบทั่วไปดังต่อไปนี้: break label;
นี่label
คือชื่อของป้ายกำกับที่ระบุบล็อกของโค้ดบางส่วน เมื่อดำเนินการแบบฟอร์มนี้break
การควบคุมจะถูกโอนจากบล็อกที่มีชื่อของรหัส (ซึ่งมีป้ายกำกับระบุไว้ในคำสั่งbreak
) ไปยังคำสั่งที่อยู่ถัดจากบล็อกนั้น บล็อกโค้ดที่ทำเครื่องหมายจำเป็นต้องมีคำสั่งนี้break
แต่ไม่จำเป็นว่าการรวมนี้จะต้องโดยตรง (นั่นคือbreak
ไม่สามารถรวมไว้ในบล็อกโดยตรงที่มีป้ายกำกับของตัวเอง แต่ในบล็อกที่ซ้อนกันภายในนั้น อาจมีเครื่องหมายด้วย ). ซึ่งหมายความว่าคุณสามารถใช้ตัวดำเนินการที่ทำเครื่องหมายไว้break
เพื่อหนีจากชุดของบล็อกที่ซ้อนกันได้ แต่คุณไม่สามารถใช้break
บล็อกโค้ดที่ไม่มีนามสกุลbreak
. หากต้องการตั้งชื่อบล็อก ให้ติดป้ายกำกับไว้ที่จุดเริ่มต้นของบล็อก (ก่อนเครื่องหมายปีกกาเปิด) ป้ายกำกับคือตัวระบุ Java ที่ถูกต้องตามด้วยเครื่องหมายทวิภาค หลังจากติดป้ายกำกับบล็อกแล้ว ป้ายกำกับนั้นสามารถใช้เป็นอาร์กิวเมนต์ให้กับตัวดำเนินการbreak
ได้ สิ่งนี้จะทำให้การดำเนินการดำเนินต่อไปตั้งแต่จุดสิ้นสุดของบล็อกที่ทำเครื่องหมายไว้ ตัวอย่างเช่น โปรแกรมต่อไปนี้ประกอบด้วยบล็อกที่ซ้อนกันสามบล็อก โดยแต่ละบล็อกมีป้ายกำกับของตัวเอง ตัวดำเนินการbreak
เคลื่อนที่ไปข้างหน้าเลยจุดสิ้นสุดของบล็อกที่มีป้ายกำกับ โดยsecond
ข้ามตัวดำเนินการสอง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.");
}
}
}
การรันโปรแกรมนี้จะสร้างผลลัพธ์ต่อไปนี้:
Перед оператором break.
Данный оператор размещен после блока second.
หนึ่งในการใช้งานทั่วไปของโอเปอเรเตอร์ที่มีป้ายกำกับbreak
คือการหลีกเลี่ยงลูปที่ซ้อนกัน ตัวอย่างเช่น ในโปรแกรมต่อไปนี้ ลูปภายนอกจะถูกดำเนินการเพียงครั้งเดียว:
// Использование 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("Цикл завершен.");
}
}
โปรแกรมสร้างผลลัพธ์ต่อไปนี้:
Итерация 0: 0 1 2 3 4 5 6 7 8 9 Цикл завершен.
จะสังเกตได้ง่ายว่าเมื่อวงในถูกขัดจังหวะก่อนถึงจุดสิ้นสุดของวงนอก ทั้งสองวงจะสิ้นสุดลง โปรดทราบว่าคุณไม่สามารถbreak
-jump ไปยังเลเบลใดๆ ที่ไม่ได้กำหนดไว้สำหรับบล็อกที่ปิดล้อมได้ ตัวอย่างเช่น โปรแกรมต่อไปนี้ไม่ถูกต้อง และจะไม่คอมไพล์:
// Эта программа содержит ошибку.
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 + " ");
}
}
}
เนื่องจากการวนซ้ำที่ทำเครื่องหมายไว้ไม่มีคำสั่งbreak
จึงไม่สามารถถ่ายโอนการควบคุมไปยังบล็อกนี้ได้
การใช้ตัวดำเนินการcontinue
บางครั้งการเริ่มต้นวนซ้ำครั้งถัดไปตั้งแต่เนิ่นๆ ก็มีประโยชน์ นั่นคือ คุณต้องดำเนินการวนซ้ำต่อไป แต่หยุดประมวลผลโค้ดที่เหลือในส่วนเนื้อหาของมันเพื่อการวนซ้ำนี้โดยเฉพาะ ที่จริงแล้ว นี่คือgoto
การเปลี่ยนผ่านการดำเนินการของเนื้อหาถัดไปไปยังจุดสิ้นสุดของบล็อกลูป continue
การดำเนินการ นี้ดำเนินการโดยผู้ดำเนินการ ในลูปตัวดำเนินการwhile
และจะทำให้การควบคุมถูกถ่ายโอนโดยตรงไปยังนิพจน์เงื่อนไขที่ควบคุมลูป ในการวนซ้ำการควบคุมจะส่งผ่านไปยังส่วนที่วนซ้ำของคำสั่งก่อนจากนั้นจึงไปยังนิพจน์แบบมีเงื่อนไข สำหรับทั้งสามลูป โค้ดระดับกลางใดๆ จะถูกข้ามไป ตัวอย่างโปรแกรมที่ใช้พิมพ์ตัวเลขสองตัวในแต่ละบรรทัดมีดังต่อไปนี้: do while
continue
for
for
continue
// Демонстрирует 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("");
}
}
}
รหัสนี้ใช้การดำเนินการ%
(โมดูโล) เพื่อตรวจสอบว่ามีอะไรเป็นi
คู่หรือไม่ หากเป็นเช่นนั้น การวนซ้ำจะดำเนินต่อไปโดยไม่ต้องพิมพ์อักขระขึ้นบรรทัดใหม่ ผลลัพธ์ของโปรแกรม:
0 1
2 3
4 5
6 7
8 9
เช่นเดียวกับตัวดำเนินการbreak
, continue
คุณสามารถกำหนดป้ายกำกับที่ระบุว่าวงปิดใดที่จะดำเนินการต่อ ตัวอย่างโปรแกรมที่ใช้continue
พิมพ์ตารางสูตรคูณสามเหลี่ยมตั้งแต่ 0 ถึง 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();
}
}
คำสั่งcontinue
ในตัวอย่างนี้สิ้นสุดการวนซ้ำที่ประเมินj
และดำเนินการต่อด้วยการวนซ้ำครั้งถัดไปของการวนซ้ำที่ขับเคลื่อนi
โดย ผลลัพธ์จากโปรแกรมนี้:
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
มัน ไม่ค่อยมีประโยชน์มากcontinue
นัก เหตุผลประการหนึ่งก็คือ Java มีชุดคำสั่งวนซ้ำที่หลากหลายที่เหมาะกับแอปพลิเคชันส่วนใหญ่ อย่างไรก็ตาม สำหรับสถานการณ์พิเศษที่จำเป็นต้องยุติการวนซ้ำก่อนกำหนด คำสั่งcontinue
จะจัดเตรียมวิธีที่มีโครงสร้างเพื่อให้งานนี้สำเร็จ
ผู้ดำเนินการreturn
คำสั่งควบคุมสุดท้ายคือreturn
. ใช้เพื่อส่งคืนเมธอดอย่างชัดเจน กล่าวคือ ถ่ายโอนการควบคุมโปรแกรมกลับไปยังโปรแกรมที่เรียก ตัวดำเนินการreturn
จัดอยู่ในประเภทตัวดำเนินการเปลี่ยน แม้ว่าการอภิปรายทั้งหมดจะต้องรอจนกว่าจะมีการหารือถึงวิธีการต่างๆ แต่มีภาพรวมโดยย่อไว้ที่return
นี่ โอเปอเรเตอร์return
สามารถใช้ที่ใดก็ได้ในเมธอดเพื่อข้ามกลับไปยังโปรแกรมที่เรียกใช้เมธอด คำสั่งreturn
จะหยุดการดำเนินการตามวิธีการที่มีอยู่ทันที ตัวอย่างต่อไปนี้แสดงให้เห็นสิ่งนี้:
// Демонстрирует return.
public class Return {
public static void main(String[] args) {
boolean t = true;
System.out.println("Перед оператором return.");
if (t) {
return; // возврат в вызывающую программу
}
System.out.println("Этот оператор никогда не выполнится.");
}
}
สิ่งนี้return
จะส่งคืนไปยังระบบ Java ณ รันไทม์ เนื่องจากเป็นระบบที่เรียกใช้ไฟล์main()
. ผลลัพธ์จากโปรแกรมนี้:
Перед оператором return.
คุณอาจสังเกตเห็นว่าคำสั่งสุดท้ายprintln()
ไม่ได้ถูกดำเนินการ ณ เวลาดำเนินการreturn
การควบคุมจะถูกโอนกลับไปยังโปรแกรมที่เรียก หมายเหตุสุดท้ายประการหนึ่ง ในโปรแกรมก่อนหน้านี้if
จำเป็นต้องมีตัวดำเนินการ (t) หากไม่มีสิ่งนี้ คอมไพเลอร์ Java จะส่งข้อผิดพลาด "รหัสที่ไม่สามารถเข้าถึงได้" เนื่องจากจะรู้ว่าคำสั่งสุดท้ายprintln()
จะไม่ถูกดำเนินการ เพื่อป้องกันข้อผิดพลาดนี้ จึงมีการใช้ตัวดำเนินการ (t) if
ซึ่งจะหลอกคอมไพลเลอร์เพื่อการสาธิตนี้ ลิงก์ไปยังแหล่งที่มาดั้งเดิม: ตัวดำเนินการเปลี่ยนผ่าน
GO TO FULL VERSION