๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
โ˜•Java

[Java ์ดํ•ดํ•˜๊ธฐ] 7. ์ž๋ฐ”์˜ ์ œ์–ด๋ฌธ

by Luvbit 2024. 5. 11.

๐Ÿฉต Java์˜ ์ œ์–ด๋ฌธ์ด๋ž€?

Java์—์„œ์˜ ์ œ์–ด๋ฌธ์€ ํ”„๋กœ๊ทธ๋žจ์˜ ํ๋ฆ„์„ ์œ ์—ฐํ•˜๊ฒŒ ์ œ์–ดํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด ์ค๋‹ˆ๋‹ค.
๋ณต์žกํ•œ ์ฝ”๋“œ๋„ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ๋งŒ๋“ค๋ฉฐ, ํšจ๊ณผ์ ์œผ๋กœ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 

Java์—์„œ ์ œ์–ด๋ฌธ์€ ํฌ๊ฒŒ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ ๋‚˜๋ˆ„์–ด์ง‘๋‹ˆ๋‹ค.
์ด๋“ค์€ ํŠน์ • ์กฐ๊ฑด์— ๋”ฐ๋ผ ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•˜๊ฑฐ๋‚˜, ๋ฐ˜๋ณตํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.
์ด๋Ÿฌํ•œ ๊ตฌ์กฐ๋ฅผ ํ™œ์šฉํ•˜๋ฉด ๋ณต์žกํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜๋„ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
์ œ์–ด๋ฌธ์˜ ์ข…๋ฅ˜์—๋Š” 'if- else', 'siwtch' , 'for' , 'while', 'do-while'๋“ฑ์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค.

 

 

 

1๏ธโƒฃ ์กฐ๊ฑด๋ฌธ (Conditional Statements)

 

1) if๋ฌธ, if- else๋ฌธ

 

'if ๋ฌธ' , 'if-else'๋ฌธ์€ ์กฐ๊ฑด์˜ ์ฐธ ๋˜๋Š” ๊ฑฐ์ง“์„ ํŒ๋‹จํ•˜์—ฌ ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค. ์กฐ๊ฑด์„ ํ•˜๋‚˜๋งŒ ํŒ๋ณ„ํ•˜๋Š” ๋˜๋Š” ๊ฒฝ์šฐ ๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ํ˜•ํƒœ์ธ if๋ฌธ์„ ํ™œ์šฉํ•˜๋ฉฐ, ๊ฑฐ์ง“๊นŒ์ง€ ํŒ๋ณ„ํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๋Š” ์ถ”๊ฐ€๋กœ 'else'๋ธ”๋ก์„ ์ถ”๊ฐ€ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋˜ํ•œ, ๋” ๋งŽ์€ ์กฐ๊ฑด์„ ํŒ๋ณ„ํ•ด์•ผ ํ•  ๊ฒฝ์šฐ๋Š” 'else-if'๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

case 1

if(a > b) {
	System.out.println("a๊ฐ€ ํฝ๋‹ˆ๋‹ค!");
}
//a๊ฐ€ b๋ณด๋‹ค ํฐ ๊ฒฝ์šฐ๋งŒ ํŒ๋ณ„. ์กฐ๊ฑด์ด ์ฐธ์ผ ๋•Œ๋งŒ ์ถœ๋ ฅ๋œ๋‹ค.

 

 

case 2

if (a > b) {
   System.out.println("a๊ฐ€ ๋” ํฝ๋‹ˆ๋‹ค!");
} else {
   System.out.println("b๊ฐ€ ๋” ํฝ๋‹ˆ๋‹ค!");
}
// ์ด์ „ ์ฝ”๋“œ๋Š” a๊ฐ€ ๋” ํด๋•Œ๋งŒ ์ถœ๋ ฅ๋์œผ๋‚˜, ์ด๋Š” b๊ฐ€ ๋” ํด๋•Œ๋„ ์ถœ๋ ฅํ•œ๋‹ค.

 

 

