คำสั่งแบ่ง Java:คำแนะนำวิธีใช้

คำสั่ง Java break หยุดการทำงานของลูป เมื่อรันคำสั่ง break โปรแกรมจะเริ่มรันโค้ดหลังคำสั่ง หากใช้คำสั่ง break ในลูปที่ซ้อนกัน จะสิ้นสุดเฉพาะลูปในสุดเท่านั้น

Java สำหรับ วนซ้ำและ ในขณะที่ ลูปถูกใช้เพื่อทำงานที่คล้ายคลึงกันโดยอัตโนมัติ เมื่อคุณทำงานกับลูปเหล่านี้ คุณอาจต้องการออกจากลูปเมื่อตรงตามเงื่อนไขเฉพาะ นั่นคือสิ่งที่ Java แตก คำสั่งเข้ามา ตัวแบ่ง คำสั่งใช้เพื่อหยุดการวนซ้ำอย่างสมบูรณ์

บทแนะนำนี้จะกล่าวถึงการใช้ ตัวแบ่ง คำสั่งเพื่อควบคุมการไหลของลูปของคุณใน Java เราจะพูดถึงตัวอย่างคำสั่ง break ในโปรแกรม Java

คำสั่งแบ่ง Java

Java แตก คำสั่งหยุดการทำงานของลูป ล่ามย้ายไปยังคำสั่งถัดไปในโปรแกรมหลังจากวนซ้ำ พัง คำสั่งจะมีประโยชน์หากคุณต้องการให้ลูปของคุณหยุดทำงานหากตรงตามเงื่อนไขที่กำหนดในลูป

ไวยากรณ์สำหรับ ตัวแบ่ง ข้อความดังต่อไปนี้:

break;

คำสั่งแบ่งยืนอยู่คนเดียวเป็นคำหลักของตัวเอง ไม่รับอาร์กิวเมนต์ใดๆ เนื่องจากคำสั่ง break ไม่ใช่ฟังก์ชัน เมื่อพบคำสั่ง break โปรแกรมจะข้ามการวนซ้ำปัจจุบันของลูป

ทำลายตัวอย่าง Java

สมมติว่าเรากำลังสร้างโปรแกรมที่ขอให้ผู้ใช้เดาตัวเลขระหว่าง 1 ถึง 10

หากผู้ใช้เดาหมายเลขที่ถูกต้อง โปรแกรมของเราควรพิมพ์ข้อความแสดงความยินดีกับผู้ใช้ที่เดาหมายเลขที่ถูกต้อง มิฉะนั้น ผู้ใช้ของเราควรได้รับอนุญาตให้เดาอีกครั้ง สูงสุดห้าครั้ง

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

นี่คือรหัสที่เราสามารถใช้เขียนโปรแกรมนี้ได้:

import java.util.Scanner;

class GuessingGame {
	public static void main(String[] args) {
		int number = 6;
		Scanner input = new Scanner(System.in);

		for (int i = 0; i <= 5; i++) {
			System.out.print("Guess a number between 1 and 10: ");
			guess = input.nextInt();

			if (guess == number) {
				System.out.println("You're correct!");
				break;
			}
		}
	}
}

รหัสของเราส่งคืน:

Guess a number between 1 and 10: 1
Guess a number between 1 and 10: 6
You're correct!

โปรแกรมของเราขอให้เราเดาอีกครั้งหากเราเดาตัวเลขไม่ถูกต้อง

หากผู้ใช้เดาได้ห้าครั้งแล้ว โปรแกรมจะหยุด แต่ถ้าผู้ใช้เดาหมายเลขที่ถูกต้อง รหัสของเราจะพิมพ์ว่า “คุณถูก!” ไปที่คอนโซล

Java break ตัวอย่างการแยกย่อย

มาทำลายรหัสของเรากัน ขั้นแรก เรานำเข้าไลบรารี java.util.Scanner ซึ่งช่วยให้เรายอมรับอินพุตของผู้ใช้ เรากำหนดคลาสที่เรียกว่า GuessingGame จากนั้นโปรแกรมของเราจะทำสิ่งต่อไปนี้:

