[멋쟁이사자처럼 부트캠프 TIL 회고] BE 13기_9일차_'다양한 예외처리'

🦁멋쟁이사자처럼 백엔드 부트캠프 13기 🦁
TIL 회고 - [9]일차

🚀 9일차에서는 예외처리를 더 깊게 알아보고, 사용자 정의 예외처리와 자동 리소스 닫기 등 새로운 개념들을 배울 수 있었다. 사용자 정의 예외처리에서 자바가 정의하지 못한 예외들을 직접 작성해줌으로써 예외를 더 잘 처리할 수 있게되었다.

예외처리와 지금까지 배운 내용을 토대로 진행하는 미니프로젝트 [은행 관리 프로그램] 실습이 꽤나 어려웠다.🥲

---

<예외발생>

❓1. 실행 시 발생하는 예외 (Runtime Exception = Unchecked Exception)

public class ExceptionExam01 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        
        // IndexOutOfBoundsException 이 발생할 수 있다.
        // 이 오류는 컴파일 시에 체크하지 않는다. 
        arr[5] = 10;

        // 이 경우 생성할때부터 예외가 발생 중
        FileInputStream fis = null;
        fis = new FileInputStream("test.txt");
    }
}

• arr[5] = 10
  RuntimeException을 상속받고 있음을 확인 가능 (Exception API) 이 오류는 컴파일 시에 체크하지 않는다.
  (실행 시에 오류를 발생시킨다 = 컴파일 시에는 넘어간다 = 결국 예외는 발생한다)
  
  
• 이 경우 컴파일 시 강제하지 않는다. (= Unchecked Exception) (=Runtime Exception)

IndexOutOfBoundsException - RuntimeException을 상속받음

<실행 시 예외발생하는 RuntimeException의 경우 - 사용자가 예외를 미리 예측해서 만듦>

try{
    arr[5] = 10;
}catch(Exception e){
    System.out.println(e);
}

• FileInputStream fis = new FileInputStream(”test.txt”)
  Unhandled Exception (예외를 다루지 않았다는 표시)
  
  
• FileNotFoundException은 Runtime Exception을 상속받고 있지 않음
  = Runtime Exception이 없는 예외들은 컴파일 시에 예외 발생
  
  
• 해결방법 = 💡 try-catch로 묶어준다.

• 이 경우 예외를 강제한다. (=Checked Exception)

---

<Runtime Exception의 특징>

• java.lang패키지
• Exception클래스의 서브클래스
• 주로 실행 시 발생하는 예외
• 비검사형 예외 (Unckecked Exception)
  Runtime Exception과 그 서브 클래스는 비검사형 예외들로 분류되어
  컴파일 시점에 “체크되지 않고” 주로 프로그래머 실수로 인해 발생
  ex. 잘못된 형변환, 배열의 잘못된 인덱싱 등
  
  
• 예외처리를 강제하기 않기때문에 프로그램의 가독성과 유지보수성을 해치지 않음
  하지만 심각한 오류를 나타낼 수도 있음
  
  
• ex. ArrayIndexOutOfBoundsException : 배열의 인덱스 잘못 접근
  NullPointerException : null 참조에 대한 연산 시도
  ClassCastException : 잘못된 형변환 시도
  ArithmeticException : 수학적 불가능한 연산 시도 (0으로 나누기 등)

---

❓2. 컴파일 시 체크하는 예외 (Checked Exception)

<실행 전 예외발생중 : 이 경우는 만들어줘야만 예외가 발생하지 않음>

FileInputStream fis = null;
try{
    fis = new FileInputStream("test.txt");
}catch (FileNotFoundException e){
    System.out.println(e);
}

FileNotFoundException은 RuntimeException을 상속받지 않음

<Chekced Exception의 특징>