case 3

if (score > 90) {
    System.out.println("์„ฑ์ ์€ A์ž…๋‹ˆ๋‹ค.");
} else if (score > 80) {
    System.out.println("์„ฑ์ ์€ B์ž…๋‹ˆ๋‹ค.");
} else {
   System.out.println("์„ฑ์ ์€ C์ž…๋‹ˆ๋‹ค.");
}

// 3๊ฐ€์ง€ ์กฐ๊ฑด์„ ๋ชจ๋‘ ํŒ๋ณ„ํ• ์ˆ˜ ์žˆ๋‹ค. ๋” ์—ฌ๋Ÿฌ ๊ฐœ๋„ ๊ฐ€๋Šฅ.

 

 

2) switch๋ฌธ

 

'switch' ๋ฌธ์€ ๋ณ€์ˆ˜์˜ ๊ฐ’์— ๋”ฐ๋ผ ๋‹ค์ˆ˜์˜ ์ฝ”๋“œ ์ค‘ ํ•˜๋‚˜๋ฅผ ์„ ํƒํ•˜์—ฌ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค. 'switch' ๋ฌธ์€ ์ฃผ์–ด์ง„ ์กฐ๊ฑด๊ณผ ์ผ์น˜ํ•˜๋Š” 'case' ๋ผ๋ฒจ์˜ ๋ธ”๋ก์„ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค. ์กฐ๊ฑด์ด ๋งŽ์„ ๊ฒฝ์šฐ 'if-else' ๋ณด๋‹ค switch๊ฐ€ ์ฝ”๋“œ๋ฅผ ์กฐ๊ธˆ ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ๋งŒ๋“ค๊ธฐ๋„ ํ•ฉ๋‹ˆ๋‹ค.

 

int num1 = 1;
int num2 = 3;
char op = '+';

switch (op) {
    case '+':
        // op๊ฐ€ '+'์™€ ์ผ์น˜ํ•  ๋•Œ ์‹คํ–‰๋˜๋Š” ์ฝ”๋“œ
        System.out.println("๊ฒฐ๊ณผ๋Š”" + (num1+num2) + "์ž…๋‹ˆ๋‹ค!");
        break;
    case '-':
        // op๊ฐ€ '-'์™€ ์ผ์น˜ํ•  ๋•Œ ์‹คํ–‰๋˜๋Š” ์ฝ”๋“œ
        System.out.println("๊ฒฐ๊ณผ๋Š”" + (num1-num2) + "์ž…๋‹ˆ๋‹ค!");
        break;
    default:
        // ์–ด๋–ค case์—๋„ ํ•ด๋‹นํ•˜์ง€ ์•Š์„ ๋•Œ ์‹คํ–‰ํ•  ์ฝ”๋“œ
        System.out.println("์ด ๊ณ„์‚ฐ๊ธฐ๋Š” ๋ง์…ˆ๊ณผ ๋บผ์…ˆ๋งŒ ์ง€์›ํ•ฉ๋‹ˆ๋‹ค!");
        break;
}

 

switch ๋ฌธ์€ ํŠน์ • ๋ณ€์ˆ˜์˜ ๊ฐ’์— ๋”ฐ๋ผ ์—ฌ๋Ÿฌ ๊ฐ€๋Šฅ์„ฑ ์ค‘ ํ•˜๋‚˜๋ฅผ ์„ ํƒํ•ด์•ผ ํ•  ๋•Œ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค. break ๋ฌธ์„ ์‚ฌ์šฉํ•ด ๊ฐ case ๋ธ”๋ก ํ›„ ์‹คํ–‰์„ ์ข…๋ฃŒํ•˜๋ฉฐ, default ๋ธ”๋ก์€ ์–ด๋–ค case๋„ ์ผ์น˜ํ•˜์ง€ ์•Š์„ ๋•Œ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. 

 

โš ๏ธ ๋งŒ์•ฝ, break๋ฌธ์„ ๊ฑธ์ง€ ์•Š์œผ๋ฉด ํ•ด๋‹นํ•˜๋Š” case๋ฌธ ์•„๋ž˜์˜ ์ฝ”๋“œ๋„ ์ „๋ถ€ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด break๊ฐ€ ์—†๋Š” ๊ฒฝ์šฐ,  '+' ๊ฒฐ๊ณผ์™€ , '-' ๊ฒฐ๊ณผ, default๊ฒฐ๊ณผ๊นŒ์ง€ ๋ชจ๋‘ ์ถœ๋ ฅ๋˜๊ณ  ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.

 

 

 

 


 

 

 

2๏ธโƒฃ ๋ฐ˜๋ณต๋ฌธ (Loop Statements)

 

1) for๋ฌธ

 

๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ๋ฐ˜๋ณต๋ฌธ ํ˜•ํƒœ๋กœ, ์ดˆ๊ธฐํ™”, ์กฐ๊ฑด ๊ฒ€์‚ฌ, ์ฆ๊ฐ์˜ ์„ธ ๋ถ€๋ถ„์œผ๋กœ ๊ตฌ์„ฑ๋ฉ๋‹ˆ๋‹ค. '1๋ถ€ํ„ฐ 10๊นŒ์ง€ ๋ฐ˜๋ณต'์ด ํ•„์š”ํ•  ๋•Œ ๋Œ€ํ‘œ์ ์œผ๋กœ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

for๋ฌธ๊ณผ for-each๋ฌธ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

 

case 1 

for(int i=0; i<5; i++) {
	System.out.print(i + " ");
}

print >>
0 1 2 3 4

// ์ด ์ฝ”๋“œ์˜ ์˜๋ฏธ๋Š” '0๋ถ€ํ„ฐ 4๊นŒ์ง€ ์ฐ์–ด' ์ž…๋‹ˆ๋‹ค.
// i๋Š” 0๋ถ€ํ„ฐ, i๊ฐ€ 5๋ณด๋‹ค ์ž‘์„๋•Œ๊นŒ์ง€(= 5๊ฐ€๋˜๋ฉด ์‹คํ–‰ x) ๋ฐ˜๋ณตํ• ๋•Œ๋งˆ๋‹ค i์— +1์„ ํ•ด์ฃผ๋ผ๋Š” ์˜๋ฏธ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

 

 

case2

int[] numbers = {1,2,3,4,5};

for(int i : numbers) {
	System.out.println(i);
}

print >>
1 2 3 4 5
//์ด ์ฝ”๋“œ์˜ ์˜๋ฏธ๋Š” numbers์•ˆ์— ์žˆ๋Š” ์•„์ด๋“ค์„ ํ•˜๋‚˜์”ฉ ๊บผ๋‚ด์„œ i์— ๋‹ด๊ณ ,
//i๋ฅผ ์ถœ๋ ฅํ•ด๋‹ฌ๋ผ๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

 

์ด for-each๋ฌธ์€ ๋ฐฐ์—ด์ด๋‚˜ ๋ฆฌ์ŠคํŠธ์˜ ์š”์†Œ๋ฅผ ์ถœ๋ ฅํ•  ๋•Œ  ๋งŽ์ด ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์•„์ง ๋ฐฐ์—ด์„ ๋ฐฐ์šฐ์ง€ ์•Š์•˜์ง€๋งŒ, ์—ฌ๊ธฐ์„œ์˜ numbers๋Š” int ๊ฐ’๋“ค์ด ์ฐจ๋ก€์ฐจ๋ก€ ๋ชจ์—ฌ์žˆ๋Š” ์•„์ด๋ผ๊ณ  ์ƒ๊ฐํ•˜๊ณ  ๋„˜์–ด๊ฐ€์ฃผ์‹œ๋ฉด ๋  ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. 

 

 

2) While๋ฌธ

 

