[Class -11] 상속 / 예외처리 / 입출력(OI)

◆ 상속의 기본적인 특성과 특징

상속은 기존 클래스(부모)의 변수와 메서드를 새로운 클래스(자식)가 물려받아 그대로 사용하거나 기능을 확장하는 매커니즘임.

• 키워드: extends (확장하다) 기호를 사용하여 구현함.
• 적용 범위: 부모의 멤버 중 private 지시자가 붙은 변수나 메서드는 상속은 되지만 자식이 직접 접근할 수 없음. 또한 생성자는 상속 대상에서 완전히 제외됨.
• 이점: 이미 검증된 코드를 재사용하므로 중복 코드가 획기적으로 줄어들고, 유지보수가 쉬워지며 프로그램의 확장성이 극대화됨.

◆ 모든 클래스의 조상: Object 클래스 후손

자바에서 개발자가 만드는 모든 클래스는 별도로 extends를 적지 않아도 무조건 java.lang.Object 클래스를 자동으로 상속받도록 설계되어 있음.

• 최상위 조상: 모든 클래스는 최하위 후손이며, Object가 제공하는 기본 메서드들을 물려받아 사용할 수 있음.
• 주요 물려받는 메서드:
  • toString(): 객체의 텍스트 표현(주소값 또는 데이터)을 반환함.
  • equals(Object obj): 두 객체가 메모리상에서 동일한지 비교함.

◆ 단일 상속 vs 다중 상속

• 단일 상속 (자바의 표준 규칙): 자바는 클래스 간의 다중 상속을 절대 허용하지 않음. 즉, class Child extends Father, Mother와 같이 두 개 이상의 부모를 동시에 지정할 수 없음.
• 이유 (다이아몬드 문제 방지): 만약 두 부모 클래스에 이름이 똑같은 메서드가 존재할 경우, 자식 객체가 어떤 부모의 메서드를 실행해야 할지 컴퓨터 시스템이 판단할 수 없는 모호성이 발생하기 때문임.
• 해결책: 다중 상속의 효과를 내기 위해 자바는 인터페이스(Interface)라는 특수 구조를 제공함.

◆ 생성자 호출 관계 파악

자식 객체를 생성할 때, 메모리(Heap) 내부에서는 자식 혼자 태어나지 않음. 반드시 부모 객체가 먼저 생성된 후 자식 객체가 그 겉을 감싸며 결합하는 아키텍처를 가짐.

• 실행 순서: 자식 생성자가 호출되면, 내부적으로 부모 생성자가 먼저 완벽하게 실행을 끝낸 뒤 자식 생성자의 나머지 본문 코드가 가동됨.

◆ super() 와 super 의 차이점

이름은 비슷하지만 메모리를 제어하는 용도가 완전히 다름.

① super() : 부모의 생성자 호출 명령

• 자식 생성자 내부에서 부모의 생성자를 강제로 가동시키는 메서드 형태의 명령어임.
• 규칙: 자식 생성자 본문에서 반드시 첫 줄에만 위치해야 함. 생략하면 컴파일러가 부모의 기본 생성자를 부르는 super();를 자동으로 맨 첫 줄에 삽입함.

② super : 부모 객체의 메모리 주소록(참조 변수)

• 자식 클래스 내부에서 내 변수와 부모의 변수 이름이 중복되어 충돌할 때, 부모의 자원을 콕 집어서 가리키는 키워드임.
• this가 현재 나 자신의 메모리 주소를 뜻한다면, super는 내 부모 방의 주소를 의미함.

◆ 상속이 도움이 되는 상황의 예시

• 상황: 회사에서 '정직원' 관리 프로그램과 '알바생' 관리 프로그램을 따로 구축해야 하는 경우.
• 상속 미적용 시: 두 클래스 모두에 이름, 나이, 사원번호, 입사일 등 똑같은 변수와 출력 메서드를 중복해서 타이핑해야 함.
• 상속 적용 시: 공통 분모인 '사원(Employee)' 클래스를 위 상위에 정의하고, '정직원(Regular)'과 '알바생(PartTime)'은 상위 클래스를 extends 한 뒤 각각 보너스 계산법이나 시급 계산법 등 자신만의 고유 차별점만 아래에 추가 구현하면 됨.

◆ 단순 인맥 관리 프로그램 예제 (관리 대상이 둘인 구조)

관리 대상이 "동창(UnivFriend)"과 "직장 동료(CompanyFriend)" 둘인 경우의 아키텍처 설계 코드임. 공통 데이터는 상위 클래스(Friend)로 묶고 상속을 통해 구현함.

1. 공통 상위 클래스 정의

 

// 💡 공통 부모 클래스
class Friend {
    protected String name; // 자식 클래스에서 직접 접근할 수 있도록 protected 배치
    protected String phone;

    public Friend(String name, String phone) {
        this.name = name;
        this.phone = phone;
    }

    public void showInfo() {
        System.out.println("이름: " + name);
        System.out.println("전화: " + phone);
    }
}

2. 두 개의 자식 클래스 대상 정의 및 상속 구현 코드

 

// 💡 관리 대상 1: 대학교 동창 클래스
class UnivFriend extends Friend {
    private String major; // 동창만의 고유 특성 (전공)

    public UnivFriend(String name, String phone, String major) {
        super(name, phone); // 💡 super()를 통해 부모 생성자에 이름과 전화번호 재료 전달
        this.major = major;
    }

