๐ฅ 4์ฃผ์ฐจ ๊ณผ์ : ์ ์ด๋ฌธ
- ๋ฐฑ๊ธฐ์ ๋์ด ์ ํญ์์ ์งํํ๋ JAVA Live-study ๊ณผ์ ์ ๊ธฐ๋กํ๋ค.
- ๋งค ์ฃผ ์ด์์ ์ฌ๋ผ์จ ์ง๋ฌธ๋ค์ ๋ํด ๊ณต๋ถํ๊ณ ๋ต์ ๋จ๊ธฐ๊ณ , ์ด์์ ๋งํฌ๋ฅผ ๊ณต์ ํ๋ ๋ฐฉ์์ผ๋ก ์งํ๋๋ค. ์ถํ ๋ฐฑ๊ธฐ์ ๋์ ์ ํ๋ธ ๋ผ์ด๋ธ๋ฅผ ํตํด ํผ๋๋ฐฑ์ ๋ฐ๊ฒ ๋๋ค.
์ฆ, Java ๊ณต๋ถ๋ฅผ ๊ธฐ๋กํ๋ ๊ณผ์ ์ด๋ค ๐ฑ
๐ ๋ชฉํ
์๋ฐ๊ฐ ์ ๊ณตํ๋ ์ ์ด๋ฌธ์ ํ์ตํ์ธ์.
๐ ํ์ตํ ๊ฒ (ํ์)
- ์ ํ๋ฌธ
- ๋ฐ๋ณต๋ฌธ
์ ์ด๋ฌธ์ด๋?
์ ์ด๋ฌธ(Control-flow statement)์ ํ๋ก๊ทธ๋จ์ ์คํ ์์๋ฅผ ์ ์ดํ ์ ์๊ฒ ํ๋ค. Java์ ์ ์ด๋ฌธ์ decision making, branching, looping, conditional block์ด ์๋ค.
(์ด๋ฏธ์ง ์ถ์ฒ: https://soshace.com/wp-content/uploads/2020/01/untitled-drawing.jpg)
Decision making statements(์ ํ๋ฌธ)
- if statement
if ๋ฌธ์ expression๊ณผ statement๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. expression์ด ์ฐธ์ด ๋๋ ๊ฒฝ์ฐ, ์ธํฐํ๋ฆฌํฐ๊ฐ statement๋ฅผ ์คํํ๊ณ , expression์ด ๊ฑฐ์ง์ด ๋๋ ๊ฒฝ์ฐ, ๊ทธ statement๋ฅผ ์คํตํ๋ค.
if (username == null) // If username is null,
username = "John Doe"; // use a default value
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- if-else statement
if ๋ฌธ์ ๋ํ ์ ํ์ ์ผ๋ก else ํค์๋๋ฅผ ํจ๊ป ์ฌ์ฉํ ์ ์๋ค. expression์ด ์ฐธ์ด๋ผ๋ฉด ์ฒซ ๋ฒ์งธ statement๋ฅผ ์คํํ๊ณ , ๊ฑฐ์ง์ด๋ผ๋ฉด ๋ ๋ฒ์งธ statement๋ฅผ ์คํํ๊ฒ ๋๋ค.
if (username != null)
System.out.println("Hello " + username);
else {
username = askQuestion("What is your name?");
System.out.println("Hello " + username + ". Welcome!");
}
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- else-if clause
๋ง์ฝ, ์ฌ๋ฌ ๋ธ๋ก์ ์ฝ๋ ์ค ์ ํํด์ผํ๋ค๋ฉด else-if ์ ์ ์ฌ์ฉํ๋ค.
if (n == 1) {
// Execute code block #1
}
else if (n == 2) {
// Execute code block #2
}
else if (n == 3) {
// Execute code block #3
}
else {
// If all else fails, execute code block #4
}
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- switch statement
๋ง์ฝ, ํ๋์ ๋ณ์ ๊ฐ์ ๋ฐ๋ผ ์ ํ์ง๊ฐ ๊ฒฐ์ ๋๋ค๋ฉด, ์ฌ๋ฌ ๊ฐ์ if ๊ตฌ๋ฌธ์ ๋์ ํ์ฌ switch ๋ฌธ์ ์ฌ์ฉํ ์ ์๋ค.
switch(n) {
case 1: // Start here if n == 1
// Execute code block #1
break; // Stop here
case 2: // Start here if n == 2
// Execute code block #2
break; // Stop here
case 3: // Start here if n == 3
// Execute code block #3
break; // Stop here
default: // If all else fails...
// Execute code block #4
break; // Stop here
}
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
Looping statements(๋ฐ๋ณต๋ฌธ)
- while statement
while ๋ฌธ์ Java์ ๊ธฐ๋ณธ์ ์ธ ๋ฐ๋ณต๋ฌธ์ด๋ค.
expression์ ์ฐธ/๊ฑฐ์ง์ ํ๋ณํ์ฌ(boolean ๋๋ Boolean์ด ๊ฒฐ๊ณผ๊ฐ์ธ ์์ ) ๊ฑฐ์ง์ด๋ผ๋ฉด ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๊ณ ๋ค์ ๊ตฌ๋ฌธ์ผ๋ก ์ด๋ํ๋ค. ์ฐธ์ด๋ผ๋ฉด ๋ฐ๋ณต์ด ์ฌ๊ฐ๋๋ฉฐ expression์ ์ฐธ/๊ฑฐ์ง์ด ๋ค์ ํ๊ฐ๋๋ค.
/*
๋ณ์ count๋ 0์์ ์์ํ๋ค. while ๋ฌธ์ 10๋ฒ ์คํ๋๊ณ ,
count๊ฐ 10์ด ๋์ด ์กฐ๊ฑด์ธ count < 10 ์ด false๊ฐ ๋๋ฏ๋ก ๋ฐ๋ณต๋ฌธ์ด ์ข
๋ฃ๋๋ค.
*/
int count = 0;
while (count < 10) {
System.out.println(count); // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
count++;
}
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- do statement
do ๋๋ do-while ๋ฌธ์ while ๋ฌธ๊ณผ ๋น์ทํ๋ค. while ๋ฌธ์ ์ฐธ/๊ฑฐ์ง์ ํ๋ณํ๋ expression์ ๋จผ์ ๋ณด์ง๋ง do-while ๋ฌธ์ loop์ด ๋จผ์ ์คํ๋๊ณ expression์ ํ๋ณํ๋ค. ์ฆ, do-while ๋ฌธ์ ์ต์ ํ ๋ฒ ์ด์ loop๊ฐ ์คํ๋๋ค.
int count = 0;
do {
System.out.println(count);
count++;
} while(count < 10);
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- for statement
๋๋ถ๋ถ์ ๋ฐ๋ณต ๊ตฌ๋ฌธ์ counter๋ state๋ฅผ ๊ธฐ๋กํ๋ ๋ณ์๊ฐ ์กด์ฌํ๊ณ loop ๊ณผ์ ๋์ ์ฐธ/๊ฑฐ์ง์ด ํ๋ณ๋๋ค. for ๋ฌธ์ ์ด๋ฌํ ๋ณ์์ initialize, update ๊ณผ์ ์ ๋์ฑ ๋ช ๋ฐฑํ๊ฒ ๋ง๋ค์ด์ฃผ๋ ๋ฌธ๋ฒ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
// while ๋ฌธ์ initialize, update ๊ณผ์ ์ด ๋ค์๊ณผ ๊ฐ๋ค๋ฉด,
initialize;
while (test) {
statement;
update;
}
// for ๋ฌธ์ initialize, update ๊ณผ์ ์ด ๋ค์๊ณผ ๊ฐ๋ค.
for (initialize; test; update) {
statement
}
/*
์์์ while ๋ฌธ์ผ๋ก ๊ตฌํํ ๋ฐ๋ณต๋ฌธ์ for ๋ฌธ ํ์์ผ๋ก
๋์ผํ ๊ธฐ๋ฅ์ ๊ตฌํํ ์์ ์ด๋ค.
*/
for (int count = 0; count < 10; count++) {
System.out.println(count);// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
}
/*
comma(,)๋ฅผ ์ฌ์ฉํ์ฌ multiple initialization๊ณผ update๋ ๊ฐ๋ฅํ๋ค.
*/
for (int i = 0, j = 10; i < 10; i++, j--) {
sum += i * j;
}
/*
for ๋ฌธ์ ๊ณ์(counting numbers)์๋ง ๊ตญํ๋์ด ์์ง ์๋ค.
์๋ฅผ ๋ค์ด, ์ฐ๊ฒฐ๋ฆฌ์คํธ(Linked List)์์ iterate๋ ๊ฐ๋ฅํ๋ค.
*/
for (Node n = listHead; n != null; n = n.nextNode()) {
process(n);
}
/*
for ๋ฌธ์ initialize, update, test ๊ตฌ๋ฌธ์ ๊ฐ๊ฐ ์๋ต ๊ฐ๋ฅํ๋ค.
*/
for (;;) {
// ์ด๋ ๊ฒ ์คํํ๋ฉด ํญ์ ์ฐธ์ด ๋์ด ๋ฌดํ ๋ฃจํ๊ฐ ๋๋ค.
}
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
- foreach statement
foreach ๋ฌธ์ Object๋ฅผ ๋ค๋ฃจ๋ ๋ฐ์ ์์ด ๋ถํ์ํ๊ฒ ํฌ๋ฐํ ๋ถ๋ถ๋ค์ ์ ๊ฑฐํ ๊ตฌ๋ฌธ์ด๋ค. ๊ทธ๋ฌ๋ foreach ๊ตฌ๋ฌธ์ด๋ผ๊ณ ํด์ each๋ผ๋ ํค์๋๊ฐ ์กด์ฌํ์ง๋ ์๋๋ค. ์ ๋ฐ๋ณต๋ฌธ๋ค์์ 10๊ฐ์ ์ซ์๋ฅผ ์ถ๋ ฅํ ๊ฒ๊ณผ ๋์ผํ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์๋ค. ๊ทธ๋ฌ๋ iterateํ ์ ์๋ ์ปฌ๋ ์ ์ด ํ์ํ๋ค๋ ๊ฒ์ด ์ฐจ์ด์ ์ด๋ค.
// These are the numbers we wnat to print
int[] primes = new int[] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
// This is the loop that prints them
for (int n : primes)
System.out.println(n);
(์์ค์ฝ๋ ์ถ์ฒ: O'Reilly, <Java in a Nutshell 7th edition>)
(์ถ์ฒ: https://soshace.com/guide-to-control-flow-statements-in-java/)
Author And Source
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(๐ฅ 4์ฃผ์ฐจ ๊ณผ์ : ์ ์ด๋ฌธ), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://velog.io/@glowing713/4์ฃผ์ฐจ-๊ณผ์ -์ ์ด๋ฌธ์ ์ ๊ท์: ์์์ ์ ๋ณด๊ฐ ์์์ URL์ ํฌํจ๋์ด ์์ผ๋ฉฐ ์ ์๊ถ์ ์์์ ์์ ์ ๋๋ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค