-
์ ์ด๋ฌธ
์๋ฐ ํ๋ก๊ทธ๋จ์ ์ผ๋ฐ์ ์ผ๋ก ์์์ ์๋๋ก ์คํํ๋ ํ๋ฆ์ ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋ฐฉํฅ์ผ๋ก ๋ฐ๊ฟ ์ ์๋๋ก ํ๋ ๊ฒ
- ์กฐ๊ฑด(์ ํ)๋ฌธ - if๋ฌธ, switch๋ฌธ
- ๋ฐ๋ณต๋ฌธ - for๋ฌธ, while๋ฌธ, do-while๋ฌธ
01 if๋ฌธ
๊ธฐ๋ณธ ๊ตฌ์กฐ
if (์กฐ๊ฑด๋ฌธ) { <์ํํ ๋ฌธ์ฅ1>; <์ํํ ๋ฌธ์ฅ2>; ... } else { <์ํํ ๋ฌธ์ฅA>; <์ํํ ๋ฌธ์ฅB>; ... }
์กฐ๊ฑด๋ฌธ์ ํ ์คํธํด์ ์ฐธ์ด๋ฉด if ๋ฌธ์ ์ํ ๋ฌธ์ฅ๋ค(์ํํ ๋ฌธ์ฅ1, ์ํํ ๋ฌธ์ฅ2)์ ์ํ
๊ฑฐ์ง์ด๋ฉด else ๋ฌธ์ ์ํ ๋ฌธ์ฅ๋ค(์ํํ ๋ฌธ์ฅA, ์ํํ ๋ฌธ์ฅB)์ ์ํ
๋น๊ต์ฐ์ฐ์
๋น๊ต ์ฐ์ฐ์ ์ค๋ช
x < y x๊ฐ y๋ณด๋ค ์๋ค x > y x๊ฐ y๋ณด๋ค ํฌ๋ค x == y x์ y๊ฐ ๊ฐ๋ค x != y x์ y๊ฐ ๊ฐ์ง ์๋ค x >= y x๊ฐ y๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค x <= y x๊ฐ y๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค ์กฐ๊ฑด์ฐ์ฐ์
์ฐ์ฐ์ ์ค๋ช
x && y x์ y ๋ชจ๋ ์ฐธ์ด์ด์ผ ์ฐธ์ด๋ค(and) x !x x๊ฐ ๊ฑฐ์ง์ด๋ฉด ์ฐธ์ด๋ค(not) contains ๋ฉ์๋
- list์ ํด๋น item์ด ์๋์ง ์กฐ์ฌ
- list์ด๋ฆ.contsains(item๋ช ) ํํ๋ก ์ฌ์ฉ
else if๋ฌธ
if (์กฐ๊ฑด๋ฌธ) { <์ํํ ๋ฌธ์ฅ1> <์ํํ ๋ฌธ์ฅ2> ... }else if (์กฐ๊ฑด๋ฌธ) { <์ํํ ๋ฌธ์ฅ1> <์ํํ ๋ฌธ์ฅ2> ... } else { <์ํํ ๋ฌธ์ฅ1> <์ํํ ๋ฌธ์ฅ2> ... }
02 switch/case๋ฌธ
๊ธฐ๋ณธ๊ตฌ์กฐ
switch(์ ๋ ฅ๋ณ์) { case ์ ๋ ฅ๊ฐ1: ์ํ๋ฌธ break; case ์ ๋ ฅ๊ฐ2: ์ํ๋ฌธ break; ... default: ์ํ๋ฌธ break; }
- if๋ฌธ๊ณผ ๋ฌ๋ฆฌ ์กฐ๊ฑด์์ ๋ฐ๋ผ ์ํ๋ฌธ์ ์ํ์ฌ๋ถ๊ฐ ๊ฒฐ์ ๋๋ ๊ฒ์ด ์๋๋ผ, ์ ๋ ฅ๋ณ์์ ๊ฐ๊ณผ ์ผ์นํ๋ case ์ ๋ ฅ๊ฐ์ด ์๋ค๋ฉด ํด๋น case๋ฌธ์ ์ํ ๋ฌธ์ฅ๋ค์ด ์คํ
- ์ ๋ ฅ ๋ณ์์ ์๋ฃํ์ byte, short, char, int, enum, String ํ์ ์ ๋ณ์๋ง ๊ฐ๋ฅ
- break๋ ํด๋น case๋ฌธ์ ์คํํ ๋ค ๋ค์ case๋ฅผ ์คํํ์ง ์๊ณ switch๋ฌธ์ ๋น ์ ธ๋๊ฐ๊ธฐ ์ํจ
- break๋ฌธ์ด ์์ผ๋ฉด ๋ค์ case๋ฌธ์ ์ํ ๋ฌธ์ฅ๋ค์ด ์คํ๋จ
- case๊ฐ ํ๋๋ ์คํ๋์ง ์์ผ๋ฉด default๋ฌธ์ฅ์ด ์คํ๋จ
- ์๋ฐ 12๋ฒ์ ์ดํ ๊ฒฐ๊ณผ๊ฐ์ ํ์ดํ ์ฐ์ฐ์ (->)๋ก ๋ฐํํ ์ ์๊ณ (case "c" -> 2; ) multiple case๋ฅผ ์ง์ (์ด์ ์๋ case "a" ์ ๊ฐ์ด ํ๋์ case๋ง ์ง์ -> case "a","b")
- yield ์์ฝ์ด ์ฌ์ฉ ๊ฐ๋ฅ
03 while๋ฌธ
while (์กฐ๊ฑด๋ฌธ) { <์ํํ ๋ฌธ์ฅ1>; <์ํํ ๋ฌธ์ฅ2>; <์ํํ ๋ฌธ์ฅ3>; ... }
- ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ธ ๋์ while์์ ๋ฌธ์ฅ์ ์ํ
๋ฌดํ๋ฃจํ
- ์กฐ๊ฑด๋ฌธ ์์ true๋ก
break
- while๋ฌธ์ ๊ฐ์ ๋ก ๋ฉ์ถฐ์ผ ํ ๋ ์ฌ์ฉ
continue
- ๋ค์ ์ํ๋ฌธ์ ์คํํ์ง ์๊ณ while ๋ฌธ์ ๋งจ ์ฒ์, ์กฐ๊ฑด๋ฌธ์ผ๋ก ๋ค์ ๋์๊ฐ๊ฒ ํ๊ณ ์ถ์ ๋
int a = 0; while (a < 10) { a++; if (a % 2 == 0) { continue; // ์ง์์ธ ๊ฒฝ์ฐ ์ถ๋ ฅ์ ํ์ง ์๊ณ ์กฐ๊ฑด๋ฌธ์ผ๋ก ๋์๊ฐ๋ค. } System.out.println(a); // ํ์๋ง ์ถ๋ ฅ๋๋ค. }
do-while๋ฌธ
do{ ์คํ๋ฌธ }while(์กฐ๊ฑด์)
- while๋ฌธ๊ณผ ๋ฌ๋ฆฌ ๋ธ๋ก ๋ด๋ถ์ ์คํ๋ฌธ์ ์ฐ์ ์คํ์ํค๊ณ ์กฐ๊ฑด์์ ๋ฐ๋ผ ์คํ์ ๊ณ์ํ ์ง ๊ฒฐ์
04 for๋ฌธ
๊ธฐ๋ณธ ๊ตฌ์กฐ
for (์ด๊ธฐ์น; ์กฐ๊ฑด๋ฌธ; ์ฆ๊ฐ์น) { ... }
- continue ๋์ผํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅ (for๋ฌธ์ ์ฒ์์ผ๋ก ๋์๊ฐ)
- break ๋์ผํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅ(for๋ฌธ์ ๋ฒ์ด๋จ)
์ด์ค for๋ฌธ
๊ตฌ๊ตฌ๋จ ์ถ๋ ฅ ์์
- System.out.print - ์ค๋ฐ๊ฟ ๋ฌธ์๋ฅผ ํฌํจํ์ง ์๊ณ ์ถ๋ ฅ
- System.out.println - ๋ง์ง๋ง์ ์ค๋ฐ๊ฟ ๋ฌธ์๋ฅผ ํฌํจํ์ฌ ์ถ๋ ฅ
05 for each๋ฌธ
๊ธฐ๋ณธ ๊ตฌ์กฐ
for (type ๋ณ์๋ช : iterate) { body-of-loop }
- iterate : ๋ฃจํ๋ฅผ ๋๋ฆด ๊ฐ์ฒด, iterate ๊ฐ์ฒด์์ ํ ๊ฐ์ฉ ์์ฐจ์ ์ผ๋ก ๋ณ์๋ช ์ ๋์ ๋์ด for ๋ฌธ์ด ์ํ๋จ
- iterate์ ์ฌ์ฉํ ์ ์๋ ์๋ฃํ์ ๋ฃจํ๋ฅผ ๋๋ฆด ์ ์๋ ์๋ฃํ(๋ฐฐ์ด์ด๋ ArrayList ๋ฑ)๋ง ๊ฐ๋ฅ
- ๋ณ์๋ช ์ type(์๋ฃํ)์ iterate ๊ฐ์ฒด์ ํฌํจ๋ ์๋ฃํ๊ณผ ์ผ์นํด์ผ ํจ
์์
import java.util.ArrayList; import java.util.Arrays; public class Sample { public static void main(String[] args) { ArrayList<String> numbers = new ArrayList<>(Arrays.asList("one", "two", "three")); for (String number : numbers) { System.out.println(number); } } }
- ๋ฃจํ๋ฅผ ๋๋ฆด ๊ฐ์ฒด → ArrayList์ธ numbers (iterate)
- string์ ์์๋ก ๊ฐ์ง ArrayList๋ฅผ string์ธ number ๋ณ์์ ์์ฐจ์ ์ผ๋ก ๋์
- ๋ฐ๋ก ๋ฐ๋ณต ํ์๋ฅผ ๋ถ์ฌํ ์ ์๊ณ , ํ ๋จ๊ณ์ฉ ์์ฐจ์ ์ผ๋ก๋ง ์ฌ์ฉ ๊ฐ๋ฅ
์ธ์ฉ
์ ํ ํฌ ์๋ฐ
์ด ์ฑ ์ ํ๋ก๊ทธ๋๋จธ๋ฅผ ๊ฟ๊พธ๋ฉฐ ์๋ฐ ์ ๋ฌธ์๋ฅผ ์ฐพ๋ ์ฌ๋๋ค์ ์ํ ์ฑ ์ด๋ค. ์ด ์ฑ ์ ์๋ฐ์ ๋ฌธ๋ฒ์ ํ๋ํ๋ ์์ธํ ์๊ธฐ ๋ณด๋จ ์ด๋ ต๊ฒ ๋๊ปด์ง๋ ์๋ฐ๋ฅผ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ์ดํดํ๋ ๊ฒ์ ๋ชฉํ…
wikidocs.net
'๐ญ Study > : Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋๊ธ