(5주차 33일) 인터페이스, 예외 처리, 기본 API

Java

인터페이스(Interface)

> 인터페이스

• 자바에서 클래스들이 구현해야 하는 동작을 지정하는 역할
• 실행 코드와 객체가 통신하는 접점으로 실행 코드가 인터페이스의 메소드를 호출하면 인터페이스는 객체의 메소드를 호출

> 인터페이스 구현

• 선언: [접근 제한자] interface 인터페이스명 { ... }
  1. class 키워드 대신 interface 키워드 사용
  2. 인터페이스는 선언된 필드는 모두 public static final의 특성을 가진다.
  3. 인터페이스에 선언된 메소드는 모두 public abstract의 특성을 가진다.
• 구현: 클래스 선언부에 implements 키워드를 추가하고 인터페이스명을 명시한다.
  1. 인터페이스를 구현하는 클래스는 인터페이스에 정의된 추상 메소드를 반드시 오버라이딩 해야 한다.
  2. 상속과 다르게 인터페이스는 다중 구현이 가능하다.
  3. 인터페이스를 구현하는 클래스로 객체를 생성 후 구현된 메소드를 호출할 수 있다.

> 인터페이스 상속

• 인터페이스는 다른 인터페이스를 상속할 수 있다.
  
  1. 인터페이스는 다중 상속을 허용한다.
  2. 구문: [접근 제한자] interface 하위인터페이스 extends 상위인터페이스1, 상위인터페이스2 { ... }
  3. 하위 인터페이스를 구현하는 클래스는 하위 인터페이스의 추상 메소드 뿐만 아니라 상위 인터페이스들의 모든 추상 메소드들을 오버라이딩 해야 한다.

 

예외(Exception) 처리

> 예외(Exception)

• 사용자의 잘못된 조작 또는 개발자의 잘못된 코딩으로 인해 발생하는 프로그램 오류
  1. CheckedException
     • Exception을 상속하고 있는 예외
     • 컴파일 시 예외 처리 코드가 있는지 검사하는 예외
     • 예외 처리 없을 시 컴파일 에러 발생
     • 주로 외부에 매개체와 입출력이 일어날 때 발생
  2. UncheckedException
     • RuntimeException을 상속하고 있는 예외
     • 컴파일 시 예외 처리 코드가 있는지 검사하지 않는 예외
     • 프로그램 실행 시 문제가 발생되므로 예측 가능함
     • 조건문 혹은 코드 수정을 통하여 처리

> try-catch-finally 문

• 프로그램에서 예외가 발생했을 경우 프로그램의 갑작스러운 종료를 막고 정상 실행을 유지할 수 있도록 처리하는 코드를 예외 처리 코드라고 한다.
• try-catch-finally 문
  
  1. try 블록에는 예외가 발생할 가능이 있는 코드가 위치한다.
  2. try 블록의 코드에서 예외가 발생하면 즉시 실행을 멈추고 catch 블록으로 이동하여 예외 처리 코드를 실행한다.
  3. finally 블록은 생략 가능하고, 예외 발생 여부와 상관없이 항상 실행할 내용이 있을 경우에 finally 블록을 작성한다.

try {
  ...
} catch (Exception e) {
  ... 
} finally {
  // 예외 발생 여부와 상관없이 실행해야 하는 코드  
}

• 예시

package com.beyond.o_exception.practice;

public class TryCatch {
    public void method1() {
        /**
         * 1. try 블럭 내에서 예외가 발생하면 (NullPointer)Exception 객체를 생성하여 catch 구문으로 던진다.
         *    이 객체를 catch 블럭에서 Exception 이라는 부모 클래스의 참조 변수에 대입하여 예외를 처리한다.
         * 2. 모든 예외 클래스들은 Exception 클래스를 상속한다.
         *    따라서 Exception 으로 처리할 경우, 모든 예외를 catch 할 수 있다.
         * 3. 만약 특정 예외를 직접 대입하게 되는 경우, 그 예외가 아닌 경우 예외 처리가 되지 않고 오류가 발생할 수 있다.
         *    따라서 예외에 따라서 다르게 처리하는 경우, catch 블럭을 여러 개 생성하여 처리한 후 
         *    Exception 으로 전체를 묶어 처리할 수 있다.
         * 4. 다중 catch: catch 블럭을 여러 개 생성하여 처리하는 방법
         *    멀티 catch: 한 catch 블럭 내에서 여러 예외를 한 번에 처리하는 방법
         */
        try {
            // 예외가 발생할 가능성이 있는 코드를 작성하는 블록
            int result = 10 / 0;
            System.out.println("result = " + result);
        } catch (NullPointerException e) {
            // try에서 발생한 예외를 처리하는 블록
            System.out.println("NullPointerException이 발생하였습니다.");
        } catch (ArithmeticException | ClassCastException e) { 
        	// 한 catch 블럭에서 여러 예외를 한 번에 처리할 수 있다.
            System.out.println("ArithmeticException이 발생하였습니다.");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 예외 발생 여부와 상관없이 무조건 수행되는 블록
            System.out.println("finally 블록 실행");
        }
    }
}

 

