[ JAVA ] 예외처리( 다중 catch / 예외 강제발생 / 예외 떠넘기기 / 사용자정의 예외 ) , 열거타입

---

 

예외처리

 

▶  try - catch문 사용

num3 을 0으로 나누면 에러가 나지만, try - catch 문으로 예외처리를 한다면 에러가 안나는것을 볼 수 있다.

finally 구문을 추가하면 에러의 유무와 상관없이 finally구문을 무조건 실행한다.

public class Study {

    public static void main( String[] args ) {
    
        System.out.println( "시작" );

        System.out.println( "1" );
        int num1 = 2;        
        int num2 = 0;
        int num3 = 10;
        
        try {
            System.out.println( "2" );
            
            //int result = num3/num1;
            int result = num3/num2;
            
            System.out.println( "3" );
            System.out.println("결과: "+ result);
            
        } catch(ArithmeticException e) {
            System.out.println( "4" );
        } finally {
            System.out.println( "5" );
        }

        System.out.println("끝");
    }
}

결과 화면

 

▶  다중 catch

try 블록 내부에 다양한 종류의 예외가 발생할 수 있다. 이를 해결하기 위해 여러개의 catch문을 사용하는것이 다중 catch 이다.

하지만 catch 블록이 여러개일지라도, 단 하나의 catch블록만 실행된다.

try 블록에서 동시다발적으로 예외가 발생하지 않고, 하나의 예외가 발생하면 즉시 실행을 멈추고

해당 catch블록으로이동하기 때문이다.

public class Study {

    public static void main( String[] args ) {
    
        try {
 			
            // Exception 발생가능 1
            String data1 = args[0];
            String data2 = args[1];
			
            // Exception 발생가능 2
            int v1 = Integer.parseInt(data1);
            int v2 = Integer.parseInt(data2);
            
            int result = v1 + v2;

            System.out.println(data1 + "+" + data2 + "=" + result);
        
        // Exception 1
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println( "실행 매개값의 수가 부족합니다." );
            System.out.println( "[실행방법]" );
            System.out.println( "java 클래스명 num1 num2" );
        
        // Exception 2
        } catch (NumberFormatException e) {
            System.out.println( "숫자로 변환할 수 없습니다." );
        } finally {
            System.out.println( "다시 실행하세요." );
        }
    }
}

결과 화면

 

그렇기 때문에 상위 예외 클래스가 하위 예외 클래스보다 아래쪽에 위치해야 한다.

예외를 처리해줄 catch 블록은 위에서부터 차례대로 검색된다.

( 하위 예외는 상위 예외를 상속했기 때문에 )

public class Study {

    public static void main( String[] args ) {
    
        try {
            String data1 = args[0];
            String data2 = args[1];

            int v1 = Integer.parseInt(data1);
            int v2 = Integer.parseInt(data2);
            int result = v1 + v2;

            System.out.println( data1 + "+" + data2 + "=" + result );
            
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("실행 매개값의 수가 부족합니다.");
            System.out.println("[실행방법]");
            System.out.println("java 클래스명 num1 num2");
            
        } catch (Exception e) {
            System.out.println("실행에 문제가 있습니다.");
        } finally {
            System.out.println("다시 실행하세요.");
        }
    }
}


=> 상위클래스인 Exception이 아래에 위치해야 한다.

 

 

▶  멀티 catch

하나의 catch 블록에서 여러개의 예외를 처리할 수 있다. ( catch 블록의 괄호 안에 예외를 | 로 연결하면 된다. )

 

 

▶  예외 강제로 발생

메서드안에서 강제로 Exception을 발생시킬 때 사용

public class Study {

    //인스턴스 메소드
    public void method1(int n) {
        System.out.println( "시작" );

        int n1 = 10;
        try {
            if( n1<100 ) {
            
                //강제 익셉션 발생
                throw new Exception( "익셉션 발생" );
            }
        } catch(Exception e) {
            System.out.println( "[익셉션]" + e.getMessage() );    
        }

        System.out.println("끝");
    } 

    public static void main( String[] args ) {
    
        Study s = new Study();
        s.method1(10);    //정상
        s.method1(101);   //비정상
    }
}

결과 화면

 

 

▶  예외 떠넘기기 ( = 위임 )

 

•  메서드 내부에서 예외가 발생할 수 있는 코드를 작성할 때, try - catch 블록으로 예외를 처리하는것이 기본이지만

    경우에 따라서는 메서드를 호출한 곳으로 예외를 위임시킬 수 있다.

= > Throws 키워드

 

•  throws 키워드는 메서드 선언부 끝에 작성되어 메서드에서 처리하지 않은 예외를 호출한 곳으로 떠넘기는 역할

•  throws 키워드 뒤에는 떠넘길 예외 클래스를 쉼표로 구분해서 나열

 

• 모든 예외를 위임시킬 수 있다.

리턴타입 메서드명( 매개변수1, ... ) throws Exception { }

 

•  throws 키워드가 붙어있는 메서드는 반드시 try 블록내에서 호출되어야 한다.

   ( catch 블록에서 위임받은 예외를 처리해야한다. )