    @Override
    public void showInfo() {
        super.showInfo(); // 💡 super 키워드로 부모의 출력 기능 먼저 가동
        System.out.println("전공: " + major);
    }
}

// 💡 관리 대상 2: 직장 동료 클래스
class CompanyFriend extends Friend {
    private String department; // 직장 동료만의 고유 특성 (부서)

    public CompanyFriend(String name, String phone, String department) {
        super(name, phone); // 부모 생성자 호출
        this.department = department;
    }

    @Override
    public void showInfo() {
        super.showInfo(); // 부모의 공통 정보 출력 활용
        System.out.println("부서: " + department);
    }
}

3. 메인 실행 및 제어 코드

 

public class Main {
    public static void main(String[] args) {
        // 동창 객체와 직장 동료 객체 각각 생성 (Heap 메모리에 부모 공간과 함께 배치됨)
        UnivFriend uFriend = new UnivFriend("홍길동", "010-1111-2222", "컴퓨터공학");
        CompanyFriend cFriend = new CompanyFriend("이순신", "010-3333-4444", "개발팀");

        System.out.println("--- 동창 정보 출력 ---");
        uFriend.showInfo();

        System.out.println("\n--- 직장 동료 정보 출력 ---");
        cFriend.showInfo();
    }
}

 

◆ 1. static 자원도 상속이 되는가?

결론부터 말하면, static 변수와 static 메서드도 자식 클래스에게 상속됨.

• 원리: 부모 클래스에 static으로 선언된 자원은 자식 클래스 이름을 통해서도 그대로 접근하고 사용할 수 있음.
• 코드 예시:
• Java

   

  class Parent {
      static int sharedVal = 100;
      static void staticMethod() {
          System.out.println("부모의 스태틱 메서드");
      }
  }
  
  class Child extends Parent {
      // 아무것도 적지 않아도 부모의 static 자원을 물려받음
  }
  
  public class Main {
      public static void main(String[] args) {
          // 💡 자식 클래스 이름을 통해 부모의 static 자원에 접근 가능
          System.out.println(Child.sharedVal); // 출력: 100
          Child.staticMethod();                // 출력: 부모의 스태틱 메서드
      }
  }
  

◆ 2. 메모리 아키텍처로 보는 상속의 진실: "공유"

상속이라고 하면 부모의 공간을 자식이 복사해서 소유하는 것처럼 느껴지지만, static은 완전히 다르게 작동함.

• 인스턴스 변수 상속: 자식 객체를 new로 생성할 때마다 힙(Heap) 영역에 부모의 변수 공간과 자식의 변수 공간이 각각 새롭게 파짐.
• static 자수 상속: static 변수는 인스턴스(객체)에 속하지 않고 오직 Static(Method) 영역에 단 한 개만 생성됨. 자식 클래스가 이를 상속받는다는 것은, 새로운 상자가 생기는 것이 아니라 Static 영역에 존재하는 하나의 똑같은 상자를 부모와 자식이 '공유'하는 구조임.
• 코드 증명 예시:
• Java

   

  Child.sharedVal = 500; // 자식 쪽에서 static 변수 값을 바꿈
  System.out.println(Parent.sharedVal); // 💡 출력: 500 (부모 쪽 값도 바뀜, 결국 같은 상자이기 때문)
  

◆ 3. ⚠️ static 메서드는 오버라이딩(Overriding)이 불가능하다

인스턴스 메서드는 부모의 것을 자식이 재정의(Overriding)하여 다형성을 구현할 수 있음. 하지만 static 메서드는 오버라이딩 규칙이 적용되지 않음.

자식 클래스에서 부모의 static 메서드와 완전히 똑같은 이름과 형태로 메서드를 다시 정의하면, 오버라이딩된 것이 아니라 '메서드 숨김(Method Hiding)' 현상이 발생함.

❌ 잘못된 오버라이딩 이해와 '메서드 숨김' 예시

Java

 

class SuperClass {
    static void print() {
        System.out.println("부모 스태틱");
    }
}

class SubClass extends SuperClass {
    // @Override ❌ 에러 발생: 스태틱 메서드에는 오버라이딩 마크를 붙일 수 없음
    static void print() {
        System.out.println("자식 스태틱"); // 부모 메서드를 가려버림(Hiding)
    }
}

public class Main {
    public static void main(String[] args) {
        SuperClass sub = new SubClass(); // 다형성 구조로 객체 생성
        sub.print(); // 💡 출력 결과: "부모 스태틱"
    }
}

• 이유 (컴파일 타임 바인딩): 일반 인스턴스 메서드는 프로그램 실행 도중(Runtime)에 진짜 힙에 있는 객체가 무엇인지 확인하고 메서드를 찾아감. 반면, static 메서드는 실행되기도 전인 컴파일 시점에 참조 변수의 '타입'만 보고 실행할 메서드를 미리 결정해 버림. 위 코드에서 sub 변수의 타입이 SuperClass이기 때문에 실제 알맹이가 SubClass일지라도 부모의 메서드를 실행해 버리는 것임.

◆ 최종 요약

• 부모의 static 변수와 메서드는 자식에게 상속되어 자식 이름으로 사용 가능함.
• 물리적으로 복사되는 것이 아니라 Static 영역의 단 하나의 자원을 부모와 자식이 공유하는 메커니즘임.
• static 메서드는 실행 시점이 아닌 컴파일 시점에 결합하므로 오버라이딩(다형성)이 불가능하며, 똑같이 만들 경우 단순히 부모의 메서드를 가리는 '메서드 숨김(Hiding)'이 일어남.

 