• 컴파일 시점에 체크되는 예외유형
• Exception클래스의 서브클래스이지만, Runtime Exception의 서브클래스는 아님
• 주로 프로그램의 외부요인에 의해 발생할 수 있는 예외상황
• 컴파일러가 체크한 이 예외를 처리하지 않으면 컴파일 오류 발생
  try-catch블록 사용 혹은 throws 키워드를 사용한 예외를 호출한 메소드로 전파
  
  
• 예측가능한 예외 : 프로그램 외부 요인, 파일 시스템오류, 네트워크 문제, DB연결 오류 등
• 프로그램의 안전성을 향상시키기위해 사용
• 개발자는 예외상황에 대해 명시적인 처리를 강제함
• 프로그램흐름을 예측가능하게 만들고 오류를 사전에 방지할 기회를 제공
  
  
• ex. IOException : 파일 입출력 시 발생
  SQLException : 데이터베이스 연결 시 발생
  FileNotFoundException : 존재하지 않는 파일에 접근시 발생

---

<예외처리>

❓1. try-catch-finally

• 내가 직접 예외를 판단하고 처리해준다.

❓2. throws Exception

• 예외를 던진다.
• 예외를 받은 쪽에서 처리해야한다.
• main메소드에서 throws로 던진다면 JVM에게 예외를 던지는 것

<throws Exception 예제>

public static void main(String[] args) throws FileNotFoundException{
    FileInputStream fis = new FileInputStream("abc");
}

 

❓예외떠넘기기 (throws)

• =예외전파
  =Exception Propagation
• 메소드가 발생시킨 예외를 처리하지 않고 그 메소드를 호출한 상위 메소드에 예외처리를 ”위임하는 방법”
  
  
• 책임의 분리 : 각 메소드나 클래스는 예외처리와는 관련없이 자신의 기능에 집중
• 코드의 간결성 유지 : 메소드 내 예외처리 시에는 메소드의 주된 기능과 관련없이 코드가 추가
• 재사용성 및 유지 보수성 향상 : 예외처리 로직을 특정 메소드에서만 구현하면
  다른 상황에서 동일한 예외발생 시 코드 중복 작성하게됨
  
  
• 흐름 제어 : 예외발생 시 프로그램의 흐름을 상위레벨로 쉽게 이동시켜 더 효과적으로 제어 가능
• 적절한 예외처리 위치 결정 : 모든 예외들은 발생한 곳에서 적절히 처리될 수 있는 것은 아니므로,
  때론 상위메소드에서 예외를 더 적절하게 처리 가능
  
  
• 💡실무에서도 내가 처리하기 힘든 문제가 있을때 빠르게 보고하는게 더 나을 수 있다.

---

▶️예제 - 예외를 메소드 별로 처리 

// exceptionProcessA() : 이 메소드에서 예외를 직접 처리한다.
public static void exceptionProcessA() {
    try{
        FileInputStream fis = new FileInputStream("abc");
    }catch(Exception e){
        System.out.println(e);
    }
}

// exceptionProcessB() : 이 메소드에서는 호출한 곳으로 예외를 던진다
public static void exceptionProcessB() throws FileNotFoundException {
    FileInputStream fis = new FileInputStream("abc");
}

public static void main(String[] args) {
    // exceptionProcessA() 메소드에서 예외를 처리해주었기때문에 호출하기만 하는 예
    exceptionProcessA();

    // exceptionProcessB()메소드를 호출했기때문에 예외를 전달받아 직접 처리해주는 예
    try{
        exceptionProcessB();
    }catch(FileNotFoundException e){
        System.out.println(e);
    }
}

• exceptionProcessA()
  이 메소드에서 예외를 직접 처리한다.
  
  
• exceptionProcessB()
  main메소드에서 이 메소드를 호출하면 이 예외를 받는다.
  = 호출한 곳에서도 예외를 throws or 처리를 해줘야한다.

---

▶️실습 - throws로 Exception과 Runtime Exception을 지정

// 메소드가 실행되는 동안 예외가 발생할 수 있음
// Runtime Exception에 해당함
public static void exceptionProcessC() throws RuntimeException{
    
}