์กฐ๊ฑด์ด ์ฐธ์ผ ๋™์•ˆ์—๋งŒ ์ฃผ์–ด์ง„ ์ฝ”๋“œ๋ฅผ ๊ณ„์† ๋ฐ˜๋ณต ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค. for๋ฌธ๊ณผ ๋ชฉ์ ์€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. while ๋ฌธ๊ณผ do-while๋ฌธ์ด ์žˆ์Šต๋‹ˆ๋‹ค. while๋ฌธ๊ณผ do-while๋ฌธ์˜ ์ฐจ์ด๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

while๋ฌธ์€ ์กฐ๊ฑด์ด ์ฐธ์ด ์•„๋‹ˆ๋ฉด ์ฃผ์–ด์ง„ ์ฝ”๋“œ๊ฐ€ ์ ˆ๋Œ€ ์‹คํ–‰๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด์— do-while๋ฌธ์€ ์กฐ๊ฑด์ด ๊ฑฐ์ง“์ด๋ผ๋„ ์ตœ์†Œ ํ•œ ๋ฒˆ์€ ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” ์ฝ”๋“œ์˜ ํŠน์„ฑ์ธ ์œ„์—์„œ ์•„๋ž˜ ์ˆœ์œผ๋กœ ์‹คํ–‰๋œ๋‹ค๋Š” ์ ์„ ์ดํ•ดํ•ด ์ฃผ์‹œ๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

 

case 1

int a = 0;

while(a < 5) {
	System.out.print(a++ + " ");
}

print >>
0 1 2 3 4

//a๊ฐ€ 5๊ฐ€ ๋˜๋Š”์ˆœ๊ฐ„ ๋ฐ˜๋ณต์ด ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.

 

 

case 2

boolean bl = false;

do {
	System.out.println("์ €๋Š” ๊ฑฐ์ง“์ธ๋ฐ๋„ ์‹คํ–‰์ด ๋ ๊นŒ์š”?");
			
} while(bl);
		
print >>
์ €๋Š” ๊ฑฐ์ง“์ธ๋ฐ๋„ ์‹คํ–‰์ด ๋ ๊นŒ์š”?
        
// do-while๋ฌธ์€ ๋ณด์‹œ๋Š” ๋ฐ”์™€ ๊ฐ™์ด, while์•ˆ์˜ ์กฐ๊ฑด์ด false์ž„์—๋„ ๋ถˆ๊ตฌํ•˜๊ณ  do-while๋ฌธ์ด๊ธฐ์—
// ์ฝ”๋“œ๊ฐ€ ํ•œ๋ฒˆ์€ ์‹คํ–‰๋˜๊ณ  ๋ฐ˜๋ณต์ด ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.

 

 

 

 

 

 

 

์ด๋Ÿฌํ•œ ์ œ์–ด๋ฌธ๊ณผ ๋ฐ˜๋ณต๋ฌธ์€ Java ํ”„๋กœ๊ทธ๋กœ๋ฐ์—์„œ ๋งค์šฐ ์ค‘์š”ํ•œ ์š”์†Œ์ž…๋‹ˆ๋‹ค.
ํ•œ ๋ฒˆ์”ฉ ์‹คํ–‰ํ•ด ๋ณด๋ฉด์„œ ์ด๋ ‡๊ฒŒ ์“ฐ์ด๋Š”๊ตฌ๋‚˜๋ฅผ ๊ผญ ์ตํ˜€์ฃผ์„ธ์š”!
๋‹ค์Œ ํฌ์ŠคํŒ…์—์„œ๋Š” String ๊ธฐ์ดˆ๋กœ ์ฐพ์•„๋ต™๊ฒ ์Šต๋‹ˆ๋‹ค 

์งˆ๋ฌธ ๋˜๋Š” ๋Œ“๊ธ€์€ ์–ธ์ œ๋“ ์ง€ ํ™˜์˜ํ•ฉ๋‹ˆ๋‹ค!
๐Ÿฉต๐Ÿฐ๐Ÿฉต