1. เราประกาศตัวแปร Java ชื่อ number. ตัวแปรนี้เก็บตัวเลขที่ผู้ใช้ควรเดา
2. เราใช้ อินพุตเครื่องสแกนเนอร์ เพื่อเริ่มต้นการป้อนข้อมูลของผู้ใช้ เพื่อให้เราสามารถดึงการคาดเดาจากผู้ใช้ในโปรแกรมของเราได้
3. เราสร้าง Java สำหรับ วนซ้ำซึ่งทำงานจนถึง i มีค่ามากกว่าห้า การวนซ้ำนี้ทำให้ผู้ใช้ของเราลองเดาหมายเลขที่ถูกต้องได้ห้าครั้ง
4. รหัสของเราพิมพ์ว่า “เดาตัวเลขระหว่าง 1 ถึง 10:“ ไปที่คอนโซล
5. เราใช้ input.nextInt() เพื่อยอมรับการเดาของผู้ใช้ เราเก็บการเดาไว้ในตัวแปรใหม่ที่เรียกว่า guess .
6. โปรแกรมของเราเปรียบเทียบว่าการเดาของผู้ใช้เท่ากับ หมายเลข . หรือไม่ ตัวแปรที่เก็บตัวเลขที่ผู้ใช้ควรเดา
7. ถ้า เดา เท่ากับ จำนวน , ข้อความ “คุณพูดถูก!” ถูกพิมพ์ไปที่คอนโซล จากนั้นลูปจะหยุดทำงาน
8. มิฉะนั้น สำหรับ วนซ้ำจะดำเนินการจนกว่า i มีค่ามากกว่า 5.

พัง คำสั่งยุติ สำหรับ หรือ ในขณะที่ วนซ้ำทันทีหลังจาก เบรก คำสั่งถูกดำเนินการ

คำสั่ง Java Nested break

พัง คำสั่งยุติวงในสุดในโปรแกรม Java สมมติว่าคุณมี ในขณะที่ วนซ้ำภายใน for วนซ้ำและ เบรก คำสั่งอยู่ใน ในขณะที่ ห่วง วงเดียวที่จะหยุดคือ ในขณะที่ วนซ้ำ

นี่คือตัวอย่างเพื่อแสดงให้เห็นวิธีการทำงาน:

for (int; expression; updateCounter) {
	// Code
	while (true) {
		// Code
		if (condition_is_met) {
			break;
		}
	}
}

ขั้นแรก เราเริ่มต้น สำหรับ ห่วง จากนั้น เราเริ่มต้น Java ในขณะที่ ห่วง เมื่อคำสั่งพักของเราทำงาน ในขณะที่ ลูปจะหยุดดำเนินการ อย่างไรก็ตาม สำหรับ loop จะทำงานต่อไปจนกว่าโปรแกรมจะหยุด

Java Labeled break Statement

คุณสามารถกำหนดป้ายกำกับให้กับป้ายกำกับให้กับ ตัวแบ่ง คำสั่งและสร้าง ตัวแบ่งที่มีป้ายกำกับ . สิ่งเหล่านี้ใช้เพื่อยุติคำสั่งที่ติดป้ายกำกับในโปรแกรม ซึ่งต่างจากคำสั่ง break ที่ไม่มีป้ายกำกับที่ทำลายลูปในสุด นี่คือไวยากรณ์สำหรับตัวแบ่งที่มีป้ายกำกับ:

break label_name;

For instance, say we have the following nested loop:

for (int; expression; updateCounter) {
	// Code
	for (int; expression; updateCounter) {
		// Code
		while (true) {
		if (condition_is_met) {
			break;
		}
		}
	}
}

เมื่อโปรแกรมของเราตรงตามเงื่อนไข เราต้องการให้โค้ดของเราพังและดำเนินการ for แรกต่อ ห่วง กล่าวอีกนัยหนึ่งเราต้องการให้โปรแกรมของเรายุติการวนซ้ำภายใน วงนอกควรวิ่งต่อไป

เราสามารถทำได้โดยใช้คำสั่งแบ่งที่มีป้ายกำกับ นี่คือรหัสที่เราจะใช้เพื่อแยกส่วน for second ที่สองของเรา วนซ้ำและ ในขณะที่ วนซ้ำ:

for (int; expression; updateCounter) {
	// Code
	top_break:
	for (int; expression; updateCounter) {
		// Code
		while (true) {
		if (condition_is_met) {
			break top_break;
		}
		}
	}
}

ทันทีที่ break top_break คำสั่งดำเนินการ โปรแกรมจะยุติการวนซ้ำทั้งหมดจนกว่า cod ของเราจะดำเนินการ top_break คำแถลง. ในกรณีนี้ หมายความว่า สำหรับตัวที่สอง วนซ้ำและ ในขณะที่ วนซ้ำสิ้นสุดลงและโปรแกรมยังคงทำงานต่อไป

บทสรุป

Java แตก คำสั่งยุติการวนซ้ำ คำสั่ง break ที่มีป้ายกำกับใช้เพื่อยุติการวนซ้ำและข้ามไปยังคำสั่งที่สอดคล้องกับตัวแบ่งที่มีป้ายกำกับ

บทแนะนำนี้กล่าวถึงวิธีใช้ ตัวแบ่ง และติดป้ายกำกับ break เพื่อควบคุมการไหลของโปรแกรม

คุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Java หรือไม่? ดูคู่มือ How to Learn Java ฉบับสมบูรณ์ของเรา ในคู่มือนี้ คุณจะพบคำแนะนำเกี่ยวกับหลักสูตร หนังสือ และแหล่งข้อมูลการเรียนรู้ชั้นนำ