◆ 프로그램 오류 (Error)의 종류

컴퓨터 프로그램이 실행되는 과정에서 발생하는 오류는 발생 시점과 성격에 따라 3가지로 분류됨.

• 컴파일 오류 (Compile-time Error): 소스 코드의 문법이 틀려 자바 컴파일러(javac)가 실행 파일(.class)을 만들지 못하고 빨간 줄을 띄우는 오류임. 가장 안전하고 발견하기 쉬움.
• 논리적 오류 (Logical Error): 컴파일도 잘 되고 프로그램도 멈추지 않고 실행되지만, 개발자의 계산 실수 등으로 인해 원하는 결과가 나오지 않는 오류임 (예: 덧셈 연산에 뺄셈 기호를 넣음).
• 런타임 오류 (Runtime Error): 컴파일은 완벽히 끝났으나, 프로그램이 실행되는 도중(Runtime) 예측하지 못한 상황을 만나 강제로 고장 나는 오류임. 예외 처리는 바로 이 런타임 오류를 방지하기 위해 사용함.

◆ 오류 종료와 해결 방법

• 오류 종료 (Abnormal Termination): 런타임 오류가 발생하면 자바 가상 머신(JVM)은 즉시 구동을 중단하고 에러 메시지를 쏟아내며 프로그램을 강제 종료시킴. 웹 서버나 금융 프로그램의 경우 시스템 전체가 마비되는 치명적인 결과를 초래함.
• 해결 방법 (예외 처리 - Exception Handling): 프로그램이 급작스럽게 죽는 것을 막고, 오류가 발생했을 때 우회 도로를 개설하여 프로그램을 끝까지 정상 실행시키도록 제어하는 메커니즘임. 자바에서는 try - catch - finally 블록을 아키텍처로 사용함.
   

  try {
      // 💡 예외가 발생할 가능성이 있는 위험한 코드 배치
      int result = 10 / 0; 
  } catch (ArithmeticException e) {
      // 💡 예외가 발생했을 때 실행할 수습용 우회 코드 배치
      System.out.println("0으로 나눌 수 없습니다. 기본값으로 대체합니다.");
  } finally {
      // 💡 예외 발생 여부와 상관없이 무조건 마지막에 실행되어야 하는 정리 코드 (자원 해제 등)
  }
  

◆ 예외 클래스의 계층 구조

자바는 프로그램 실행 중 발생할 수 있는 모든 오류 상황을 '객체'로 만들어서 관리함. 따라서 오류도 부모-자식 상속 구조를 가짐.

• Throwable : 자바에서 오류로 던져질 수 있는 모든 클래스의 최상위 조상임.
• Error 후손: 시스템 메모리 부족(OutOfMemoryError)이나 하드웨어 고장 등 프로그램 코드로 수습할 수 없는 심각한 구조적 오류임. 개발자가 코드로 잡을 수 없음.
• Exception 후손: 개발자가 발생을 예측하고 코드를 통해 정상 상태로 수습할 수 있는 가벼운 오류임. 예외 처리의 직접적인 대상임.
  • Checked Exception: RuntimeException을 상속받지 않은 예외들. 컴파일러가 예외 처리를 무조건 명시하라고 강제함. 안 적으면 컴파일(빨간 줄) 자체가 안 됨 (예: IOException, SQLException).
  • Unchecked Exception: RuntimeException과 그 자식들. 컴파일러가 강제하지 않아 개발자의 주의력에 의존함.

◆ RuntimeException (Unchecked Exception)

예외 계층 구조 중 가장 독특하고 빈번하게 만나는 영역임.

• 특징: 주로 개발자의 논리적 오류나 코딩 실수(주의 부족)로 인해 발생하는 예외들을 모아놓은 클래스임.
• 매커니즘: 컴파일러가 수습 코드를 적었는지 감시하지 않기 때문에(try-catch를 안 써도 컴파일은 통과됨) 프로그램 실행 전까지 오류를 인지하기 어려움. 철저한 코드 검증과 예외 처리가 동반되어야 함.
• 대표적인 자식 클래스들:
  • NullPointerException : 객체 주소록이 비어있는 상태(null)인데 그 안의 변수나 메서드를 참조하려고 접근할 때 발생함.
  • ArrayIndexOutOfBoundsException : 배열의 크기가 5인데 6번 인덱스 칸을 열어달라고 요청할 때 발생함.
  • ArithmeticException : 정수를 0으로 나누는 등 수학적으로 불가능한 연산을 명령할 때 발생함.

◆ Java API Document 확인하는 예시

내가 쓰려는 자바 표준 메서드가 어떤 예외를 던지는지 알고 싶을 때 공식 API 문서를 확인하는 방법임. (주로 오라클 공식 사이트의 자바 API 문서를 기준함)

• 상황: 문자열을 정수로 바꿔주는 Integer.parseInt(String s) 메서드를 사용하려는 경우.
• 확인 순서:
  • 1. 문서 검색창에 Integer 클래스를 찾고, 메서드 리스트 중 parseInt(String s) 명세서를 찾음.
    1. 메서드 선언부 하단의 "Throws" 항목을 정밀 확인해야 함.
    1. 문서를 보면 Throws: NumberFormatException 이라고 명시되어 있음. 그 옆의 설명을 읽어보면 *"문자열이 정수로 변환될 수 있는 형태가 아닐 때 발생한다"*고 적혀 있음.
    1. 결과 매핑: 개발자는 이 명세를 보고 아래와 같이 방어 코드를 아키텍처에 미리 심어둘 수 있음.
  
  

   

  String input = "123abc"; // 숫자가 아닌 문자가 섞임
  
  try {
      int num = Integer.parseInt(input); // 💡 Throws 명세에 적힌대로 NumberFormatException 발생함
  } catch (NumberFormatException e) {
      System.out.println("숫자 포맷이 잘못되어 기본값 0으로 초기화합니다.");
  }