// Exception은 Runtime Exception을 상속받진 않으므로
// Checked Exception에 해당함
public static void exceptionProcessD() throws Exception{

}

public static void main(String[] args) {
    // 예외처리를 직접 하지 않아도 에러가 표시되지 않음
    exceptionProcessC();
    
    // 예외처리를 반드시 해야 에러가 사라짐
    exceptionProcessD();
}

exceptionProcessD()를 예외처리함

public static void main(String[] args) {
    // 예외처리를 직접 하지 않아도 에러가 표시되지 않음
    exceptionProcessC();
    
    // 예외처리를 반드시 해야 에러가 사라짐
    try {
        exceptionProcessD();
    } catch (Exception e) {
        System.out.println(e);
    }
}

<총정리코드>

public static void exceptionProcessC() throws RuntimeException{
    // 1) 예외발생 시 이 메소드를 호출한 쪽으로 예외처리를 넘김 (맡김) - UnChecked Exception이 발생
}

public static void exceptionProcessD() throws Exception{
    // 2) 예외발생 시 이 메소드를 호출한 쪽으로 예외처리를 넘김 (맡김) - Checked Exception이 발생
}

public static void exceptionProcessE() {
    // 3) 예외발생 시, 이 메소드 내에서 예외를 처리한 경우
    try{
        
    }catch (Exception e){
        System.out.println(e);
    }
}

public static void main(String[] args) {
    // 1) 예외처리를 직접 하지 않아도 에러가 표시되지 않음
    exceptionProcessC();

    // 2) 예외처리를 [반드시] 해야 에러가 사라짐
    try {
        exceptionProcessD();
    } catch (Exception e) {
        System.out.println(e);
    }
    
    // 3) 예외가 메소드 내에서 처리되었음
    exceptionProcessE();
}

---

❓예외처리의 적합한 방법

상황에 따라 다르다.

• 예외를 상위클래스로 던지면 상위클래스에서 해결법을 도와줄 수 있다. [예외를 던짐]
  예외를 던지는 것이 꼭 나쁘진 않은 경우이다.
  
  
• 예외를 본인이 마음대로 처리하면 안하느니만 못할 수 있다. [스스로 예외처리]

❓CheckedException vs UnChecked Exception

1. Checked Exception
= Runtime Exception을 상속받지 않은 예외들

• FileInputStream 같은 경우 throws를 던져서 실행 전에 예외처리를 꼭 해야함
• 파일명이 애초에 없으면 파일을 만들지 못하므로, 그러한 경우
• Java IO가 가지고 있는 클래스들은 대체로 Chekced Exception이 많이 발생 대체로 throws로 던져주고 있음
• 💡Java IO는 단순히 쓰지 못하고 예외처리를 꼭 해주어야 “객체 생성이 제대로 됨”
• ⭐Java IO는 데코레이터 패턴을 하나 사용해서 객체를 생성할때도
  그 안에 다른 객체들이 사용되는 경우가 있다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

➡️생성자 안에 생성자가 있는 경우 (new InputStreamReader)
=  데코레이터 패턴 : "목적지, 근원지 등만 바꿔주면 가져다가 읽고/쓰고 하는 것들이 바뀌는 패턴"

---

2. UnChecked Exception
= Runtime Exception을 상속받은 예외들

• IndexOutOfBounds 같은 경우 컴파일 시에는 문제 없으나, 실행하면 예외가 발생함

---

🚀실습 - 심부름 예외처리

1. 내가 예외를 직접 처리했을때와
2. 예외를 넘겼을때를 실습

<심부름A()> - 예외발생 시 내가 직접 처리

// 심부름A() - 예외 발생 시 내가 직접 처리하는 방식
public static void workingA(){
    String call = "과자사와라";
    char[] calls = call.toCharArray();
    try{
        calls[6] = '!';
    }catch(Exception e){
        System.out.println(" : [A-예외처리] 화내지 마세요.");
    }

    System.out.println("[내가처리] : 알아서 사갈게요\n");
}