> throws

• throws 키워드를 통해서 메소드를 호출한 곳으로 예외를 떠넘길 수 있다.
  
  1. throws 키워드는 메소드 선언부 끝에 작성되어 메소드에서 처리하지 않는 예외를 호출한 곳으로 떠넘기는 역할을 한다.
  2. throws가 붙어있는 메소드는 반드시 try 블록 내에서 호출되어야 한다. 
     만약 throws가 붙어있는 메소드를 호출한 곳에서 처리하지 않으려면 throws 키워드로 다시 예외를 떠넘길 수 있다.
     
• 예시
  1. throws 키워드 사용
  2. 전달받은 예외를 직접 처리

package com.beyond.o_exception.practice;

import java.io.IOException;

public class Throws {
    // 외부에서 method2, method3에 접근할 수 없고 method1에만 접근 가능하도록 생성
    public void method1() throws ClassNotFoundException, IOException {
        // 3. method2로부터 전달받은 예외를 다시 던짐
        // -> method1을 호출하는 ExceptionApplication에서 예외를 처리해야 함
        System.out.println("Throws.method1");
        method2();
        System.out.println("end.method1");
    }
    private void method2() throws ClassNotFoundException, IOException {
        // 2. method3 으로부터 전달받은 예외를 다시 던짐
        // -> method2를 호출하는 method1에서 예외를 처리해야 함
        System.out.println("Throws.method2");
        method3();
        System.out.println("end.method2");
    }
    private void method3() throws ClassNotFoundException, IOException {
        // 1. 메소드 호출 시 2개의 예외가 발생할 수 있도록 method3 생성
        //  throws 문을 사용하여 예외를 던져줌

        System.out.println("Throws.method3");

        int random = (int)(Math.random() * 3 + 1);
        if (random == 1) {
            throw new ClassNotFoundException();
        } else if (random == 2) {
            throw new IOException();
        }

        System.out.println("end.method3");

    }
}

package com.beyond.o_exception;

import com.beyond.o_exception.practice.Throws;
import com.beyond.o_exception.practice.TryCatch;

import java.io.IOException;

public class ExceptionApplication {
    public static void main(String[] args) {
        System.out.println("프로그램 실행");
        // 4. method1로부터 전달받은 예외를 직접 처리
        try {
            new Throws().method1();
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFoundException 예외 발생");
        } catch (IOException e) {
            System.out.println("IOException 예외 발생");
        }
        System.out.println("프로그램 종료");
        
        // *5. 메인 메소드에서도 예외를 처리하지 않고 던지는 경우,
        // jvm에서 예외를 전달받아 프로그램을 정상 종료하지 않고 오류가 발생한다.
    }
}

 

기본 API

> Wrapper

/**
 * Wrapper 클래스
 *  - 기본 자료형을 객체로 포장해 주는 클래스이다.
 *  - 기본 자료형을 Wrapper 클래스로 포장해 주는 것을 Boxing 이라고 한다.
 *  - Wrapper 클래스로 포장된 객체를 기본 자료형으로 변경하는 것을 Unboxing 이라고 한다.
 */

@Deprecated
public void method1() {
    // Boxing(기본 타입 -> Wrapper 객체)
    // 1. Wrapper 클래스로 객체를 생성하는 방법
    Integer integer = new Integer(10);
    Double double1 = new Double(3.14);
    Double double2 = new Double(3.14);

 

> Date

/**
 * DateApi 클래스
 *  - 날짜를 표현하는 클래스이다.
 *  - 주로 객체 간에 날짜 정보를 주고 받을 때 사용한다.
 */
    public void method1() {
        // 기본 생성자로 객체를 생성하면 현재 시스템의 시간에 대한 정보를 가지고 객체를 생성한다.
        Date today = new Date();
        // 1970/1/1 00:00:00 기준 ms 단위로 표기
        Date when = new Date(1);
        SimpleDateFormat sdf = new SimpleDateFormat("yy년 MM월 dd일(E) a hh시 mm분 ss초");

 

> Java.time

/**
 * java.time 패키지
 *  - 자바 1.8부터는 날짜와 시간을 나타내는 java.time 패키지를 제공한다.
 */
public void method1() {
    // 날짜와 시간 정보를 모두 저장할 수 있다.
    // 현재 날짜와 시간 정보를 저장한 객체를 생성한다.
    LocalDateTime now = LocalDateTime.now();
    LocalDateTime when = LocalDateTime.of(2024, 6, 13, 18, 00, 00);

    System.out.println("now = " + now);
    System.out.println("when = " + when);
    System.out.println(ZonedDateTime.now());
    System.out.println();