๐ Book19 4-2์ฅ ๋ฐ๋ณต๋ฌธ 1. for๋ฌธ ๐ก๋ฐ๋ณต ํ์๋ฅผ ์๊ณ ์์ ๋ ์ฃผ๋ก ์ฌ์ฉ for๋ฌธ์ ๊ตฌ์กฐ์ ์ํ ์์ - ์ด๊ธฐํ - ์กฐ๊ฑด์ - ์ฆ๊ฐ์ - ๋ธ๋ก {} for(์ด๊ธฐํ; ์กฐ๊ฑด์; ์ฆ๊ฐ์;) { ... // ์กฐ๊ฑด์์ด ์ฐธ์ผ ๋ ์ํ๋๋ค. } ์ํ ์์ 1. ์ด๊ธฐํ 2. ์กฐ๊ฑด์ 3. ์ํ๋ ๋ฌธ์ฅ 4. ์ฆ๊ฐ์ ์ด๊ธฐํ ๐ก ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉ๋ ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ ๊ณผ์ , ์ฒ์์ ๋จ ํ๋ฒ ์ํ๋๋ค. for(int i = 0; i ,(์ฝค๋ง)๋ฅผ ๊ตฌ๋ถ์๋ก ๋ณ์ ์ด๊ธฐํ ์กฐ๊ฑด์ ๐ก ์กฐ๊ฑด์์ ๊ฐ์ด ์ฐธ(true)์ด๋ฉด ๋ฐ๋ณต ๊ณ์ ์งํํ๊ณ ๊ฑฐ์ง(false)์ด๋ฉด ๋ฐ๋ณต์ ์ค๋จํ๊ณ for๋ฌธ์์ ๋ฒ์ด๋๋ค. ⇒ ์กฐ๊ฑด์์ด ‘์ฐธ์ธ ๋์’ ๋ฐ.. 2023. 3. 29. 4-1์ฅ ์กฐ๊ฑด๋ฌธ 1. if๋ฌธ ๐ก๋ง์ผ(if) ์กฐ๊ฑด์์ด ์ฐธ(true)์ด๋ฉด ๊ดํธ { } ์์ ๋ฌธ์ฅ๋ค์ ์ํํ๋ผ if (์กฐ๊ฑด์) { // ์กฐ๊ฑด์์ด ์ฐธ(true)์ผ ๋ ์ํ } ์กฐ๊ฑด์ ์ผ๋ฐ์ ์ผ๋ก ๋น๊ต ์ฐ์ฐ์์ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ก ๊ตฌ์ฑ๋๋ค. 90 60) { System.out.println ("ํฉ๊ฒฉ์ ๋๋ค."); } ⇒ ์๋ก์ด ๋ฌธ์ฅ๋ค์ด ์ถ๊ฐ๋์์ ๋ ๊ดํธ{}๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ์๊ธฐ ์ฝ๊ธฐ ๋๋ฌธ์ด๋ค. 2. if-else๋ฌธ if (์กฐ๊ฑด์) { // ์กฐ๊ฑด์์ด ์ฐธ(true)์ผ ๋ ์ํ } else { // ์กฐ๊ฑด์์ด ๊ฑฐ์ง(false)์ผ ๋ ์ํ } 2๊ฐ์ if๋ฌธ vs if-else๋ฌธ if (input == 0) { ... } if (input != 0) { ... } 2๊ฐ์ ์กฐ๊ฑด์ if (input == 0) { ... } else { ... } 1.. 2023. 3. 29. 3-6์ฅ ๊ธฐํ ์ฐ์ฐ์ 1. ์กฐ๊ฑด ์ฐ์ฐ์ ?: ๐ก ์กฐ๊ฑด์, ์ 1, ์2 ๋ชจ๋ ์ธ ๊ฐ์ ํผ์ฐ์ฐ์๋ฅผ ํ์๋ก ํ๋ ์ผํญ ์ฐ์ฐ์ ์กฐ๊ฑด์์ ํ๊ฐ ๊ฒฐ๊ณผ๊ฐ true์ด๋ฉด ์1, false์ด๋ฉด ์ 2๊ฐ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ๋๋ค. ์์ ์ค์ฒฉ๋ ์กฐ๊ฑด์ฐ์ฐ์ ์กฐ๊ฑด ์ฐ์ฐ์์ ๊ฒฐํฉ๊ท์น ์ค๋ฅธ์ชฝ → ์ผ์ชฝ ex) x = 3์ธ ๊ฒฝ์ฐ result = x > 0 ? 1 : (x == 0 ? 0 : -1) -> result = x > 0 ? 1 : (3 == 0 ? 0 : -1) -> result = x > 0 ? 1 : (false ? 0 : -1) -> result = x > 0 ? 1 : -1 -> result = 3 > 0 ? 1 : -1 -> result = true ? 1 : -1 -> result = 1 ์ฐ์ ๋ณํ ์ 1๊ณผ ์ 2, ์ด ๋ ํผ์ฐ์ฐ์์ ํ์ ์ด .. 2023. 3. 14. 3-5์ฅ ๋ ผ๋ฆฌ ์ฐ์ฐ์ ๐ก ๋ ์ด์์ ์กฐ๊ฑด์ ‘๊ทธ๋ฆฌ๊ณ (AND)’๋ ‘๋๋(OR)’์ผ๋ก ์ฐ๊ฒฐํ์ฌ ํ๋์ ์์ผ๋ก ํํํ ์ ์๊ฒ ํด ์ค๋ค. 1. ๋ ผ๋ฆฌ ์ฐ์ฐ์ && || ! &&: ํผ์ฐ์ฐ์ ์์ชฝ ๋ชจ๋ true์ด์ด์ผ true๋ก ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค. ||: ํผ์ฐ์ฐ์ ์ค ์ด๋ ํ์ชฝ์ true์ด๋ฉด true๋ก ๊ฒฐ๊ณผ๋ก ์ป๋๋ค. ์์ 1. x๋ 10๋ณด๋ค ํฌ๊ณ , 20๋ณด๋ค ์๋ค. 10 32 ์๋ฆฌ ์.. 2023. 3. 14. 3-4์ฅ ๋น๊ต ์ฐ์ฐ์ 1. ๋์ ๋น๊ต ์ฐ์ฐ์ ≤ ≥ ๐ก ๊ฐ์ ํฌ๊ธฐ๋ฅผ ๋น๊ต ๊ธฐ๋ณธํ ์ค์์ boolean์ ์ ์ธํ ๋๋จธ์ง ์๋ฃํ์ ๋ชจ๋ ์ฌ์ฉ ๊ฐ๋ฅ ์ฐธ์กฐํ์๋ ์ฌ์ฉํ ์ ์๋ค. 2. ๋ฑ๊ฐ ๋น๊ต ์ฐ์ฐ์ == ≠ ๐ก ๊ฐ์ด ๊ฐ์ ์ง ๋๋ ๋ค๋ฅธ ์ง๋ฅผ ๋น๊ต ๊ธฐ๋ณธํ, ์ฐธ์กฐํ ๋ชจ๋ ์ฌ์ฉ ๊ฐ๋ฅ - ๊ธฐ๋ณธํ: ๋ณ์์ ์ ์ฅ๋์ด ์๋ ๊ฐ ๋น๊ต - ์ฐธ์กฐํ: ๋ ๊ฐ์ ์ฐธ์กฐ ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋์ง ๋น๊ต (์ฐธ์กฐํ์ ๊ฒฝ์ฐ ๊ฐ์ฒด์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๊ธฐ ๋๋ฌธ) System.out.println(10 == 10.0f); // true ๋น๊ต ์ฐ์ฐ์๋ ์ดํญ ์ฐ์ฐ์์ด๋ฏ๋ก ์ฐ์ฐ์ ์ํํ๊ธฐ ์ ์ ํ๋ณํ์ ํ๋ค. 10 == 10.0f → 10.0f == 10.0f → true ์ค์ํ ์ค์ฐจ ํ์ธ float f = 0.1f; double d = 0.1; Syst.. 2023. 3. 14. 3-3์ฅ ์ฐ์ ์ฐ์ฐ์ ์ฌ์น ์ฐ์ฐ์: +, -, *, / ๋๋จธ์ง ์ฐ์ฐ์: % ์ฐ์ ์์: *, /, % > +, - 1. ์ฌ์น ์ฐ์ฐ์ + - * / ์ฃผ์ํด์ผ ๋๋ ๋ถ๋ถ 1. intํ์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ์๋ ์์์ ์ ๋ฒ๋ฆฐ๋ค. int a = 10; int b = 4; System.out.println(a / b); // 2 2. ํผ์ฐ์ฐ์๊ฐ ์ ์ํ์ธ ๊ฒฝ์ฐ, ๋๋๋ ์๋ก 0์ ์ฌ์ฉํ ์ ์๋ค. ๋ถ๋ ์์์ ๊ฐ์ธ 0.0f, 0.0d๋ก ๋๋๋ ๊ฒ์ ๊ฐ๋ฅํ์ง๋ง ๊ทธ ๊ฒฐ๊ณผ๋ ๋ฌดํ๋์ด๋ค. System.out.println(3 / 0); // ์คํํ๋ฉด, ์ค๋ฅ(ArithmeticException) ๋ฐ์ System.out.println(3 / 0.0); // Infinity๊ฐ ์ถ๋ ฅ๋จ 3. byte ์ฐ์ฐ ์๋ฌ ๋ฐ์ byte a = 10; byte b = .. 2023. 3. 14. ์ด์ 1 2 3 4 ๋ค์