<심부름B()> - 예외발생 시 상위클래스로 던지는 방식 throws

// 심부름B() - 예외 발생 시 throws하는 방식
public static void workingB() throws Exception{
    String call = "과자사와라";
    char[] calls = call.toCharArray();
    calls[6] = '!';
}

<main()> - 던져진 Exception을 try-catch로 처리

public static void main(String[] args) {
    workingA();

    try{
        workingB();
    }catch(Exception e){
        System.out.println(" : [B-예외처리] 화내지 마세요");
        System.out.println("[예외넘김] : 뭐 사갈까요?");
    }
}

실행결과

<예외처리 별 try-catch-finally 실행되는 부분 판단>

public static void main(String[] args) {
    // 1. 예외발생 시 이 예외를 잘 처리했을때
    // > try의 예외 발생 밑 문장이 실행되지 않음
    int[] arr = {1, 2, 3};

    try{
        System.out.println("try - start");
        System.out.println(arr[3]);

        System.out.println("try - end");
    }catch(IndexOutOfBoundsException e){
        System.out.println(e);
    }

    System.out.println("1. To-do");
    System.out.println("2. To-do");
    System.out.println("3. To-do");
    System.out.println("끝");
}

실행결과

• arr[3]에서 예외가 발생하여, IndexOutOfBoundsException으로 잘 처리해주었기때문에
• catch문이 실행되었고
• main의 문장도 실행이 되었다.

// 2. 예외발생 시 이 예외를 잘 처리하지 못했을때
// > try의 예외 발생 밑 문장이 아예 실행되지 않음
int[] arr = {1, 2, 3};

try{
    System.out.println("try - start");

    int i = arr[2] / 0;

    System.out.println(arr[3]);

    System.out.println("try - end");
}catch(IndexOutOfBoundsException e){
    System.out.println(e);
}
// ...

실행결과

• int i = arr[2] / 0 에서 예외가 발생되었는데, ArithmeticException 예외를 처리하지 못하여
• try문의 그 밑 문장이 실행되지 않고,
• catch문의 문장도 실행되지 않으며
• main메소드의 문장도 실행되지 않는다.

// 3. 예외발생가 발생하지 않았을때
// > 모든 문장이 실행됨
// + finally블럭 추가
int[] arr = {1, 2, 3};

try{
    System.out.println("try - start");

    int i = arr[2] / 1;

    System.out.println(arr[2]);

    System.out.println("try - end");
}catch(IndexOutOfBoundsException e){
    System.out.println(e);
}finally{
    System.out.println("반드시 실행되는 블럭");
}
//...

실행결과

예외가 발생하지 않았을때, try문 안의 모든 문장은 물론 finally문장, main의 문장까지 실행된다.

---

<사용자 정의 예외>

1. 일반적으로는

• 파일이 들어와야하는데 파일이 없다.
• 가리켜야하는 값이 없다 이런 것들을 보편적인 예외로해서 “자바가 이미 정의하고있음”

---

2. 이렇게 자바가 정의한 것들을 제외하고
사용자가 정의하는 예외 사용자관점의 예외가 발생할 수 있다.

• 은행의 잔고보다 더 큰 금액을 출금하려할때 → 예외를 사용자가 직접 만들어야함
• 성적이 0~100까지 들어와야하는데 101점이 들어오면 안되므로 이러한 경우는 자바가 정의할 수 없고 사용자가 정의할 수 있다.

▶️예제 - 사용자 정의 예외 - 올바른 점수 입력