자바(Java)에서 예외를 수습하는 핵심 도구인 try - catch 문에 대한 구동 원리와 매커니즘 중심의 정리임.

◆ try - catch 문의 정의와 기능

• 정의: 프로그램 실행 중 발생할 수 있는 런타임 예외(오류)를 가로채서, 프로그램이 비정상적으로 죽지 않도록 방어막을 치는 제어문임.
• 기능: 예외가 발생했을 때 프로그램의 강제 종료를 막고, 개발자가 미리 준비한 우회 도로(대비책)를 따라 정상적인 실행 흐름을 유지시킵니다.

◆ try - catch 기본 구조 및 매커니즘

• try 블록: 예외(오류)가 발생할 가능성이 있는 위험한 코드를 모아두는 공간임.
• catch 블록: try 블록 안에서 진짜로 예외가 터졌을 때만 가동되는 비상 수습 공간임. 괄호 () 안에 수습하고자 하는 예외 객체의 타입을 명시해야 함.

◆ 예외 발생 시나리오별 구동 흐름

시나리오 ①: try 블록 내에서 예외가 발생한 경우 (비상 상황)

• 1. try 블록을 위에서부터 한 줄씩 실행하다가 예외가 발생하는 순간, 그 즉시 실행을 중단함 (밑에 남은 코드는 무시됨).
  1. 발생한 예외 객체와 일치하는 타입을 가진 catch 블록이 있는지 위에서부터 차례로 검사함.
  1. 일치하는 catch 블록을 찾으면 그 내부 코드를 실행하여 상황을 수습함.
  1. try-catch 전체 문을 빠져나가 그 다음 줄의 코드를 정상적으로 이어서 실행함.

시나리오 ②: try 블록 내에서 예외가 발생하지 않은 경우 (평화 상황)

• 1. try 블록 안의 모든 코드가 정상적으로 끝까지 실행됨.
  1. catch 블록은 실행되지 않고 통째로 패스됨.
  1. try-catch 전체 문 아래의 코드를 이어서 실행함.
  2.  

◆ 실무 코드 예시

❌ 예외 처리를 하지 않아 프로그램이 도중에 죽는 경우

 

public class Main {
    public static void main(String[] args) {
        System.out.println("프로그램 시작");
        
        int sVal = 10 / 0; // 💥 런타임 에러 발생 (ArithmeticException)
        
        // 에러 발생으로 인해 아래 코드는 실행되지 못하고 강제 종료됨
        System.out.println("연산 결과: " + sVal); 
        System.out.println("프로그램 정상 종료");
    }
}

⭕ try - catch 로 예외를 수습하여 안전하게 실행하는 경우

Java

 

public class Main {
    public static void main(String[] args) {
        System.out.println("프로그램 시작");

        try {
            System.out.println("💡 [try] 연산을 시도합니다.");
            int sVal = 10 / 0; // 💥 여기서 예외 발생! 즉시 catch 블록으로 순간이동함
            
            System.out.println("[try] 이 코드는 실행되지 않습니다."); 
        } catch (ArithmeticException e) {
            // 🚨 수습 가동
            System.out.println("⚠️ [catch] 에러 발생: 0으로 나눌 수 없어 결과를 0으로 처리합니다.");
        }

        // 💡 수습이 완료되었으므로 아래 코드가 정상 실행됨
        System.out.println("프로그램 정상 종료");
    }
}

◆ 다중 catch 블록 활용 규칙 (상속 계층 고려)

하나의 try 블록 안에서 여러 종류의 예외가 발생할 수 있다면, catch 블록을 아래로 여러 개 덧붙여 다중 방어벽을 세울 수 있음.

이때 부모-자식 상속 계층에 따라 자식 예외 클래스를 무조건 상위에, 부모 예외 클래스를 하위에 배치해야 함.

 

try {
    int[] arr = new int[3];
    arr[5] = 100; // 💥 ArrayIndexOutOfBoundsException 발생 가능성
    
    int num = Integer.parseInt("abc"); // 💥 NumberFormatException 발생 가능성
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("배열 인덱스 범위를 벗어났습니다.");
} catch (NumberFormatException e) {
    System.out.println("숫자로 바꿀 수 없는 문자열입니다.");
} catch (Exception e) {
    // 💡 모든 예외의 조상인 Exception은 맨 마지막에 배치하여
    // 위에서 걸러지지 않은 예상치 못한 모든 예외를 최종 수습하는 안전장치로 씀
    System.out.println("알 수 없는 예외가 발생했습니다.");
}

 

 

자바(Java)에서 모든 예외와 오류의 시조이자 최상위 가리키는 설계도가 바로 Throwable 클래스임.

자바 프로그램에서 throw 키워드를 통해 던져질 수 있는(Throwable) 모든 객체는 반드시 이 클래스를 상속받아야 메모리 아키텍처 상에서 예외 시스템으로 인식됨.

