๋ฐฐ์ด
- ์ธ๋ฑ์ค์ ์ธ๋ฑ์ค์ ๋์ํ๋ ์ผ๋ จ์ ๋ฐ์ดํฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฐ์์ ์ธ ์๋ฃ ๊ตฌ์กฐ
- ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ค์ด ์์ฐจ์ ์ผ๋ก ์ ์ฅ๋๋ค.
๋ฐฐ์ด ์ ์ธ ๋ฐ ์์ฑ
1) ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค ๋ณ์ ์ ์ธ
2) ๋ฐฐ์ด ์์ฑ - ๋ฐฐ์ด ๊ณต๊ฐ ํ ๋น
๋ ํผ๋ฐ์ค ์นํ๊ณผ ๋ฐฐ์ด ๊ณต์
- ์๋ฐ์์๋ ๋ฐฐ์ด ๊ณต๊ฐ๊ณผ ๋ ํผ๋ฐ์ค ๋ณ์๊ฐ ๋ถ๋ฆฌ๋์ด ์๊ธฐ ๋๋ฌธ์ ์์ฑ๋ ๋ฐฐ์ด์ ๋ํ ๊ณต์ ๊ฐ ์ฝ๊ฒ ์ด๋ฃจ์ด์ง๋ค.
- ๋ ํผ๋ฐ์ค์ ์นํ์ ๋ฐฐ์ด์ ๋ณต์ฌํ์ฌ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋๋ ๊ฒ์ด ์๋๋ผ ๋ ํผ๋ฐ์ค๋ง ๋ณต์ฌ๋๋ค.
- myArray๋ intArray ๋ ํผ๋ฐ์ค ๊ฐ์ ๊ฐ์ง๊ฒ ๋จ์ผ๋ก์จ intArray ๋ฐฐ์ด์ ๊ณต์ ํ๊ฒ ๋๋ค.
int intArray[] = new int[5];
int myArray[] = intArray; // ๋ ํผ๋ฐ์ค ์นํ. myArray๋ intArray์ ๋์ผํ ๋ฐฐ์ด ์ฐธ์กฐ
for-each ๋ฌธ
- ๋ฐฐ์ด์ด๋ ๋์ด์ ํฌ๊ธฐ๋งํผ ๋ฃจํ๋ฅผ ๋๋ฉด์ ๊ฐ ์์๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ๊ทผํ๋๋ฐ ์ ์ฉ
// for-each ๋ฌธ์ ์ฌ์ฉํ์ฌ ์ ์ ๋ฐฐ์ด์ ํฉ์ ๊ตฌํ๋ ์ฝ๋
int [] n = {1, 2, 3, 4, 5};
int sum = 0;
for (int k : n) { // n.length ๋งํผ ๋ฐ๋ณต
// ๋ฐ๋ณต๋ ๋๋ง๋ค k๋ n[0], ..., n[4]๋ก ๋ฒ๊ฐ์ ์ค์
sum += k;
}
๋ฉ์๋์ ๋ฐฐ์ด ๋ฆฌํด
- ๋ฉ์๋๊ฐ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ ๊ฒฝ์ฐ, ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ ์ ์ฒด๊ฐ ์๋๋ผ ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค๋ง ๋ฆฌํด๋๋ค.
// ์ผ์ฐจ์ ์ ์ ๋ฐฐ์ด์ ์์ฑํ๋ ๋ฆฌํดํ๋ makeArray(), ์ด ๋ฉ์๋๋ก๋ถํฐ ๋ฐฐ์ด์ ์ ๋ฌ๋ฐ๋ ํ๋ก๊ทธ๋จ
public class ReturnArray {
static int[] makeArray() { // ์ผ์ฐจ์ ์ ์ ๋ฐฐ์ด ๋ฆฌํด
int temp[] = new int[4]; // ๋ฐฐ์ด ์์ฑ
for (int i=0; i<temp.length; i++)
temp[i] = i;
return temp; // ๋ฐฐ์ด ๋ฆฌํด. makeArray()๊ฐ ์ข
๋ฃํด๋ ์์ฑ๋ ๋ฐฐ์ด์ ์๋ฉธ๋์ง ์์.
}
public static void main(String[] args) {
int intArray[]; // ๋ฐฐ์ด ๋ ํผ๋ฐ์ค ๋ณ์ ์ ์ธ
intArray = makeArray(); // ๋ฉ์๋๊ฐ ๋ฆฌํดํ ๋ฐฐ์ด ์ฐธ์กฐ
for (int i=0; i<intArray.length; i++)
System.out.print(intArray[i] + " ");
}
}
์๋ฐ์ ์์ธ ์ฒ๋ฆฌ
์์ธ ๋ฐ์ ์ฌ๋ก
- ์ ์๋ฅผ 0์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ํฐ ์ธ๋ฑ์ค๋ก ๋ฐฐ์ด์ ์์๋ฅผ ์ ๊ทผํ๋ ๊ฒฝ์ฐ
- ์ ์๋ฅผ ์ฝ๋ ์ฝ๋๊ฐ ์คํ๋๊ณ ์์ ๋ ์ฌ์ฉ์๊ฐ ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
try-catch-finally ๋ฌธ
try {
์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ์คํ๋ฌธ
}
catch (์ฒ๋ฆฌํ ์์ธ ํ์
์ ์ธ) {
์์ธ ์ฒ๋ฆฌ๋ฌธ
}
finally { // ์๋ต ๊ฐ๋ฅ
์์ธ ๋ฐ์ ์ฌ๋ถ์ ์๊ด์์ด ๋ฌด์กฐ๊ฑด ์คํ๋๋ ๋ฌธ์ฅ
}
์์ธ ํด๋์ค
์์ธ ํ์ (์์ธ ํด๋์ค) | ์์ธ ๋ฐ์ ๊ฒฝ์ฐ | ํจํค์ง |
ArithmeticException | ์ ์๋ฅผ 0์ผ๋ก ๋๋ ๋ ๋ฐ์ | java.lang |
NullPointerException | null ๋ ํผ๋ฐ์ค๋ฅผ ์ฐธ์กฐํ ๋ ๋ฐ์ | java.lang |
ClassCastException | ๋ณํํ ์ ์๋ ํ์ ์ผ๋ก ๊ฐ์ฒด๋ฅผ ๋ณํํ ๋ ๋ฐ์ | java.lang |
OutOfMemoryError | ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๊ฒฝ์ฐ ๋ฐ์ | java.lang |
ArrayIndexOutOfBoundsException | ๋ฐฐ์ด์ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ์ ๊ทผ ์ ๋ฐ์ | java.lang |
IllegalArgumentException | ์๋ชป๋ ์ธ์ ์ ๋ฌ ์ ๋ฐ์ | java.lang |
IOException | ์ ์ถ๋ ฅ ๋์ ์คํจ ๋๋ ์ธํฐ๋ฝํธ ์ ๋ฐ์ | java.io |
NumberFormatException | ๋ฌธ์์ด์ด ๋ํ๋ด๋ ์ซ์์ ์ผ์นํ์ง ์๋ ํ์ ์ ์ซ์๋ก ๋ณํ ์ ๋ฐ์ | java.lang |
InputMismatchException | Scanner ํด๋์ค์ nextInt()๋ฅผ ํธ์ถํ์ฌ ์ ์๋ก ์ ๋ ฅ๋ฐ๊ณ ์ ํ์์ง๋ง, ์ฌ์ฉ์๊ฐ 'a' ๋ฑ๊ณผ ๊ฐ์ด ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ | java.util |
// 0์ผ๋ก ๋๋๋ ์์ธ์ ๋์ฒํ๋ try-catch ๋ธ๋ก
import java.util.Scanner;
public class DevideByZeroHandling {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int dividend;
int divisor;
System.out.print("๋๋จ์๋ฅผ ์
๋ ฅํ์์ค:");
dividend = sc.nextInt();
System.out.print("๋๋์๋ฅผ ์
๋ ฅํ์์ค:");
divisor = sc.nextInt();
try {
System.out.println(dividend + "๋ฅผ " + divisor + "๋ก ๋๋๋ฉด ๋ชซ์ " + dividend/divisor + "์
๋๋ค.");
// divisor๊ฐ 0์ธ ๊ฒฝ์ฐ ArithmeticExceptio ์์ธ ๋ฐ์
}
catch(ArithmeticException e) {
System.out.println("0์ผ๋ก ๋๋ ์ ์์ต๋๋ค.");
}
finally {
sc.close();
}
}
}
'๐ฃ๏ธ > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์์ (0) | 2022.02.23 |
---|---|
[Java] ํด๋์ค์ ๊ฐ์ฒด (0) | 2022.02.11 |
[Java] ์๋ฐ ๊ธฐ๋ณธ ํ๋ก๊ทธ๋๋ฐ (ํ๋ก๊ทธ๋จ ๊ตฌ์กฐ, ๋ฐ์ดํฐ ํ์ , ํค ์ ๋ ฅ) (0) | 2022.02.05 |