public static void inputScore(int score){
        // 값을 받아들일때, 101점이상이면 예외를 발생시키고 싶음

        // 1. 일반적인 문구출력으로 다시 입력을 요구하는 예제
        if(0 < score || score > 100){
            System.out.println("[재입력요구] : 점수는 0~100까지만 입력해주세요.");
            return;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("점수를 입력하세요 : ");
        inputScore(sc.nextInt());
    }

• 일반적으로 재입력을 요구하여 프로그램을 종료하는 예제

 

public static void inputScore(int score){
    // 값을 받아들일때, 101점이상이면 예외를 발생시키고 싶음

    // 2. 이 상황을 사용자가 정의한 예외로 판단하여 예외를 발생
    if(0 < score || score > 100){
        throw new Exception("[예외발생] : 점수는 0~100까지만 입력해주세요.");
    }
    System.out.println("학생의 점수 : " + score + "점");
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("점수를 입력하세요 : ");
    inputScore(sc.nextInt());
}

• 사용자가 예외를 정의하여 예외를 처리하는 예제이지만

에러발생

• 이처럼 에러가 발생했을때 main에서 예외를 처리해야할지,
  메소드에서 예외를 처리해야할지 판단해야한다.  
  
  
• 상황에 따라 다르지만 메소드에서는 throws Exception 으로 예외를 던지고
  사용자에게 입력을 받는 main메소드에서 try-catch 블록으로 처리를 해야한다.

 

public static void inputScore(int score) throws Exception{
    // 값을 받아들일때, 101점이상이면 예외를 발생시키고 싶음

    // 2. 이 상황을 사용자가 정의한 예외로 판단하여 예외를 발생
    if(0 < score || score > 100){
        throw new Exception("[예외발생] : 점수는 0~100까지만 입력해주세요.");
    }
    System.out.println("학생의 점수 : " + score + "점");
}
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("점수를 입력하세요 : ");
    try{
        inputScore(sc.nextInt());
    }catch(Exception e){
        System.out.println(e.getMessage());
    }
}

---

▶️예제 - 예외객체 직접 만들기

= 예외객체를 직접 설계할 수 있다.

// 사용자가 직접 정의한 예외 (직접 이름을 지은 예외)
public class MyException extends Exception{
	//...
}

• 예외객체를 만드는 방법 중 가장 첫번째는 Exception을 상속받으면 된다.
  extends Exception
  
  
• UnChekced Exception을 발생시키고 싶으면 Runtime Exception을 상속받으면 된다.
  extends RuntimeException
  
  
• 이제 사용자 정의 예외를 만든 후 다른 클래스에서 예외를 발생시킬때
  throw new MyException(); 처럼 써주면 된다.
  예외발생 시 MyException으로 예외가 발생하는 것을 확인할 수 있다.

예외발생 문구

• 사용자 정의 예외객체에서도 메시지가 발생하도록 할 수 있다.
  = 생성자를 만든다.

// 사용자가 직접 정의한 예외 (직접 이름을 지은 예외)
// 사용자 정의 예외객체를 생성하는 방법 = Exception을 상속받기
public class MyException extends Exception{
    // 기본생성자에서도 super로 메시지를 전달 가능
    public MyException() {
        super("MyException 예외");
    }

    // Exception발생 시 메시지를 넣고싶음
    public MyException(String message) {
        super(message);
    }
}

---

▶️실습 - 사용자 정의 예외객체 활용 - 올바른 로또 번호

<inputLottoNumbers()> - 로또번호를 검사하는 메소드

public static void inputLottoNumbers(int num) throws Exception{
    if(1 > num || num > 45){
        throw new MyException("올바른 로또 번호를 입력해주세요");
    }
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("로또 번호를 입력해주세요 : ");
    try{
        inputLottoNumbers(sc.nextInt());
    }catch(Exception e){
        // 세 종류의 예외 메시지 출력
        System.out.println("e.getMessage() : " + e.getMessage());
        e.printStackTrace();
        System.out.println("e : " + e);
    }
}

 

<MyException클래스> - 직접 정의한 예외

// 사용자가 직접 정의한 예외 (직접 이름을 지은 예외)
// 사용자 정의 예외객체를 생성하는 방법 = Exception을 상속받기
public class MyException extends Exception{
    // 기본생성자에서도 super로 메시지를 전달 가능
    public MyException() {
        super("MyException 예외");
    }