◆ 1. Throwable 클래스의 계층적 위치

자바의 모든 객체의 조상인 Object 바로 아래에 위치하며, 자식으로 Error와 Exception 두 개의 거대한 기둥을 거느리고 있음.

• java.lang.Object (최상위 객체)
  • └── java.lang.Throwable (모든 예외/오류의 시조)
    • ├── java.lang.Error (대형 사고: 코드로 수습 불가)
    • └── java.lang.Exception (일반 예외: 코드로 수습 가능)

◆ 2. 두 종류의 후손(자식) 구별 핵심

Throwable을 상속받은 자식들은 성격이 완전히 극단적으로 나뉨.

• Error 계열: JVM 내부 메모리 고갈(OutOfMemoryError), 스택 공간 오버플로우(StackOverflowError) 등 시스템 단위의 치명적인 결함임. 개발자가 코드 수준에서 try-catch로 가로채서 수습할 수 없으므로 무조건 프로그램이 죽음.
• Exception 계열: 개발자의 실수나 사용자의 잘못된 조작으로 인해 일어나는 가벼운 오류 상황임. 예측이 가능하므로 try-catch로 잡아내어 우회 도로를 개설(수습)할 수 있음.

◆ 3. Throwable 클래스의 핵심 내장 메서드 기능

Throwable 클래스는 자식들에게 예외가 발생한 상세 원인과 경로를 추적할 수 있는 강력한 핵심 메서드들을 물려줌. 개발자가 예외 처리를 할 때 가장 많이 사용하는 기능들임.

① getMessage() : 에러 메시지 반환

• 예외 객체 내부에 저장된 발생 원인에 대한 핵심 요약 한 줄 코멘트(문자열)를 리턴함.
• 코드 예시: System.out.println(e.getMessage()); ➡️ 출력: "/ by zero" (0으로 나누었을 때)

② toString() : 예외 이름과 메시지 통합 반환

• 발생한 예외 클래스의 풀 네임(패키지 경로 포함)과 에러 메시지를 결합하여 문자열로 내놓음.
• 코드 예시: System.out.println(e.toString()); ➡️ 출력: "java.lang.ArithmeticException: / by zero"

③ printStackTrace() : 추적 경로 상세 출력 (가장 중요)

• 예외가 최초로 발생한 소스 코드의 위치(클래스명, 메서드명, 줄 번호)부터 시작해서, 어떤 경로를 거쳐 변수가 타고 내려왔는지 스택(Stack) 영역의 메모리 이동 행적을 화면에 빨간 글씨로 전부 쏟아냄.
• 예외 처리를 하더라도 이 메서드를 내부에 심어두어야 개발자가 나중에 로그를 보고 버그를 잡을 수 있음.

◆ 4. 실제 작동 및 메서드 활용 예시

Java

 

public class ThrowableExample {
    public static void main(String[] args) {
        try {
            int[] arr = new int[2];
            System.out.println(arr[5]); // 💥 ArrayIndexOutOfBoundsException 발생
            
        } catch (Throwable t) { 
            // 💡 다형성 아키텍처: Exception의 조상인 Throwable 타입으로도 모든 예외를 다 받아낼 수 있음
            
            System.out.println("1. getMessage 결과: " + t.getMessage());
            System.out.println("-------------------------------------");
            
            System.out.println("2. toString 결과: " + t.toString());
            System.out.println("-------------------------------------");
            
            System.out.println("3. printStackTrace 결과:");
            t.printStackTrace(); // 콘솔에 상세 추적 이력 출력
        }
    }
}

• 출력 결과 데이터 매핑:
  • getMessage : "Index 5 out of bounds for length 2"
  • toString : "java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 2"
  • printStackTrace : 소스코드 몇 번째 줄에서 배열 방 번호 에러가 터졌는지 추적 경로를 로그로 출력함.

 printStackTrace

◆ 1. printStackTrace()의 핵심 기능

• 스택 메모리 추적: 예외가 터지기 직전까지 가상 머신(JVM)의 Stack 영역에 어떤 메서드들이 순서대로 쌓여서 실행되고 있었는지 그 계보를 전부 찾아내어 파일명, 메서드명, 소스 코드 줄 번호(Line Number)까지 명시함.
• 비정상 종료 없는 확인: try-catch문으로 예외를 가로챘기 때문에 프로그램은 정상 구동 상태를 유지하지만, 이 메서드 덕분에 내부에 어떤 심각한 버그가 있었는지 개발자가 육안으로 추적할 수 있음.

◆ 2. 콘솔 출력 결과 해체 (로그 읽는 방법)

예외가 발생했을 때 printStackTrace()가 쏟아내는 빨간 글씨의 로그는 가장 아래쪽 줄부터 위쪽 줄 순서대로 읽어 올라가야 함.

• 맨 아랫줄: 프로그램의 시작점(main 메서드)임.
• 중간 줄들: main에서 어떤 메서드를 타고 들어갔는지 이동 경로를 나타냄.
• 맨 윗줄: 최종적으로 예외가 발생한 진짜 원인(예외 클래스 이름 및 메시지)과 사건이 터진 최종 소스 코드 위치임.

◆ 3. 실무 코드 및 출력 매핑 예시

일부러 메서드를 3단계로 거쳐서 예외를 발생시킨 뒤 printStackTrace()가 스택 메모리를 어떻게 역추적하는지 보여주는 구조임.

Java

 