public class Study {
	
    // 인스턴스 메소드
    public void method1( int n ) {
        System.out.println( "시작" );

        int n1 = 10;
        
        try {
            if( n1<100 ) {
            
                //강제 익셉션 발생
                throw new Exception( "익셉션 발생" );
            }
        } catch(Exception e) {
            System.out.println( "[익셉션]"+e.getMessage() );    
        }

        System.out.println( "끝" );
    } 

    // 예외 위임시키는 method2
    public void method2(int n) throws Exception {
        System.out.println( "시작" );

        int n1 = 10;
        if(n1<100) {
        
		// 강제 익셉션 발생
            throw new Exception( "익셉션 발생" );
        }
        System.out.println( "끝" );
    } 

    public static void main( String[] args ) {
        Study s = new Study();
        s.method1(10);
        s.method1(101);
		
        // 예외를 위임받았으므로 try-catch 블럭으로 묶어준다.
        try {
            s.method2(101);    
        } catch(Exception e1) {
            System.out.println( "[익셉션] : "+e1.getMessage() );
        }
        
    }
}

결과 화면

 

 

▶  사용자정의 예외

•  자바표준 API에서 제공하는 예외클래스만으로 다양한 종류의 예외를 표현할수가 없다.

    이럴경우 개발자가 직접 예외를 정의해서 만들어야 한다. ( 이를, 사용자정의 예외 )

 

•  사용자정의 예외 클래스는 컴파일러가 체크하는 일반 예외로 선언할 수 있고 체크하지 않는

    실행 예외로도 선언 가능하다.

     -  일반 예외 선언 : Exception 을 상속

     -  실행 예외 선언 : RuntimeException 을 상속

 

•  사용자정의 예외 연습

// 사용자 정의 예외 클래스 선언
class BalanceInsufficientException extends Exception {

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

class Account {

    private long balance;

    public Account() { }

    // 통장잔고확인 메소드
    public long getBalance() {
        return balance;
    }

    // 예금하기 메소드
    public void deposit( int money ) {
        balance += money;
    }

    // 출금하기 메소드 - 사용자 정의 예외 위임하기
    public void withdraw( int money ) throws BalanceInsufficientException {
        if( balance < money ) {
            throw new BalanceInsufficientException( "잔고부족: "+(money-balance)+"가 모자람" );
        }
        
        balance -= money;
    }
}

public class Study {

    public static void main( String[] args ) {
    
        Account account = new Account();

        // 예금하기
        account.deposit(10000);
        System.out.println( "예금액: "+account.getBalance() );

        // 출금하기
        
        try {
            account.withdraw(30000);
            
        } catch(BalanceInsufficientException e) {
            String message = e.getMessage();
            System.out.println(message);
            System.out.println();
            e.printStackTrace();    //예외 추적후 출력
        }
    }
}

 

 

 

▶  이클립스( Eclipse )에서 예외처리

 

•  예외처리하고자 하는 부분을 영역을 드래그 해준다.

•  마우스 우클릭 후, Surround With 클릭

•  try/catch  블록 클릭

 

---

 

열거타입

 

•  한정된 값만을 갖는 데이터타입을 의미한다.

•  몇개의 열거 상수중에서 하나의 상수를 저장하는 데이터 타입이다.

    ex) 요일에 대한 데이터

•  열거타입 이름은 관례적으로 첫문자를 대문자, 나머지는 소문자로 한다.

•  열거타입의 데이터들은 대문자를 사용한다.

 

 

▶  열거타입의 선언

public enum Week {

    // 열거상수
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

 

 

▶  열거타입의 사용

열거타입 변수이름 = 열거타입.열거상수;
Week today = Week.SUNDAY;


// 열거타입 변수
이클립스에서 new에 따로 enum만드는 것이 있다.
문자열이 아니고 enum타입으로 특수한 타입이다.
상수 값이 아니라 이름에 의한 접근이며 목록 중심이다.

 

 

▶  열거타입 메서드

package com;
import java.util.Calendar;

public class Study {

	public static void main( String[] args ) {
    
		// 열거타입 변수 선언
		Week today = null;
		
		Calendar c = Calendar.getInstance();
		
		// 일(1) ~ 토(7) 까지의 숫자리턴
		int week = c.get(Calendar.DAY_OF_WEEK);
		
		switch(week) {
		case 1:
			today = Week.SUNDAY; break;
		case 2:
			today = Week.MONDAY; break;
		case 3:
			today = Week.TUESDAY; break;
		case 4:
			today = Week.WEDESDAY; break;
		case 5:
			today = Week.THURSDAY; break;
		case 6:
			today = Week.FRIDAY; break;
		case 7:
			today = Week.SATURDAY; break;
		}
		
		System.out.println( "오늘 요일: "+today );
		
		if( today == Week.SUNDAY ) {
			System.out.println( "일요일에는 축구를 합니다." );
		} else {
			System.out.println( "열심히 자바 공부를 합니다." );
		}
	}
}