์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
Tags
- ubuntu
- ์๋ฐ ๊ฐ๋
- ํ์ด์ฌ
- java
- OS
- ์ฐ๋ถํฌ
- ๋ฌ์คํธ ์์
- ๋ฌ์คํธ
- ์๋ฐ
- Reversing
- ์๊ณ ๋ฆฌ์ฆ
- ํ์ด์ฌ ์ฑ๋ฆฐ์ง
- data communication
- C
- Python
- ์ด์์ฒด์
- ํ์ด์ฌ ์ฒผ๋ฆฐ์ง
- ํ์ด์ฌ ์๊ณ ๋ฆฌ์ฆ
- Python challenge
- ์ค๋ผํด
- Rust
- ์ค๋ผํดDB
- ์๋ฐ ๊ธฐ์ด
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- ๋ฐ์ดํฐ ํต์
- ๋ฌ์คํธ ํ๋ก๊ทธ๋๋ฐ ๊ณต์ ๊ฐ์ด๋
- ๋ฐฑ์ค ๋ฌ์คํธ
- Database
- Operating System
- ๋ฐฑ์ค
Archives
- Today
- Total
IT’s Portfolio
[Java] Lecture - Day 4 ๋ณธ๋ฌธ
728x90
๋ฐ์ํ
๐ฅ Basic Java - Day 4
๐๐ป [Chapter 03] ๋ฐ๋ณต๋ฌธ๊ณผ ๋ฐฐ์ด, ๊ทธ๋ฆฌ๊ณ ์์ธ ์ฒ๋ฆฌ
๋ฐ๋ณต๋ฌธ
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
.. ์์
๋ฌธ ..
}
- for : ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ๋ฐ๋ณต๋ฌธ
while(์กฐ๊ฑด์) {
.. ์์
๋ฌธ ..
}
- while
- ์กฐ๊ฑด์์ด '์ฐธ'์ธ ๋์ ๋ฐ๋ณต ์คํ
do {
.. ์์
๋ฌธ ..
} while(์กฐ๊ฑด์);
- do-while
- ์กฐ๊ฑด์์ด '์ฐธ'์ธ ๋์ ๋ฐ๋ณต ์คํ
- ์์ ๋ฌธ์ ํ ๋ฒ ๋ฐ๋์ ์คํ
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
...
}
...
}
- ์ค์ฒฉ ๋ฐ๋ณต
- ๋ฐ๋ณต๋ฌธ์ด ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ์ ๋ดํฌํ๋ ๊ตฌ์กฐ
continue ๋ฌธ
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
...
continue;
...
}
while(์กฐ๊ฑด์) {
...
continue;
...
}
do {
...
continue;
...
} while(์กฐ๊ฑด์);
- ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ ๋๊ฐ์ง ์๊ณ , ๋ค์ ๋ฐ๋ณต์ผ๋ก ์ ์ด ๋ณ๊ฒฝ
- ๋ฐ๋ณต๋ฌธ์์ continue ๋ฌธ์ ์ํ ๋ถ๊ธฐ
break ๋ฌธ
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
...
break;
...
}
...
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
) {
while(์กฐ๊ฑด์) {
...
break;
...
}
...
}
...
- ๋ฐ๋ณต๋ฌธ ํ๋๋ฅผ ์ฆ์ ๋ฒ์ด๊ฐ ๋ ์ฌ์ฉ
- ํ๋์ ๋ฐ๋ณต๋ฌธ๋ง ๋ฒ์ด๋จ
- ์ค์ฒฉ ๋ฐ๋ณต์ ๊ฒฝ์ฐ ์์ชฝ ๋ฐ๋ณต๋ฌธ์ break ๋ฌธ์ด ์คํ๋๋ฉด ์์ชฝ ๋ฐ๋ณต๋ฌธ๋ง ๋ฒ์ด๋จ
์๋ฐ ๋ฐฐ์ด
- Array
- ์ธ๋ฑ์ค์ ์ธ๋ฑ์ค์ ๋์ํ๋ ๋ฐ์ดํฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์๋ฃ ๊ตฌ์กฐ
- ๋ฐฐ์ด์ ์ด์ฉํ๋ฉด ํ ๋ฒ์ ๋ง์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ธ ๊ฐ๋ฅ
- ๋ฐฐ์ด์ ๊ฐ์ ํ์
์ ๋ฐ์ดํฐ๋ค์ด ์์ฐจ์ ์ผ๋ก ์ ์ฅ๋๋ ๊ณต๊ฐ
- ์์ ๋ฐ์ดํฐ๋ค์ด ์์ฐจ์ ์ผ๋ก ์ ์ฅ๋จ
- ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํ์ฌ ์์ ๋ฐ์ดํฐ ์ ๊ทผ
- ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ์ฌ ์ฒ๋ฆฌํ๊ธฐ์ ์ ํฉํ ์๋ฃ ๊ตฌ์กฐ
- ๋ฐฐ์ด ์ธ๋ฑ์ค
- 0๋ถํฐ ์์
- ์ธ๋ฑ์ค๋ ๋ฐฐ์ด์ ์์ ์์น์์๋ถํฐ ๋ฐ์ดํฐ๊ฐ ์๋ ์๋ ์์น
- ์ธ๋ฑ์ค์ ์ธ๋ฑ์ค์ ๋์ํ๋ ๋ฐ์ดํฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์๋ฃ ๊ตฌ์กฐ
int i[] = new int[10];
- ๋ฐฐ์ด ์ ์ธ
int i[] = new int[5];
int myI[] = i;
- ๋ ํผ๋ฐ์ค ์นํ์ผ๋ก ๋ ๋ ํผ๋ฐ์ค๊ฐ ํ๋์ ๋ฐฐ์ด ๊ณต์
๋ฐฐ์ด์ ํฌ๊ธฐ, length ํ๋
int i[] = new int[5];
int size = i.length;
- ์๋ฐ์ ๋ฐฐ์ด์ ๊ฐ์ฒด๋ก ์ฒ๋ฆฌ
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๋ฐฐ์ญ ๊ฐ์ฒด์ length ํ๋์ ์ ์ฅ
- ํจ์ ํธ์ถ ์ ๋ฐฐ์ด ์ ๋ฌ ๋น๊ต
- C/Cpp์ ๊ฒฝ์ฐ
- ๋ฐฐ์ด๊ณผ ํฌ๊ธฐ๋ฅผ ๊ฐ๊ฐ ์ ๋ฌ ๋ฐ์
- ์๋ฐ์ ๊ฒฝ์ฐ
- ๋ฐฐ์ด๋ง ์ ๋ฌ๋ฐ์
- C/Cpp์ ๊ฒฝ์ฐ
๋ฐฐ์ด๊ณผ for-each ๋ฌธ
for(๋ณ์ : ๋ฐฐ์ด๋ ํผ๋ฐ์ค) {
.. ๋ฐ๋ณต์์
๋ฌธ ..
}
- for-each ๋ฌธ
- ๋ฐฐ์ด๊ณผ ์ด๊ฑฐ(enumeration) ์์๋ฅผ ์์ฐจ ์ ๊ทผํ๋๋ฐ ์ ์ฉํ for ๋ฌธ
2์ฐจ์ ๋ฐฐ์ด
int i[][] = new int[2][5];
int[][] i = new int[2][5];
- 2์ฐจ์ ๋ฐฐ์ด ์ ์ธ
// 2์ฐจ์ ๋ฐฐ์ด์ ํ ๊ฐ์
i.length
// n๋ฒ์งธ ํ์ ์ด ๊ฐ์
i[n].length
// 1๋ฒ์งธ ํ์ ์ด ๊ฐ์
i[1].length
๋ฉ์๋์ ๋ฐฐ์ด ๋ฆฌํด
- ๋ฐฐ์ด ๋ฆฌํด
- ๋ฐฐ์ด์ ๋ ํผ๋ฐ์ค๋ง ๋ฆฌํด(๋ฐฐ์ด ์ ์ฒด๊ฐ ๋ฆฌํด๋๋ ๊ฒ์ด ์๋)
int[] makeArray() {
int temp[] = new int[4];
return temp;
}
public static void main(String[] args) {
int[] intArray;
intArray = makeArray();
}
- ๋ฉ์๋์ ๋ฆฌํด ํ์
- ๋ฆฌํดํ๋ ๋ฐฐ์ด ํ์ ๊ณผ ๋ฆฌํด ๋ฐ๋ ๋ฐฐ์ด ํ์ ์ผ์น
- ๋ฆฌํด ํ์ ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ง ์์
์์ธ ์ฒ๋ฆฌ
- Exception
- ์คํ ์ค ์ค๋์์ด๋ ๊ฒฐ๊ณผ์ ์
์ํฅ์ ๋ฏธ์น๋ ์์์น ๋ชปํ ์ํฉ ๋ฐ์
- ์๋ฐ์์๋ ์คํ ์ค ๋ฐ์ํ๋ ์๋ฌ๋ฅผ ์์ธ๋ก ์ฒ๋ฆฌ
- ์คํ ์ค ์ค๋์์ด๋ ๊ฒฐ๊ณผ์ ์
์ํฅ์ ๋ฏธ์น๋ ์์์น ๋ชปํ ์ํฉ ๋ฐ์
- ์คํ ์ค ์์ธ ๋ฐ์ ์
- ์๋ฐ ํ๋ซํผ์ ์คํ ์ค์ธ ์์ฉ ํ๋ก๊ทธ๋จ์๊ฒ ์์ธ๋ฅผ ์ ๋ฌํ์ฌ ์์ฉ ํ๋ก๊ทธ๋จ์ด ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋๋ก ํจ
- ์์ฉ ํ๋ก๊ทธ๋จ์ด ์์ธ๋ฅผ ์ฒ๋ฆฌํ์ง ์์ผ๋ฉด ํ๋ก๊ทธ๋จ์ ๊ฐ์ ์ข ๋ฃ ์ํด
- ์๋ฐ ํ๋ซํผ์ ์คํ ์ค์ธ ์์ฉ ํ๋ก๊ทธ๋จ์๊ฒ ์์ธ๋ฅผ ์ ๋ฌํ์ฌ ์์ฉ ํ๋ก๊ทธ๋จ์ด ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋๋ก ํจ
- ์์ธ ๋ฐ์ ๊ฒฝ์ฐ
- ์ ์๋ฅผ 0์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ํฐ ์ธ๋ฑ์ค๋ก ๋ฐฐ์ด์ ์์๋ฅผ ์ ๊ทผํ๋ ๊ฒฝ์ฐ
- ์ ์๋ฅผ ์ฝ๋ ์ฝ๋๊ฐ ์คํ๋๊ณ ์์ ๋ ์ฌ์ฉ์๊ฐ ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
try-catch-finally ๋ฌธ
- ์์ธ ์ฒ๋ฆฌ
- ๋ฐ์ํ ์์ธ์ ๋ํด ๊ฐ๋ฐ์๊ฐ ์์ฑํ ํ๋ก๊ทธ๋จ ์ฝ๋์์ ๋์ํ๋ ๊ฒ
- ์์ธ๊ฐ ๋ฐ์ํ ์์ ์์ ์์ธ ๊ฐ์ฒด๋ฅผ ์ก์ ์ฒ๋ฆฌ
try {
์์ธ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ ๋ดํฌํ ์คํ๋ฌธ(try ๋ธ๋ก)
} catch (์ฒ๋ฆฌ ์์ธ ํ์
์ ์ธ) {
์์ธ ์ฒ๋ฆฌ๋ฌธ(catch ๋ธ๋ก)
} finally {
์์ธ ๋ฐ์ ์ฌ๋ถ ์๊ด์์ด ๋ฌด์กฐ๊ฑด ์คํ ๋ฌธ์ฅ(finally ๋ธ๋ก)
}
- finally ๋ธ๋ก์ ์๋ต์ด ๊ฐ๋ฅํจ
์๋ฐ์ ์์ธ ํด๋์ค
- java.lang pkg
- ArithmeticException : ์ ์๋ฅผ 0์ผ๋ก ๋๋ ๋ ๋ฐ์
- NullPointerException : null ๋ ํผ๋ฐ์ค ์ฐธ์กฐ ์ ๋ฐ์
- ClassCastException : ๋ณํํ ์ ์๋ ํ์ ์ผ๋ก ๊ฐ์ฒด ๋ณํ ์ ๋ฐ์
- OutOfMemoryError : ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ์ ๋ฐ์
- ArrayIndexOutOfBoundsException : ๋ฐฐ์ด ๋ฒ์๋ฅผ ๋ฒ์ด๋ ์ ๊ทผ ์ ๋ฐ์
- IllegalArgumentException : ์๋ชป๋ ์ธ์ ์ ๋ฌ ์ ๋ฐ์
- NumberFormatException : ๋ฌธ์์ด์ด ๋ํ๋ด๋ ์ซ์์ ์ผ์นํ์ง ์๋ ํ์ ์ ์ซ์๋ก ๋ณํ ์ ๋ฐ์
- java.io pkg
- IOException : ์ ์ถ๋ ฅ ๋์ ์คํจ ๋๋ ์ธํฐ๋ฝํธ ์ ๋ฐ์
- java.util
- InputMismatchException : Scanner ํด๋์ค์ nextInt()๋ฅผ ํธ์ถํ์ฌ ์ ์๋ก ์ ๋ ฅ๋ฐ๊ณ ์ ํ์์ง๋ง, ์ฌ์ฉ์๊ฐ ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
์์ธ ๋ ๋๊ธฐ๊ธฐ : throws
import java.util.Scanner;
public class exam1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int div1;
int div2;
System.out.print("๋๋จ์ ์
๋ ฅ");
div1 = sc.nextInt();
System.out.print("๋๋์ ์
๋ ฅ");
div2 = sc.nextInt();
try {
divide(div1, div2);
} catch(ArithmeticException e) {
System.out.println("0์ผ๋ก ๋๋ ์ ์์");
}
sc.close();
}
static void divide(int div1, int div2) throws ArithmeticException {
System.out.println(div1+"๋ฅผ "+div2+"๋ก ๋๋๋ฉด ๋ชซ์ "
+ div1/div2 +"์
๋๋ค.");
}
}
- ์์ธ๋ฅผ ๋ฐ์์ํจ ์คํ๋ฌธ์ ์์ ์ฝ๋ ๋ธ๋ก์ผ๋ก ์์ธ ๊ฐ์ฒด ๋ ๋๊ธฐ๊ธฐ
- ๋ ๋๊ฒจ์ง ์์ธ ๊ฐ์ฒด๋ ์ ์ ํ ์์ธ ํธ๋ค๋ฌ๋ฅผ ๋ง๋ ์ฒ๋ฆฌ๋ ๋๊น์ง ๊ณ์ ๋ฉ์๋ ํธ์ถ ์ญ์์ผ๋ก ์ ๋ฌ
- main๊น์ง ๋ ๋๊ฒจ๋ ์ ์ ํ ์์ธ ํธ๋ค๋ฌ๋ฅผ ์ฐพ์ง ๋ชปํ ์ JVM์ ํด๋น ํ๋ก๊ทธ๋จ์ ์ข ๋ฃ ์ํด
728x90
๋ฐ์ํ
'Development Study > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Lecture - Day 6 (0) | 2023.12.12 |
---|---|
[Java] Lecture - Day 5 (0) | 2023.12.12 |
[Java] Lecture - Day 3 (0) | 2023.12.12 |
[Java] Lecture - Day 1~2 (0) | 2023.12.12 |
[Java] ์๊ณ ๋ฆฌ์ฆ - ์ธ ์ ์์ ์ต๋๊ฐ (0) | 2020.04.06 |
Comments