public class Test {
    public static void main(String[] args) {
        try {
            methodA(); // 💡 1. main에서 methodA 호출
        } catch (ArithmeticException e) {
            System.out.println("--- printStackTrace 출력 시작 ---");
            e.printStackTrace(); // 🚨 예외 추적 가동
            System.out.println("--- printStackTrace 출력 끝 ---");
        }
        System.out.println("프로그램은 죽지 않고 끝까지 실행됨");
    }

    public static void methodA() {
        methodB(); // 💡 2. methodA에서 methodB 호출
    }

    public static void methodB() {
        int crash = 10 / 0; // 💥 3. 여기서 최종 ArithmeticException 발생!
    }
}

📊 실제 콘솔 출력 결과 데이터:

Plaintext

 

--- printStackTrace 출력 시작 ---
java.lang.ArithmeticException: / by zero
	at Test.methodB(Test.java:19)
	at Test.methodA(Test.java:15)
	at Test.main(Test.java:5)
--- printStackTrace 출력 끝 ---
프로그램은 죽지 않고 끝까지 실행됨

• 추적 경로 해독:
  • 1. at Test.main(Test.java:5) ➡️ 5번째 줄에서 methodA()를 불렀음.
    1. at Test.methodA(Test.java:15) ➡️ 15번째 줄에서 methodB()를 불렀음.
    1. at Test.methodB(Test.java:19) ➡️ 19번째 줄에서 0으로 나누는 대형 사고가 터짐.
    1. java.lang.ArithmeticException: / by zero ➡️ 사고 원인은 수학적 연산 오류임.

◆ 4. 실무 운영 환경에서의 주의 사항 (보안 및 성능)

• 보안 취약점 발생: printStackTrace()는 소스 코드의 패키지 구조, 클래스명, 메서드명을 가감 없이 노출함. 만약 실제 서비스 중인 웹사이트 시스템 화면에 이 정보가 그대로 노출되면 해커에게 아키텍처 설계도를 넘겨주는 꼴이 되어 보안상 매우 위험함.
• 성능 저하: 이 메서드는 힙과 스택의 메모리 추적을 위해 시스템 자원을 생각보다 많이 소모함. 대규모 사용자가 몰리는 서버에서 남발하면 성능을 갉아먹음.
• 해결책: 현업 실무에서는 개발 중에만 콘솔로 확인하고, 실제 배포할 때는 콘솔 출력을 금지하며, Logback이나 log4j 같은 전문 로깅 라이브러리를 결합하여 안전한 파일 시스템 형태로 에러 로그를 기록 관리함.

자바(Java)에서 부모 클래스의 메서드를 자식 클래스에서 재정의하는 오버라이딩(Overriding)을 진행할 때, 메서드가 던지는 예외(Exception)에는 상속 관계에 따른 엄격한 아키텍처 규칙이 존재함.

자바 컴파일러는 다형성 구현 시 안정성을 보장하기 위해 이 규칙을 강제함. 핵심 규칙과 메커니즘을 팩트 위주로 해체함.

◆  예외 오버라이딩의 대원칙: "확장 불가, 축소 가능"

자식 클래스에서 메서드를 오버라이딩할 때, 부모 메서드가 던지던 예외보다 더 크거나(상위 클래스) 더 많은 종류의 Checked 예외를 던질 수 없음. 즉, 예외의 범위를 좁히거나 아예 던지지 않는 방향(축소)으로만 오버라이딩이 허용됨.

⚠️ 준수해야 하는 3대 예외 규칙

1. 더 상위의 예외 선언 불가: 부모 메서드가 IOException을 던진다면, 자식 메서드는 그 조상인 Exception이나 Throwable을 던질 수 없음.
2. 새로운 Checked 예외 추가 불가: 부모가 선언하지 않은 완전히 새로운 Checked 예외(예: SQLException)를 마음대로 추가할 수 없음.
3. 자식 예외 선언은 가능 (축소): 부모 메서드가 Exception을 던진다면, 자식 메서드는 그 자식 클래스인 IOException이나 NullPointerException으로 좁혀서 던지는 것이 가능함. 또한 예외를 아예 던지지 않도록 수정하는 것도 허용됨.

◆ 에러가 발생하는 잘못된 오버라이딩 예시

 

import java.io.IOException;
import java.sql.SQLException;

class Parent {
    // 💡 부모 메서드는 IOException(Checked Exception)을 던지도록 설계됨
    public void process() throws IOException {
        System.out.println("부모 처리");
    }
}

class Child extends Parent {
    // ❌ 컴파일 에러 발생: 부모보다 더 광범위한 상위 예외(Exception)를 던질 수 없음
    @Override
    public void process() throws Exception { 
        System.out.println("자식 처리");
    }
}

class Child2 extends Parent {
    // ❌ 컴파일 에러 발생: 부모 설계도에 없던 새로운 Checked 예외(SQLException)를 추가할 수 없음
    @Override
    public void process() throws SQLException { 
        System.out.println("자식 처리 2");
    }
}

◆ 정상적으로 작동하는 올바른 오버라이딩 예시

 

import java.io.FileNotFoundException;
import java.io.IOException;

class Parent {
    public void process() throws IOException {
        System.out.println("부모 처리");
    }
}

class ChildGood1 extends Parent {
    // ⭕ 가능: 부모가 선언한 IOException의 하위(자식) 예외인 FileNotFoundException으로 범위를 좁힘
    @Override
    public void process() throws FileNotFoundException {
        System.out.println("자식 처리 1");
    }
}

