์๋ฐ ํ๋ก๊ทธ๋๋ฐ์์๋ ์ฝ๋์ ์คํ ํ๋ฆ์ ํจ๊ณผ์ ์ผ๋ก ์ ์ดํ๊ธฐ ์ํด break์ continue ๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ์ด ๋ ๋ฌธ์ ๋ฐ๋ณต๋ฌธ์ ์กฐ์ ํ์ฌ ํน์ ์กฐ๊ฑด์์ ๋ฃจํ๋ฅผ ์ข ๋ฃํ๊ฑฐ๋ ๊ฑด๋๋ธ ๋ ์ ์ฉํฉ๋๋ค. ์ด๋ฒ ํฌ์คํ ์์๋ break์ continue ๋ฌธ์ ๊ฐ๋ , ํ์ฉ ๋ฐฉ๋ฒ, ๊ทธ๋ฆฌ๊ณ ์ฃผ์ ์ฌํญ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
์๋ฐ ๋ฐ๋ณต๋ฌธ์ ๋ํ ๋ด์ฉ์ ์๋ ํฌ์คํ ์ ํ์ธํด ์ฃผ์ธ์๐
break ๋ฌธ๐
break๋ฌธ์ ๋ฐ๋ณต๋ฌธ ๋ด์์ ์ฌ์ฉ๋๋ฉฐ, ๋ฐ๋ณต๋ฌธ์ ์คํ์ ์ฆ์ ์ข ๋ฃํ๊ณ ๋น ์ ธ๋์ค๋ ์ญํ ์ ํฉ๋๋ค. ์ฃผ๋ก ๋ฐ๋ณต๋ฌธ (for, while, do-while) ๋ด๋ถ์์ ์ฌ์ฉ๋๋ฉฐ, ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋์์ ๋ ๋ฐ๋ณต๋ฌธ์ ์ฆ์ ์ข ๋ฃํ๊ณ ๋ฐ๋ณต๋ฌธ์ ๋ฒ์ด๋ฉ๋๋ค. ์ฌ๋ฌ ์ํฉ์์ break ๋ฌธ์ด ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฐ๋ณต๋ฌธ์์ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ ๊ฒฝ์ฐ ๋ฃจํ๋ฅผ ์ข ๋ฃํ๊ณ ์ ํ ๋ ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ๋ํ, ๋ฐ๋ณต๋ฌธ ๋ด์์ ์์ธ์ ์ธ ๊ฒฝ์ฐ์๋ง ๋ฐ๋ณต์ ์ค๋จํ๊ณ ์ ํ ๋๋ ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
break๋ฌธ ์์
์๋์ ์์ ์์๋ for ๋ฐ๋ณต๋ฌธ์ด ์คํ๋๋ ๋์ค์ i ๊ฐ์ด 3์ด ๋์์ ๋, break ๋ฌธ์ด ์คํ๋์ด ๋ฐ๋ณต๋ฌธ์ด ์ข ๋ฃ๋ฉ๋๋ค.
public class BreakExample {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
if (i == 3) {
System.out.println("๋ฐ๋ณต๋ฌธ ์ข
๋ฃ!");
break;
}
System.out.println("i ๊ฐ: " + i);
}
}
}
์ด๋ฒ ์์ ๋ ์ฌ์ฉ์๋ก๋ถํฐ ์ ๋ ฅ๋ฐ์ ์ซ์๋ค ์ค์์ 0์ ์ ๋ ฅํ ๋๊น์ง ํฉ์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ๋๋ค. ์ฌ์ฉ์๊ฐ 0์ ์ ๋ ฅํ๋ฉด ๋ฐ๋ณต๋ฌธ์ด ์ค๋จ๋๊ณ ํฉ์ ์ถ๋ ฅํฉ๋๋ค.
import java.util.Scanner;
public class BreakExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int sum = 0;
System.out.println("์ซ์๋ฅผ ์
๋ ฅํ์ธ์. (0 ์
๋ ฅ ์ ์ข
๋ฃ)");
while (true) {
System.out.print("์ซ์ ์
๋ ฅ: ");
int num = scanner.nextInt();
if (num == 0) {
System.out.println("์
๋ ฅ ์ข
๋ฃ!");
break; // 0์ ์
๋ ฅํ๋ฉด ๋ฐ๋ณต๋ฌธ ์ข
๋ฃ
}
sum += num;
}
System.out.println("์
๋ ฅํ ์ซ์๋ค์ ํฉ: " + sum);
scanner.close();
}
}
์ด๋ ๊ฒ break ๋ฌธ์ ์ฌ์ฉํ๋ฉด ํน์ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋์์ ๋ ๋ฐ๋ณต๋ฌธ์ ์ฆ์ ์ข
๋ฃ์ํฌ ์ ์์ด์ ์ํ๋ ์์ ์ ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ์ ์ดํ ์ ์์ต๋๋ค.
break๋ฌธ ์ฃผ์์ฌํญ
- ์๋ชป๋ ์์น์์ ์ฌ์ฉํ์ง ์๊ธฐ: break ๋ฌธ์ ๋ฐ๋ณต๋ฌธ ๋ด์์๋ง ์ฌ์ฉํด์ผ ํฉ๋๋ค. ๋ฐ๋ณต๋ฌธ์ด ์๋ ๊ณณ์์ break ๋ฌธ์ ์ฌ์ฉํ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
- ๋๋ฌด ๋ง์ ์ฌ์ฉ ํผํ๊ธฐ: break ๋ฌธ์ ๋จ์ฉํ๋ฉด ์ฝ๋์ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง ์ ์์ต๋๋ค. ๋ฐ๋ณต๋ฌธ ๋ด์์ ๋ถํ์ํ๊ฒ ๋ง์ break ๋ฌธ์ ์ฌ์ฉํ๋ ๊ฒ์ ์ฝ๋๋ฅผ ์ดํดํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ค ์ ์์ต๋๋ค.
- ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์ ์ฃผ์ํ๊ธฐ: ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์ break ๋ฌธ์ ์ฌ์ฉํ ๋๋ ์ฃผ์ํด์ผ ํฉ๋๋ค. break ๋ฌธ์ ๊ฐ์ฅ ์์ชฝ์ ์๋ ๋ฐ๋ณต๋ฌธ๋ง ์ข ๋ฃ์ํค๋ฏ๋ก, ๋ฐ๊นฅ์ชฝ ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃ์ํค๋ ค๋ฉด ์ถ๊ฐ์ ์ธ ์กฐ์น๊ฐ ํ์ํฉ๋๋ค.
- ๋ฌดํ ๋ฃจํ์ ๋น ์ง ๊ฐ๋ฅ์ฑ ๊ณ ๋ คํ๊ธฐ: ๋ฐ๋ณต๋ฌธ์์ break ๋ฌธ์ ์ฌ์ฉํ ๋ ๋ฌดํ ๋ฃจํ์ ๋น ์ง ๊ฐ๋ฅ์ฑ์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค. break ๋ฌธ์ด ์คํ๋๋ ์กฐ๊ฑด์ ์ ์คํ ๊ฒํ ํ์ฌ ํ๋ก๊ทธ๋จ์ด ์ํ๋ ๋๋ก ๋์ํ๋๋ก ํด์ผ ํฉ๋๋ค.
break outter
"break outter" ๋ ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์ ๋ด๋ถ ๋ฐ๋ณต๋ฌธ์์ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃ์ํค๋ ์ฉ๋๋ก ์ฌ์ฉ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์ ๋ด๋ถ ๋ฐ๋ณต๋ฌธ์์ break ๋ฌธ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ๋ง ์ข
๋ฃ๋ฉ๋๋ค. ํ์ง๋ง ๊ฒฝ์ฐ์ ๋ฐ๋ผ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ๊น์ง ํ ๋ฒ์ ์ข
๋ฃ์์ผ์ผ ํ ๋๊ฐ ์์ต๋๋ค. ์ด๋ "break outter"๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃ์ํต๋๋ค.
์ฌ๊ธฐ์ "outter"๋ ์ธ๋ถ๋ฅผ ์๋ฏธํ๋ ๋จ์ด๋ก, ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ๊ฐ๋ฆฌํต๋๋ค. "break outter"๋ ์ด๋ฌํ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃํ๋ ์ญํ ์ ํฉ๋๋ค. ์ด๋ฅผํ
๋ฉด ์๋์ ๊ฐ์ ์ํฉ์์ "break outter"๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
outerloop:
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (i * j > 6) {
System.out.println("Breaking out of outerloop");
break outerloop;
}
System.out.println(i + " " + j);
}
}
์์ ์ฝ๋์์ "outerloop"์ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ๋ํ๋ด๋ ๋ ์ด๋ธ(label)์
๋๋ค. ๋ด๋ถ ๋ฐ๋ณต๋ฌธ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ "break outerloop;"๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃ์ํฌ ์ ์์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ด๋ถ ๋ฐ๋ณต๋ฌธ์์ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ๊น์ง ํ ๋ฒ์ ์ข
๋ฃํ ์ ์์ต๋๋ค.
continue ๋ฌธ๐โ
continue ๋ฌธ์ ๋ฐ๋ณต๋ฌธ ๋ด์์ ์ฌ์ฉ๋๋ฉฐ, ๋ฐ๋ณต๋ฌธ์ ๋๋จธ์ง ๋ถ๋ถ์ ๊ฑด๋๋ฐ๊ณ ๋ฐ๋ก ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ๋ ์ญํ ์ ํฉ๋๋ค. ์ฆ, continue ๋ฌธ์ด ์คํ๋๋ฉด ํด๋น ๋ฐ๋ณต์ ๋๋จธ์ง ๋ถ๋ถ์ ์คํ๋์ง ์๊ณ ๋ค์ ๋ฐ๋ณต์ด ์งํ๋ฉ๋๋ค.
์ฃผ๋ก ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ ๋ ํด๋น ๋ฐ๋ณต์ ๊ฑด๋๋ฐ๊ณ ์ ํ ๋ continue ๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฐ๋ณต๋ฌธ ๋ด์์ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ํน์ ์์ ์ ์ํํ์ง ์๊ณ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ๊ณ ์ถ์ ๋ continue ๋ฌธ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
continue๋ฌธ ์์
์๋๋ continue ๋ฌธ์ ์ฌ์ฉํ ๊ฐ๋จํ ์์ ์ ๋๋ค. ์ด ์์ ๋ 1๋ถํฐ 10๊น์ง์ ์ซ์ ์ค์์ ํ์๋ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋๋ค.
public class ContinueExample {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
// ์ง์์ธ ๊ฒฝ์ฐ์๋ continue ๋ฌธ์ ์คํํ์ฌ ํ์ฌ ๋ฐ๋ณต์ ๊ฑด๋๋๋๋ค.
continue;
}
System.out.println(i); // ํ์๋ง ์ถ๋ ฅ
}
}
}
์๋๋ continue ๋ฌธ์ ์ฌ์ฉํ์ฌ 1๋ถํฐ 10๊น์ง์ ์ซ์ ์ค์์ 3์ ๋ฐฐ์๋ฅผ ์ ์ธํ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ์์ ์ฝ๋์
๋๋ค.
public class ContinueExample {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
// 3์ ๋ฐฐ์์ธ ๊ฒฝ์ฐ์๋ continue ๋ฌธ์ ์คํํ์ฌ ํ์ฌ ๋ฐ๋ณต์ ๊ฑด๋๋๋๋ค.
continue;
}
System.out.println(i); // 3์ ๋ฐฐ์๋ฅผ ์ ์ธํ ์ซ์ ์ถ๋ ฅ
}
}
}
์ ์ฝ๋๋ ๋ฐ๋ณต๋ฌธ์ด ์คํ๋๋ ๋์ค์ ํ์ฌ ์ซ์๊ฐ 3์ ๋ฐฐ์์ธ ๊ฒฝ์ฐ์๋ง continue ๋ฌธ์ด ์คํ๋์ด ํด๋น ๋ฐ๋ณต์ ๊ฑด๋๋ฐ๊ณ , ๊ทธ ์ธ์ ๊ฒฝ์ฐ์๋ ์ซ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
continue๋ฌธ ์ฃผ์์ฌํญ
- ๋ฌดํ ๋ฃจํ์ ๋น ์ง์ง ์๋๋ก ์ฃผ์: continue ๋ฌธ์ ์ฌ์ฉํ ๋๋ ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃ ์กฐ๊ฑด์ ์ ์คํ๊ฒ ์ค์ ํด์ผ ํฉ๋๋ค. ์๋ชป๋ ์กฐ๊ฑด ์ค์ ์ผ๋ก ์ธํด ๋ฌดํ ๋ฃจํ์ ๋น ์ง ์ ์์ต๋๋ค.
- ์คํ ์์ ํ์ธ: continue ๋ฌธ์ด ์คํ๋ ํ์๋ ํด๋น ๋ฐ๋ณต์์ ๋จ์ ์ฝ๋๋ฅผ ์คํํ์ง ์๊ณ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ๋๋ค. ๋ฐ๋ผ์ continue ๋ฌธ ์ดํ์ ์ฝ๋๊ฐ ์คํ๋์ง ์๋๋ค๋ ์ ์ ์ฃผ์ํด์ผ ํฉ๋๋ค.
- ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์์ ์ฃผ์: ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์์ continue ๋ฌธ์ ์ฌ์ฉํ ๋๋ ๋ด๋ถ ๋ฐ๋ณต๋ฌธ์ด ์๋ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ด๋ํ๋๋ก ํ๋ ค๋ฉด ์ถ๊ฐ์ ์ธ ์ ์ด๊ฐ ํ์ํฉ๋๋ค. ์ด๋ฅผ ์ํด ๋ ์ด๋ธ์ ์ฌ์ฉํ๊ฑฐ๋, ๋ฉ์๋๋ฅผ ๋ถ๋ฆฌํ์ฌ ์ฒ๋ฆฌํ๋ ๋ฑ์ ๋ฐฉ๋ฒ์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
- ์ฝ๋ ๊ฐ๋
์ฑ ์ ์ง: continue ๋ฌธ์ ์ฝ๋์ ๊ฐ๋
์ฑ์ ๋ฎ์ถ ์ ์์ต๋๋ค. ๋๋ฌด ๋ง์ continue ๋ฌธ์ ์ฌ์ฉํ๋ฉด ์ฝ๋์ ํ๋ฆ์ ํ์
ํ๊ธฐ ์ด๋ ค์์ง ์ ์์ผ๋ฏ๋ก, ํ์ํ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.