    // Exception발생 시 메시지를 넣고싶음
    public MyException(String message) {
        super(message);
    }
}

실행결과

---

🚀실습 - 사용자 정의 예외객체 활용 - 간단한 은행 프로그램

• 통장 객체
• 출금하다() : 잔액보다 더 많은 금액이 출금되면 예외발생 (ex. BankException (사용자정의예외객체))
• 입금하다()

<Account클래스> - 통장, 계좌 클래스

private static int money; // 계좌 잔액

public int getMoney() {
    return money;
}

// 생성될때 랜덤한 계좌 잔액을 설정하도록 함
public Account() {
    randomAccountMoney();
}

// 10000원부터 99000원까지 계좌 잔액을 랜덤하게 설정
public static void randomAccountMoney(){
    money = ((int)(Math.random()*99+10)) * 1000;
}

• Getter메소드로 money를 계좌 잔액을 가져올 수 있음
• Math.random()을 이용하여 10~99까지 뽑고 그값을 정수형변환 한 후 1000을 곱하여 10000~99000까지의 랜덤한 
  계좌 잔액을 만들어냄

<main()> - 입금, 출금의 메소드를 정의하고, 프로그램 실행을 담당

// 입금하다()
public static void deposit(int money) throws Exception{
    if(money < 0){ // 입금할 금액이 음수일 경우 예외처리
        throw new BankException("[음수입력] : 올바르지 않은 값입니다.");
    }
    System.out.println("입금 전 잔액 : " + userRandomMoney);
    System.out.println("입금 후 잔액 : " + (userRandomMoney+money));
}
// 출금하다()
public static void withdrawal(int money) throws Exception{
    if(userRandomMoney < money){ // 출금할 금액이 계좌잔액보다 많을 경우 예외처리
        throw new BankException("잔액이 부족합니다");
    }
    System.out.println("출금 전 잔액 : " + userRandomMoney);
    System.out.println("출금 후 잔액 : " + (userRandomMoney-money));
}

• 입금에 음수가 입력되면 BankException을 발생시킴
• userRandomMoney로 값을 불러와서 입력받은 money를 더하거나 차감
• 출금에 계좌 잔액보다 출금 금액이 많을 경우 BankException을 발생시킴

<BankException 클래스> - 은행관련 예외를 발생 (사용자 정의 예외처리)

public class BankException extends Exception{
    public BankException() {
        super("[은행] 예외가 발생하였습니다.");
    }

    public BankException(String message) {
        super(message);
    }
}

 

<main()> - 사용자에게 메뉴를 입력받음

int userMenu = sc.nextInt();
switch (userMenu){
    case 1: // 입금 시스템 전달
        System.out.print("얼마를 입금하시겠습니까? : ");
        try{
            deposit(sc.nextInt());
        }catch(Exception e){
            e.printStackTrace();
        }
        break outter;

    case 2: // 출금 시스템 전달
        System.out.print("얼마를 출금하시겠습니까? : ");
        try{
            withdrawal(sc.nextInt());
        }catch(Exception e){
            e.printStackTrace();
        }
        break outter;

    default: // 올바르지 않은 메뉴 입력
        System.out.println("다시 입력해주세요.");
}

• 사용자에게 메뉴를 입력받아 switch문으로 처리
• 각각의 메소드로 보내고, try-catch문을 통해 예외처리를 함

실행결과 - 입금

실행결과 - 출금

실행결과 - 입금 예외처리

실행결과 - 출금 예외처리

🚀 이번 간단한 은행 관리 프로그램을 실습해보며, 입금, 출금 기능말고도 계좌 생성, 계좌 확인, 잔액 확인 등의 기능을 구현하기 위해서는 더 복잡한 로직이 필요할 것 같다고 느꼈다.

데이터베이스가 연동되지 않은 이상 프로그램이 실행될 때 안에 데이터들이 담기고, 종료될 때 모두 사라지므로

데이터베이스와 연동하여 은행 관리 프로그램을 만드는 것도 배워야할 것 같다.