class ChildGood2 extends Parent {
    // ⭕ 가능: 자식 메서드 내부에서 예외를 완벽히 수습하여 외부로 아예 안 던지도록 축소함
    @Override
    public void process() {
        System.out.println("자식 처리 2");
    }
}

◆이러한 제약 규칙이 존재하는 이유: 다형성 보장

자바 컴파일러가 왜 자식의 예외 확장을 막는지 다형성 호출 구조 관점에서 해체해야 함.

Java

 

public class Main {
    public static void main(String[] args) {
        // 💡 다형성: 부모 타입 리모컨(Parent)으로 자식 객체(Child)를 조종함
        Parent obj = new Child(); 
        
        try {
            obj.process(); // 💡 컴파일러는 리모컨 타입인 'Parent.process()'의 명세만 보고 코드를 검사함
        } catch (IOException e) {
            // 개발자는 부모 명세에 적힌 IOException만 잡도록 대비책(catch)을 세워둠
            System.out.println("부모가 선언한 예외 수습 완료");
        }
    }
}

• 메커니즘 비틀기: 만약 자식 클래스인 Child가 오버라이딩을 하면서 부모 몰래 SQLException이라는 완전히 새로운 예외를 던지도록 허용해 버렸다면 어떻게 될까?
• 실제 프로그램 실행 시 obj.process() 구동 도중 SQLException이 터져 흘러나오게 됨. 하지만 상위 main 메서드에는 오직 IOException만 잡는 방어막(catch)만 쳐져 있기 때문에, 이 예외를 가로채지 못하고 프로그램이 그 자리에서 강제 오류 종료되는 치명적인 구멍이 생김.
• 자바 컴파일러는 이러한 다형성 구동 시의 런타임 붕괴를 원천 차단하기 위해, 오버라이딩 시 부모가 선언한 예외의 울타리를 자식이 절대 넘어가지 못하도록 규제하는 것임.

◆ 예외 규칙의 유일한 예외: RuntimeException

• Unchecked Exception(RuntimeException 계열)은 이 오버라이딩 제약 규칙에서 완전히 자유로움.
• 자식 클래스에서 오버라이딩할 때 부모 메서드가 선언하지 않은 NullPointerException이나 ArrayIndexOutOfBoundsException 같은 예외는 제한 없이 얼마든지 던지도록 추가할 수 있음.
• 이유: Unchecked 예외는 애초에 컴파일러가 try-catch 선언을 강제 감시하지 않는 영역이기 때문에 규칙 매핑 자체에서 제외하기 때문임.

데이터 이동 핵심 메커니즘인 입출력(I/O - Input/Output)과 스트림(Stream) 아키텍처를 팩트 기반으로 해체하여 정리함.

◆  입출력(I/O)의 정의와 기능

• 정의: 컴퓨터 내부 프로그램과 외부 장치(파일, 키보드, 모니터, 네트워크, 메모리 등) 간에 데이터를 주고받는 일련의 행위를 의미함.
• 기능: * Input (입력): 외부 장치에 존재하는 데이터를 프로그램 메모리 안으로 읽어 들이는 기능 (Read 연산)
  • Output (출력): 프로그램이 메모리상에서 연산한 데이터 결과물을 외부 장치로 내보내어 저장하거나 표시하는 기능 (Write 연산)

◆ 스트림(Stream)의 정의 및 핵심 개념

자바의 I/O는 스트림(Stream)이라는 모델을 통해 물리적인 장치 종류와 상관없이 동일한 방식으로 데이터를 제어함.

• 스트림의 정의: 데이터가 이동하는 '단방향 통로' 또는 '흐르는 물줄기'를 뜻함.
• 단방향성의 원칙: 하나의 통로(스트림)로는 한 가지 방향으로만 데이터가 흐를 수 있음. 즉, 입력과 출력을 동시에 처리할 수 없으므로 입력용 통로와 출력용 통로를 각각 별도로 개설해야 함.
• FIFO (First-In-First-Out): 통로에 먼저 들어간 데이터가 반대쪽 끝으로 먼저 나오는 선입선출 구조를 따름.

◆ 스트림(Stream)의 3대 분류 기준

자바는 효율적인 자원 제어를 위해 스트림을 세 가지 기준(방향, 데이터 형태, 기능)에 따라 명확하게 분류함.

기준 ①: 데이터 흐름의 방향에 따른 분류 (단방향 원칙)

• 입력 스트림 (Input Stream): 대상 목적지로부터 프로그램으로 데이터를 밀어 넣어주는 읽기 전용 통로.
• 출력 스트림 (Output Stream): 프로그램 내부 데이터를 대상 장치로 밀어내 주는 쓰기 전용 통로.

기준 ②: 다루는 데이터의 최소 단주(형태)에 따른 분류

데이터 알맹이를 어떤 크기로 쪼개서 전송하느냐에 따라 물리적 처리 방식이 완전히 나뉨.

• 바이트 스트림 (Byte Stream): * 데이터를 1바이트(byte, 8bit) 단위로 가공 없이 그대로 주고받는 가장 원시적이고 강력한 통로임.
  • 그림 파일(.jpg), 음악(.mp3), 동영상, 실행 파일(.exe) 등 모든 형태의 바이너리 데이터를 깨짐 없이 완벽하게 전송할 수 있음.
  • 클래스 이름 접미사: 입력은 ~InputStream, 출력은 ~OutputStream 형식을 취함. (예: FileInputStream)
