[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 2์ฅ ์์ฝ & ์ ๋ฆฌ
2์ฅ ์๋ฐ ๊ธฐ๋ณธ ํ๋ก๊ทธ๋๋ฐ
1. ์๋ฐ์ C++
ํด๋์ค๋ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ์ํ
C++์ main() ํจ์๊ฐ ํด๋์ค์ ๋ค์ด๊ฐ ์์ง ์๋ค. // 98% ๊ฐ์ฒด์งํฅ
์๋ฐ๋ C++๊ณผ ๋ค๋ฅด๊ฒ main() ๋ฉ์๋๋ ํด๋์ค ์์ ๋ค์ด๊ฐ ์๋ค.
์ฆ, ์๋ฐ๋ ๋ชจ๋ ์ฝ๋๊ฐ ํด๋์ค ์์ ๋ค์ด์๋ค. // 100% ๊ฐ์ฒด์งํฅ์ธ ์ด์
์๋ฐ๋ ๋ชจ๋ ๊ฒ์ ๊ฐ์ฒด๋ก ๋ณด๊ธฐ ๋๋ฌธ์ ์ง๋ฌธ OOO์ด ๊ฐ์ฒด์
๋๊น? ์ ๋ํ ๋๋ต์ ํญ์ O
์๋ฐ์์ ๋ฉค๋ฒ๋ณ์์ ๋ฉค๋ฒํจ์๋ผ๋ ์ฉ์ด ๋์ ํ๋์ ๋ฉ์๋๋ผ๊ณ ํ๋ค.
2. ์๋ฐ ๊ธฐ๋ณธ๊ตฌ์กฐ
public class Hello{} // Hello ๋ผ๋ ์ด๋ฆ์ ํด๋์ค ์ ์
ใด ์๋ฌด๋ ๋ค ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
{ // ํด๋์ค ์ ์ ์์
} // ํด๋์ค ์ ์ ๋
// ํ ์ค ์ฃผ์
/* */ ์ฌ๋ฌ ์ค ์ฃผ์
; // ๋ฌธ์ฅ์ ๋
๊ทธ๋ฌ๋ฏ๋ก ํ ๋ฌธ์ฅ์ด ๋ฐ๋์ ํ ์ค์ ์์ฑ๋ ํ์๋ ์์
์๋ฅผ ๋ค์ด, s = sum(i, 20);์ ๋ค์๊ณผ ๊ฐ์ด ์์ฑํด๋ ์ ์์ ์ธ ๋ฌธ์ฅ์ผ๋ก ์ธ์
System.out.println(); // ํ์ค ์ถ๋ ฅ ๋ฉ์๋, ํ์์ง์ ์ ์ง์ ํ์ง ์์
๋ฉ์ธ ๋ฉ์๋๋ public static void main(String[] args){} ํ์์ผ๋ก ์ด๋ค.
๋ฉ์ธ ๋ฉ์๋์์ ์๋ฐ ํ๋ก๊ทธ๋จ์ด ์์๋๋ค.
์๋ฐ์์ ๋ฉ์ธ ๋ฉ์๋๋ฅผ ํฌํจํ ๋ชจ๋ ์ฝ๋๋ ํด๋์ค ๋ฐ์ ์์ฑํ ์ ์๋ค.
3. ์๋ณ์
์๋ณ์ indentifier // C/C++๊ณผ ๋์ผ
์๋ณ์๋ ์ด๋ฆ์ด๋ค.
๋ฌธ๋ฒ
ํน์ ๋ฌธ์, ํญ, ๊ณต๋ฐฑ ์ฌ์ฉ๋ถ๊ฐ // ์์ธ์ ์ผ๋ก _์ $์ ์ฌ์ฉ๊ฐ๋ฅ
์ซ์๋ก ์์ ๋ถ๊ฐ // _์ $์ผ๋ก ์์ ๊ฐ๋ฅํ์ง๋ง ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ์ง๋ ์์
์์ฝ์ด(ํค์๋) ์ฌ์ฉ๋ถ๊ฐ
์ ๋์ฝ๋, ํ๊ธ ์ฌ์ฉ๊ฐ๋ฅ
๊ธธ์ด ์ ํ ์์
์์ด ๋์๋ฌธ์ ๊ตฌ๋ถ
๊ด์ต
๋ชฉ์ ์ ๋ถ๋ช
ํ๊ฒ ๋ํ๋ด๋ ์ด๋ฆ s vs sum
ํด๋์ค ์ด๋ฆ์ ๋๋ฌธ์๋ก ์์
ํ๋, ๋ฉ์๋ ์ด๋ฆ์ ์๋ฌธ์๋ก ์์
์ดํ ๊ฐ ๋จ์ด์ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ง ๋๋ฌธ์ // camel case๋ก ์์ฑํจ, _์ผ๋ก ์ฐ๊ฒฐํ๋ snake case๋ก ์์ฑํ์ง ์์
์์ ์ด๋ฆ์ ๋ชจ๋ ๋ฌธ์๋ฅผ ๋๋ฌธ์
4. ์๋ฃํ
์๋ฐ์์ ์๋ฃํ data type
๊ธฐ๋ณธํ์ 8๊ฐ // ๊ธฐ๋ณธ ํ์
boolean(1), char(2), byte(1), short(2), int(4), long(8), float(4), double(8)
C์ธ์ด์ ์๋ ๋ฐ์ดํฐ ํ์
์ boolean(1๋ฐ์ดํธ)๊ณผ byte(1๋ฐ์ดํธ)์ด๋ค.
char๋ C์์ 1๋ฐ์ดํธ, ์๋ฐ์์ 2๋ฐ์ดํธ์ด๋ค. // ์ ๋์ฝ๋ ํํ์ ์ํด 2๋ฐ์ดํธ(16๋นํธ)์ด๋ค.
์ฐธ์กฐํ์ 1๊ฐ // ๋ ํผ๋ฐ์ค ํ์
๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค
ํด๋์ค์ ๋ํ ๋ ํผ๋ฐ์ค
์ธํฐํ์ด์ค์ ๋ํ ๋ ํผ๋ฐ์ค
String์ ๊ธฐ๋ณธํ ๋ฐ์ดํฐ์ ํ์
์ด ์๋๊ณ , ํด๋์ค์ ์ด๋ฆ์ด๋ค. // ๊ฐ์ฒด์ด๋ค.
C/C++์์๋ ์์ด๋ 1๋ฐ์ดํธ๋ก ํ๊ธ์ 2๋ฐ์ดํธ๋ก ํํ๋๋ฏ๋ก, ํ๊ธ๊ณผ ์์ด๊ฐ ์์ฌ ์๋ ๋ฌธ์์ด์ด๋ ํ์ผ์ ๋ค๋ฃจ๋ ํ๋ก๊ทธ๋จ ์์ฑ์ ๋งค์ฐ ๊น๋ค๋กญ๋ค.
์๋ฐ๋ ํ๋ซํผ์ ๋ ๋ฆฝ์ ์ธ ์ธ์ด์ด๋ฏ๋ก CPU์ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ด๋ ์ด์์ฒด์ ์ ๋ฐ๋ผ ๋ฐ์ดํฐ๊ฐ ์ฐจ์งํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํฌ๊ธฐ๊ฐ ๋ฌ๋ผ์ง ์ ์๋ ๋ค๋ฅธ ์ธ์ด์ ๋ฌ๋ฆฌ ๋ฐ์ดํฐ ํ์ ์ ํฌ๊ธฐ๊ฐ ํญ์ ์ผ์ ํ๋ค.
5. ๋ฆฌํฐ๋ด
๋ฆฌํฐ๋ด // ํ๋ก๊ทธ๋จ์ ์ง์ ์์ฑํ ๊ฐ
์ ์ ๋ฆฌํฐ๋ด์ ๊ธฐ๋ณธ์ ์ผ๋ก intํ์ผ๋ก ์ปดํ์ผ
// 10์ง์, 0์ผ๋ก ์์ํ๋ 8์ง์, 0x๋ก ์์ํ๋ 16์ง์, 0b๋ก ์์ํ๋ 2์ง์
// long ํ์
๋ฆฌํฐ๋ด์ ์ซ์ ๋ค์ L ๋๋ l ํ๊ธฐ
์ค์ ๋ฆฌํฐ๋ด์ ๊ธฐ๋ณธ์ ์ผ๋ก doubleํ์ผ๋ก ์ปดํ์ผ
// ์์์ ํํ๋ ์ง์ ํํ
// float ํ์
๋ฆฌํฐ๋ด์ ์ซ์ ๋ค์ f ๋๋ Fํ๊ธฐ, double ํ์
๋ฆฌํฐ๋ด์ ์ซ์ ๋ค์ d ๋๋ D ํ๊ธฐ
๋ฌธ์ ๋ฆฌํฐ๋ด
// ์์ ๋ฐ์ดํ๋ก ๋๋ฌ์ ๋๋ \u ๋ค์ ์ ๋์ฝ๋ ex) ‘๊ธ’ ๋๋ \u0041
// ํน์ ๋ฌธ์ ๋ฆฌํฐ๋ด(์ด์ค์ผ์ดํ ์ํ์ค)์ \๋ก ์์
๋ฌธ์์ด ๋ฆฌํฐ๋ด
// ํฐ ๋ฐ์ดํ๋ก ๋๋ฌ์ ex) “๊ธ”
๋
ผ๋ฆฌ ๋ฆฌํฐ๋ด
// true, false 2๊ฐ๋ฟ
// boolean c = 1; C/C++์ ๋ฌ๋ฆฌ ์๋ฐ์์ ์ซ์๋ฅผ ์ฐธ, ๊ฑฐ์ง์ผ๋ก ์ฌ์ฉ ๋ถ๊ฐ
// while(true) { // ์๋ฐ์์ ๋ฌดํ ๋ฃจํ, while(1)๋ก ํ๋ฉด ์๋จ
}
null ๋ฆฌํฐ๋ด
// ์๋ฌด๊ฒ๋ ๊ฐ๋ฆฌํค์ง ์์ ๋ ์ฐธ์กฐํ ๋ณ์์ ๋์
ํ์ฌ ์ฌ์ฉ ex) String str = null;
_๋ ๋ฆฌํฐ๋ด์ ์ฌ์ฉ์ ๋ฐ๋์ ์ซ์์ฌ์ด์๋ง ๊ฐ๋ฅ
20,000์ ํํํ๊ณ ์ถ์ ๋, 20_000๋ฅผ ์ปดํ์ผ๋ฌ๋ _ ๋นผ๊ณ ์ฒ๋ฆฌํ์ฌ 20000์ผ๋ก ์ธ์
2__________5 ๋ ๊ฐ๋ฅ
var ํค์๋
๋ณ์ ํ์
์ ์ธ ์๋ต, ์ปดํ์ผ๋ฌ๊ฐ ๋ณ์ ํ์
์ถ๋ก
์ ์ธ ์ ์ด๊ธฐํ ํ์
์ง์ญ ๋ณ์ ์ ์ธ์๋ง ์ฌ์ฉ // ์ง์ญ๋ณ์๋? ๋ฉ์๋ ๋ด๋ถ์ ์ ์ธ๋ ๋ณ์
var price = 200; // intํ
6. ๋ณ์, ์์
๋ณ์
ํ๋ก๊ทธ๋จ ์คํ ๋์ ๋ฐ์ดํฐ๋ฅผ ์ผ์์ ์ผ๋ก ์ ์ฅํ๋ ๊ณต๊ฐ
int a = 3, b = 3, c= 3; // ์ฌ๋ฌ ๊ฐ์ ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ ์ฝค๋ง๋ก ๊ตฌ๋ถํ์ฌ ํ ์ค๋ก ์์ฑ ๊ฐ๋ฅ
์์
final ํค์๋๋ก ์ ์ธ
์ ์ธ ์ ์ด๊ธฐํ ํ์
์คํ ์ค ๊ฐ ๋ณ๊ฒฝ ๋ถ๊ฐ
final double PI = 3.141592;
7. ํ๋ณํ
์๋ํ์
๋ณํ(์์์ ํ์
๋ณํ) // ์์ ํ์
-> ํฐ ํ์
, ์ปดํ์ผ๋ฌ๊ฐ ํด์ค๋ค.
๊ฐ์ ํ์
๋ณํ(๋ช
์์ ํ์
๋ณํ) // ํฐ ํ์
-> ์์ ํ์
, ( ) ์์ ๋ณํํ ํ์
์ง์ ํ์ฌ ๊ฐ๋ฐ์ ํ๋ค, ๊ฐ ์์ค ์ฃผ์
์ฐ์ฐ์ ์์น์ ์ผ๋ก ๊ฐ์ ํ์
๋ผ๋ฆฌ๋ง ๊ฐ๋ฅ
ํฐ ํ์ ์ ๊ฐ์ ์์ ํ์ ์ ๊ฐ์ผ๋ก ๋ณํํด์ผ ํ ๋, ์ปดํ์ผ๋ฌ๋ ์๋ ํ์ ๋ณํ ๋์ ์ปดํ์ผ ์ค๋ฅ๋ฅผ ๋ฐ์
3.14*10 // double * int ์ด๋ฏ๋ก int์ธ 10์ด double์ธ 10.0์ผ๋ก ์๋ํ์ ๋ณํ
8. ํค์ ๋ ฅ(System.in, Scanner)
System.in // ํ์ค ์
๋ ฅ
ํค๋ณด๋๋ก๋ถํฐ ์ง์ ์ฝ๋ ์๋ฐ์ ํ์ค ์
๋ ฅ ์คํธ๋ฆผ
ํค ๊ฐ์ ๋ฐ์ดํธ ๋จ์๋ก ๋ฆฌํด // 1byte์ด๋ฏ๋ก ๋ฌธ์ ์๋
๊ทธ๋ฌ๋ฏ๋ก ์์ฉ ํ๋ก๊ทธ๋จ์ด ๋ฌธ์ ์ ๋ณด๋ก ๋ณํํด์ผ ํ๋ ๋ฌธ์ ์ ์ด ์์
Scanner ํด๋์ค
System.in์๊ฒ ํค๋ฅผ ์ฝ๊ฒ ํ๊ณ , ๋ค์ํ ํ์
์ผ๋ก ๋ณํํ์ฌ ๋ฆฌํด
import java.util.Scanner; // ๋ค๋ฅธ ํจํค์ง์ ์๋ ํด๋์ค ์ฌ์ฉํ๋ฏ๋ก import๋ฌธ ์ ์ธ ํ์, import๋ฌธ์ด ์์ผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ Scanner ํด๋์ค๊ฐ ์ด๋์ ์๋์ง ์ฐพ์ ์ ์์
Scanner scanner = new Scanner(System.in); // scanner ๊ฐ์ฒด ์์ฑ
์
๋ ฅ๋ ํค ๊ฐ์ ๊ณต๋ฐฑ๋ฌธ์๋ก ๊ตฌ๋ถ๋๋ ํ ํฐ ๋จ์๋ก ์ฝ์ // ‘\t’, ‘\f’, ‘\r’, ‘ ‘, ‘\n’
next() // ๋ค์ ํ ํฐ์ ๋ฌธ์์ด๋ก ๋ฆฌํด
nextLine() // \n์ ํฌํจํ๋ ํ ์ค์ ์ฝ์ด๋ค์ธ ๋ค, \n์ ์ ์ธํ ๋ฌธ์์ด ๋ฆฌํด, ์ํฐํค ์
๋ ฅ์ ๊ธฐ๋ค๋ฆฌ๋ ์ฉ๋๋ก ์ฌ์ฉํ ์ ์์
nextInt() // ๋ค์ ํ ํฐ์ intํ์ผ๋ก ๋ฆฌํด
close() // ์ฌ์ฉ ์ข
๋ฃ
hasNext() // ํ์ฌ ์ ๋ ฅ๋ ํ ํฐ์ด ์์ผ๋ฉด true๋ฅผ ๋ฆฌํด, ์๋๋ฉด ๋ฌดํ์ ๋๊ธฐ, ctrl+z ํค๊ฐ ์ ๋ ฅ๋๋ฉด ์ ๋ ฅ ๋์ด๋ฏ๋ก false ๋ฆฌํด
์์ฉ ํ๋ก๊ทธ๋จ์ scanner๋ฅผ ๋ซ๋ ์ฝ๋๊ฐ ์์ผ๋ฉด ์ปดํ์ผ์์ ๊ฒฝ๊ณ ๊ฐ ๋ฐ์ํ์ง๋ง, ์คํํ๋ ๋ฐ๋ ํน๋ณํ ๋ฌธ์ ๊ฐ ์๋ค. ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋๋ฉด ์๋์ผ๋ก ๋ซํ๋ค.
๊ฐ๋ฐ์๋ ์์ฉ ํ๋ก๊ทธ๋จ ์ ์ฒด์ Scanner ๊ฐ์ฒด๋ฅผ ํ๋๋ง ์์ฑํ๊ณ ๊ณต์ ํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. Scanner ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ ๊ฐ ์์ฑํด๋ ์ด๋ค์ ๋ชจ๋ ํ๋๋ฟ์ธ System.in์ ๊ณต์ ํ๋ฏ๋ก ํ ๊ตฐ๋ฐ์ close()๋ฅผ ํธ์ถํ์ฌ Scanner ๊ฐ์ฒด๋ฅผ ๋ซ์๋ฒ๋ฆฌ๋ฉด System.in๋ ๋ซํ๋ฒ๋ ค ์์ฉ ํ๋ก๊ทธ๋จ ๋ด ๋ค๋ฅธ Scanner ๊ฐ์ฒด์์ ํค ์
๋ ฅ์ ๋ฐ์ ์ ์๊ฒ ๋๋ค.
scanner.close();scanner = new Scanner(System.in);
9. ์๊ณผ ์ฐ์ฐ์
์ // ํผ์ฐ์ฐ์์ ์ฐ์ฐ์๋ก ์ด๋ฃจ์ด์ง
์ฐ์ฐ // ์ฃผ์ด์ง ์์ ๊ณ์ฐํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ์ป์ด๋ด๋ ๊ณผ์
์ฐ์ฐ์์ ์ฐ์ ์์๋ ์์์ ์ผ๋ก ์๊ฐํ๋ฉด ๋จ
๋จํญ, ์ดํญ, ์ผํญ ์ฐ์ฐ์์
๋์
์ฐ์ฐ์๊ฐ ๊ฐ์ฅ ๋์ค
๊ดํธ๋ ์ต์ฐ์ ์์
์ผ๋ฐ์ ์ผ๋ก ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฐ์ฐ
์ฐ์ฐ์ ์ฐ์ ์์๊ฐ ๋์ผํ๋ฉด ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฒ๋ฆฌํ์ง๋ง, ์์ธ์ ์ผ๋ก ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ์ฒ๋ฆฌํ๋ ์ฐ์ฐ์๋ ์์
์ฐ์ ์ฐ์ฐ์
์ค์น ์ฐ์ฐ(+, -, *, /, %), %๋ ๋๋จธ์ง ์ฐ์ฐ์
์๋ฐ์์๋ ๋ฌธ์์ด๊ณผ ๊ธฐ๋ณธ ํ์
์ + ์ฐ์ฐ์ด ์คํ๋๋ฉด, ๊ธฐ๋ณธ ํ์
์ ๊ฐ์ด ๋ฌธ์์ด๋ก ๋ฐ๋๊ณ , ๋ ๋ฌธ์์ด์ด ์ฐ๊ฒฐ๋ ์๋ก์ด ๋ฌธ์์ด์ด ์์ฑ๋จ
์ฆ๊ฐ ์ฐ์ฐ์
1 ์ฆ๊ฐ ๋๋ ๊ฐ์์ํค๋ ์ฐ์ฐ์
์ ์, ํ์ ์ฐ์ฐ์์ ๋ฐ๋ผ ์ฐ์ฐ ์์๊ฐ ๋ฌ๋ผ์ง๋ค. // ++a;๋ +1 ๋จผ์ , a++;์ +1 ๋์ค
๋์
์ฐ์ฐ์ // ์ค๋ฅธ์ชฝ ๊ฐ์ ์ผ์ชฝ์ ๋์
๋ณตํฉ ๋์
์ฐ์ฐ์ // ์ค๋ฅธ์ชฝ์ ๋์
์ฐ์ฐ์๊ฐ ์๋ค. ex) +=
๋์
์ฐ์ฐ์, ์ฆ๊ฐ์ฐ์ฐ์์ ์ฌ์ฉ -> ํท๊ฐ๋ฆผ // ๋ฐ๋์ ๊ทธ๋ฆผ์ ๊ทธ๋ ค์ ์๊ฐํด๋ณด๊ธฐ
๋
ผ๋ฆฌ ์ฐ์ฐ์
! not // true์ด๋ฉด false
&& and // ๋๋ค true์ฌ์ผ true
|| or // ๋ ์ค ํ๋๋ง true์ฌ๋ true
^ xor // ์๋ก ๋ฌ๋ผ์ผ true
๋น๊ต ์ฐ์ฐ์๋ ์ขํญ์ ๊ธฐ์ค์ผ๋ก ์ฝ์
๋น๊ต ์ฐ์ฐ์์ ๋
ผ๋ฆฌ ์ฐ์ฐ์์ ๋ณตํฉ์ฌ๋ก์์ ์ํ์ ์ผ๋ก ํํํ๋ฉด ์ปดํ์ผ ์๋ฌ // ๋ฌธ๋ฒ ์ค๋ฅ
์กฐ๊ฑด ์ฐ์ฐ์ // ํจ์ถ์ ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด ๋ ์ข์ ์ฝ๋
๋นํธ ์ฐ์ฐ์ // ๋นํธ ๋จ์๋ก ์ฐ์ฐ, ๋นํธ ๋
ผ๋ฆฌ ์ฐ์ฐ๊ณผ ๋นํธ ์ํํธ ์ฐ์ฐ์ด ์์
๋นํธ ๋
ผ๋ฆฌ์ฐ์ฐ์ &, |, ~, ^ // ์ฐ์ฐ์ 1๊ฐ๋ง ์
๋นํธ ์ํํธ ์ฐ์ฐ์ >>, >>>, << // a >> 2 ์ค๋ฅธ์ชฝ์ผ๋ก 2๊ฐ ์ํํธ ์ฐ์ฐ์ด๋ฉด ์ค๋ฅธ์ชฝ 2๊ฐ์ ๋นํธ๋ฅผ ์์ค๋ค.
๋นํธ ์ํํธ ์ฐ์ฐ์ ํผ์ฐ์ฐ์๋ byte, short, int, long, char ํ์ ๋ง ๊ฐ๋ฅํ๊ณ , float, double, boolean์ ์ฌ์ฉํ ์ ์์
<< ์ฐ์ฐ์์ ๊ฒฝ์ฐ ์์(์ต์์ ๋นํธ๊ฐ 1)๋ฅผ ์ํํธํ์ฌ ์ต์์ ๋นํธ๊ฐ 0์ธ ์์๊ฐ ๋๋ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ์ ์์ผ๋ฏ๋ก ์ฃผ์
byte, short, char ํ์ ์ ๋ํด์๋ ์ํํธ ์ intํ์ ์ผ๋ก ๋ณํ๋์ด ์ฐ์ฐ์ด ์ผ์ด๋๋ฏ๋ก ์ํ์ง ์๋ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์์
10. ์กฐ๊ฑด๋ฌธ
๋จ์ if๋ฌธ // if(์กฐ๊ฑด์) {์กฐ๊ฑด์์ด ์ฐธ์ด๋ฉด ์คํ๋ ๋ฌธ์ฅ}
if-else๋ฌธ // if() {} else {}
๋ค์ค if-else๋ฌธ // if() {} else if() {} else {}
์ค์ฒฉ if-else๋ฌธ // if() { if() {} else {} } else {}
if๋ฌธ์์ ๋ธ๋ก{}์ ์ง์ ํ์ง ์์ผ๋ฉด ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฒ๊ณผ ๊ด๋ จ๋์ด ์คํ๋จ
๋ค์ค if-else๋ฌธ์ switch๋ฌธ์ผ๋ก ๋ฐ๊พธ๋ ๊ฒ์ด ์ข์ // ๋ ํท๊ฐ๋ฆผ
switch๋ฌธ //
switch(์){
case ๊ฐ1:
์คํ๋ฌธ์ฅ1;
break;
case ๊ฐ2:
์คํ๋ฌธ์ฅ2;
break;
…
default:
์คํ๋ฌธ์ฅn;
}
default๋ฌธ์ ์๋ต ๊ฐ๋ฅํ๋ฉฐ, ์คํ ๋ฌธ์ฅ์ { }๋ก ๋๋ฌ์ธ์ง ์๋๋ค.
case ๊ฐ์ ํ๋ฒ๋ง ๊ฒ์ฌํ๋ฏ๋ก break;๋ฌธ์ด ์๋ค๋ฉด break;๋ฌธ์ ๋ง๋ ๋๊น์ง ๋ค์ ์คํ๋ฌธ์ฅ๋ค์ ๊ณ์ ์คํํ๋ค.
case๋ฌธ์ ๊ฐ์๋ ๋ณ์๋ ์์ ์ฌ์ฉํ ์ ์์ // case a: case a > 3:
case๋ฌธ์ ๊ฐ์ ์ค์ ๋ฆฌํฐ๋ด์ ํ์ฉ๋์ง ์์ // ์ ์, ๋ฌธ์, ๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ง ๊ฐ๋ฅ
byte, short, int, char, String // ๊ฐ๋ฅ
long, float, double // ๋ถ๊ฐ๋ฅ, long์ ์ ์ ๋ฆฌํฐ๋ด ์ค์์ ์ ์ผํ๊ฒ ์๋๋ ํ์
'1. Java ์๋ฐ > 1_0. ์ฑ , ๊ฐ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 1์ฅ 29์ชฝ ์ฒดํฌ ํ์_์ ๋ต (0) | 2022.05.18 |
---|---|
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 3์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 1์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 0์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |
[์๋ฐํ๋ก๊ทธ๋๋ฐ1] 12์ฃผ์ฐจ ๊ต์ฌ_๋ด์ฉ์ ๋ฆฌ (0) | 2022.05.18 |