간단한 입금, 출금 기능을 가진 은행 관리 프로그램이지만 사용자 정의 예외로 처리를 하여 음수입력, 잔액부족 등의 Exception문구를 출력해볼 수 있었다.

---

❓예외처리를 제대로 하지 않을 경우

• 프로그램의 비정상적 중단
• 데이터손실
• 보안 취약점
• 사용자 경험 저하
• 유지보수의 어려움

---

<다양한 예외>

= 자바가 미리 제공하는 예외 클래스
java.lang패키지와 java.io패키지에 대부분 포함

❓Error와 서브클래스

• 이 에러는 프로그래머가 처리할 수 없다.
• 에러와 예외는 다르다. 에러는 프로그래머가 어떻게 할 수 없지만, 예외는 우리가 대처가능
• OutOfMemoryError : JVM의 메모리 부족시 발생
• StackOverflowError : 스택 오버플로우 발생 (메소드 호출이 깊이 너무 많이 중첩되었을떄사용)

---

<JDK에서의 예외 떠넘기기 사례>

• java.io.InputStream의 read()메소드 데이터를 읽을때 발생할 수 있는
  IOException을 떠넘김 (파일이 존재하지 않음, 읽기 권한 없음 등)
  
  
• java.net.Socket의 생성자 네트워크 연결과 관련된 Socket클래스도 예외를 떠넘김
  Socket의 생성자는 호스트 주소와 포트를 사용해 소켓연결을 시도하며
  이 과정에서 여러 네트워크 관련 예외를 발생시킬 수 있음 UnknowHostException과 IOException을 떠넘김

public Socket(String host, int port) throws UnknownHostException, IOException;

• 이를 통해 네트워크 연결 문제나 입/출력 문제 발생할 경우 이를 처리할수 있는 기회 제공

---

❓사용자 정의 예외, 예외발생, 예외 떠넘기기를 함께 사용하는 이유

• 사용자 정의 예외는 자바가 제공하는 표준 예외들로는 특정상황을 명확하게 표현하기 어려울때,
  오류 상황을 더 구체적이고 명확하게 전달 가능
  
  
• 예외 발생시키기는 프로그램에서 예상치 못한 상황이나 조건을 만났을때 안전하게 처리할 수 있도록 도와줌
  특정 조건에서 프로그램의 실행 중단 및 문제를 알려주거나 적절한 조치를 취할 수 있음
  
  
• 예외 떠넘기기는 발생한 예외를 호출한 메소드로 전달하는 것 예외를 처리하는 로직을
  현재의 메소드 레벨에서 다루기 어려울때, 상위레벨로 위임하기위해 사용
  [오류 처리의 책임을 명확하게 분리 / 코드의 가독성과 유지보수성 높임]

---

❓자동 리소스 닫기

• 1. 일반적으로 finally안에서 try-catch문 처리로 닫아주는 예제