• 문자 스트림 (Character Stream):
  • 데이터를 2바이트(2byte, 16bit) 단위로 쪼개어 전송하며, 전송 과정에서 자바 내장 인코딩(UTF-16 등) 규격에 맞춰 문자(Text)로 자동 번역해 주는 통로임.
  • 오직 텍스트 파일(.txt, .csv, 소스 코드) 전용이며, 영어 외의 전 세계 문자(한글, 한자 등 2바이트 이상 문자)가 깨지지 않도록 보장함.
  • 클래스 이름 접미사: 입력은 ~Reader, 출력은 ~Writer 형식을 취함. (예: FileReader)

기준 ③: 스트림의 역할 및 결합 아키텍처에 따른 분류

• 기반 스트림 (1차 스트림): 파일이나 메모리 같은 데이터 소스에 직접 빨대를 꽂아 통로를 개설하는 스트림임. 혼자서 데이터를 직접 퍼 올릴 수 있음. (예: FileInputStream, FileReader)
• 보조 스트림 (2차 스트림 / 필터 스트림): 데이터 소스에 직접 연결할 수 없음. 대신 이미 개설된 1차 기반 스트림 주변을 감싸서 버퍼 기능(속도 향상), 문자 인코딩 변환, 성능 업그레이드 등 부가 기능만 데코레이션해 주는 특수 스트림임. (예: BufferedInputStream, BufferedReader)

 

 

◆ File 클래스

 

 하드디스크 같은 물리적 저장 장치에 존재하는 실제 파일이나 디렉터리(폴더)를 자바 객체 아키텍처로 추상화하여 제어하는 도구임.◆ File 클래스의 객체 형성(생성) 방식 및 메커니즘

• 절대 경로: 드라이브의 최상위 루트부터 파일이 있는 위치까지 전체 경로를 전부 다 적어주는 방식임.
  • 예시: C:\java_project\test.txt
• 상대 경로: 현재 프로그램(프로젝트 폴더)이 실행되고 있는 위치를 기준점(./)으로 잡고 파일의 위치를 찾아가는 방식임. 경로 유연성이 높아 실무 아키텍처에서 훨씬 선호됨.
  • 예시: src/data/test.txt

◆ File 객체 형성 및 핵심 메서드 제어 예시

Java

 

import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        
        // 💡 1. 디렉터리(폴더) 제어용 File 객체 형성
        File dir = new File("src/myFolder");
        
        // 💡 2. 파일 제어용 File 객체 형성 (경로와 파일명 결합)
        File file = new File(dir, "sample.txt");

        try {
            // ◆ 물리적 폴더 생성 메커니즘
            if (!dir.exists()) { // 해당 경로에 폴더가 존재하지 않는다면
                dir.mkdir();     // 하드디스크에 진짜 폴더를 파냄
                System.out.println("📁 폴더 생성 완료");
            }

            // ◆ 물리적 파일 생성 메커니즘
            if (!file.exists()) {  // 해당 파일이 존재하지 않는다면
                file.createNewFile(); // 💥 Checked Exception 발생하므로 try-catch 필수 구조, 진짜 파일 생성
                System.out.println("📄 파일 생성 완료");
            }

            // ◆ 형성된 File 객체를 통한 상태 데이터 조회 기능
            System.out.println("--------------------------------");
            System.out.println("파일 절대경로: " + file.getAbsolutePath());
            System.out.println("파일 크기(Byte): " + file.length());
            System.out.println("읽기 가능 여부: " + file.canRead());
            System.out.println("쓰기 가능 여부: " + file.canWrite());
            System.out.println("이것은 파일인가?: " + file.isFile());
            System.out.println("이것은 폴더인가?: " + file.isDirectory());
            System.out.println("--------------------------------");

            // ◆ 파일 삭제 메커니즘 (테스트 필요 시 주석 해제)
            // if (file.exists()) {
            //     file.delete(); // 물리 파일 삭제
            //     System.out.println("🗑️ 파일 삭제 완료");
            // }

        } catch (IOException e) {
            // printStackTrace를 활용한 경로 역추적 에러 로그 출력
            e.printStackTrace(); 
        }
    }
}

◆ ⚠️ 주의 사항 및 구동 팩트

• 객체 생성 vs 물리 파일 생성 분리: File file = new File("test.txt"); 문장을 실행했다고 해서 하드디스크에 파일이 즉시 만들어지는 것이 아님. 단지 메모리 스택 영역에 주소 상자(자바 객체)만 파진 상태임.
• 존재 여부 확인 필수: 반드시 객체 형성 이후 file.exists() 메서드로 파일이 실제 하드디스크에 있는지 확인한 뒤, createNewFile()이나 mkdir() 메서드를 명시적으로 가동해야 물리 공간에 할당됨.

• 아래 코드는 상대 경로 구조를 사용하여 실제 파일 시스템에 물리적 파일과 폴더를 탄생시키고 속성을 조회하는 전체 시퀀스임.
• File 객체를 생성하기 위해서는 대상 파일이 위치한 물리적 경로(Path) 문자열을 지정해야 함. 이때 경로는 두 가지 방식으로 매핑할 수 있음.
• 실제 파일 내부의 데이터 알맹이를 읽고 쓰는 기능은 없으며, 파일의 경로, 이름, 크기, 수정 날짜 등을 조회하거나 파일을 생성, 삭제, 이름 변경하는 등의 외형적 관리 기능만 수행함.