// 자동리소스 닫기 예제
// 1) 일반 finally에서 try-catch문 사용
public class ExceptionFinally01 {
    public static void main(String[] args) {
        // 연결하면, 반드시 닫아야하는 것이 중요 = FildInputStream 등
        // 반드시 닫아야하는 기능은 finally에서 기능
        FileInputStream fis = null;

				System.out.println("-----1번방법 블록 start");
        try{
            fis = new FileInputStream("abc");
        }catch (Exception e){
            System.out.println(e);
        }finally{ // finally에서도 try-catch블록을 통해 반드시 닫는 기능 close()를 수행하고
                    // 어디서 발생했는지를 알 수 있도록 IOException을 발생하는 e를 catch문에 작성
            try{
                fis.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
 				System.out.println("-----1번방법 블록 end");
    }
}

 

• 2. ⭐Java 7부터 제공하는 try-with-resources라는 구문을 사용하여 자동리소스 닫기

// 연결하면, 반드시 닫아야하는 것이 중요 = FildInputStream 등
FileInputStream fis = null;

System.out.println("-----2번방법 블록 start");
// 이 리소스를 쓸것임을 try()안에 바로 선언
try(FileInputStream fis2 = new FileInputStream("abc")){

}catch(Exception e){
    e.printStackTrace();
}
System.out.println("-----2번방법 블록 end");

// 이구문은 finally로 닫아준 구문과 똑같이 동작함

이 구문은 try( ) 안에 만들어진 리소스들은 finally에서 자동으로 close시켜준다는 의미이다.

⭐1번방법의 블록과 2번방법의 블록은 똑같은 기능을한다.
1번방법과 같은 코드가 복잡하고, 리소스를 닫는 것을 잊어버리는 실수를 해결하기 위해
2번방법처럼 간결하게 사용이 가능하고, 리소스 누수를 방지하고 코드를 더 깔끔하게 관리할 수 있게된다.

💡이 2번기능을 사용하기 위해서는 (try-with-resources)

리소스 객체가 AutoCloseable 인터페이스를 구현해야하고,
대부분의 Java표준 라이브러리 리소스 클래스들은 ⭐⭐이미 이 인터페이스를 구현하고 있다.
이 인터페이스를 구현하고 있지 않으면 이 타입을 가리킬 수 없다.

예로 FileInputStream API를 가보면

FileInputStream API

Implements에서 AutoCloseable 인터페이스를 구현하고 있고,
이 AutoCloseable 인터페이스는 1.7 부터 제공하는 것을 알 수 있다.

AutoCloseable API

---

❓예외정보얻기가 필요한 이유

• 예외 발생 시 원인과 상황을 정확히 파악하고 같은 실수를 반복하지 않게함
• 정확한 디버깅 : 예외정보에는 예외가 발생한 코드 위치 (파일명, 라인 번호 등)가 포함됨
• 효율적인 문제 해결 : 예외의 종류와 메시지를 이해할 수 있음,
  예로 NullPointerException은 객체가 초기화하지 않았으므로 개발자는 객체 초기화와 관련된 코드를 확인할 수 있음

 

<예외출력 메소드>

❓getStackTrace()

예외발생 위치를 반환한다.
💡(”예외 발생 위치 : “+ e.getStackTrace()[0]);

---

❓printStackTrace()

예외발생 메시지와 위치를 출력한다.

---

🚀이 후 남은 시간에는
은행 관리 프로그램 만들기를 미니프로젝트로 진행하였다. 처음에는 예외처리를 중요하게 생각하지 않아서

단순히 기능만 구현하고, 올바른 입력값이 아닐 경우에는 while문을 통해 올바른 값이 입력될때까지 무한 반복 시켰다면

예외처리를 배우고나서는 어느정도 try-catch문으로 묶어봐야겠다는 생각도 든다.

아직까지 이 은행 관리 프로그램을 만들고 있지만 여전히 예외처리를 구현해서 넣는 것이 어려웠다.

입금 / 출금 / 계좌등록 / 계좌확인 / 이름 중복 금지 등 갖가지 기능을 구현하다보니 예외처리는 일단 제껴두고 구현에만 힘쓰고있었다.

프로젝트 구현이 막바지될때쯤 예외를 넣어가며 하나하나 코드를 수정해야겠다고 생각했다.

---

💡 9일차에서는 이렇게 예외처리에 대해서 다양하고 깊게 배우고, 은행 관리 프로그램 만들기 프로젝트를 통해 예외처리를 직접 사용해보고 기능구현과 함께 개발해나가는 과정을 경험할 수 있었다.

머릿속에서 갑자기 생각나서 만들고 싶어한 프로그램 기능들은 한 줄 한 줄 코드가 잘 써졌는데

요구사항과 정해진 클래스, 메소드를 보니 머리도 복잡해지고 객체와의 관계를 어떻게 정의할지부터 막막했다.

이번 미니 프로젝트를 진행하면서 느낀건 하나하나 오류 잡아가면서 완성시켜야겠다는 의지가 생겼다는 것이다!🚀