- [Java 기본]예외처리, 클래스 상속

출처 : http://cafe.naver.com/litave/366

ho0113.zip

 
//===========================================================================//
  본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
  작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. 예외처리
2. 상속성

//---------------------------------------------------------------------------//

* 예외처리

o 예외처리를 배우는 목적
  1) 예외 발생 시 정상적인 종료를 위하여
  2) 예외 발생 시 대안적인 결과를 주기위하여
  3) 예외 발생 시 무시하고 계속 실행 시키기 위하여

o 예약어
  1) throw
  2) throws
  3) try ~ catch ~ finally


1. 예외의 개념 잡기
  1) 예외 처리기
    예제 -> Ex0113_01
    Su1과 Su2를 입력 받는다.
    a) 숫자를 받아야할 자리에 문자를 입력하면 NumberFormatException 이 발생한다.
        -> 사용자가 런타임시 발생할 수 있는 에러이다.
  *참고) 자바는 컴파일 에러와 런타임 Exception 으로 구분한다.

    b) 정수를 0으로 나눈 경우 ArithmeticException
     -> 실행 중에 발생한 것 사용자가 실행을 해 보아야 알 수 있는 것이다..
     -> 일단 실행을 해보아야 알수있는 에러들을 예외라고 한다.
     -> 에러 발생시 자바 프로그램은 비정상 종료를 하게 된다. 이런 것을 방지 하기 위하여 Exception을 처리 한다.

2. 예외 처리시 만나는 예약어
  1) throw : 예외 발생
    -> Client 에게 프로그램을 잘못 되었다는 것을 알려 줄때.
   사용 예)
     if(Su1 < 0) {    //특정 조건시 임의의 에러 출력 가능
       NumberFormatException nfe = new NumberFormatException("음수 입력하면 안된다.");
       throw nfe;
            //에러가 발생 한 사항을.. 던저 줄수도 있다.
     }

  2) throws : 예외 전가
   -> 예외를 전달 전달 시킨다.
   -> 하나의 Method에서 throws IOException 을 사용하면 그 Method를 사용하는 부분에서도 예외 전가를 시키기 위해서(throwsIOException) 혹은 try catch 를 사용해야 한다.

  3) try ~ catch ~ finally
          ^예외 처리기(catch:다섯가지 예약어 중에서 유일한 예외 처리기 이다.)

  예외 처리 
    a) try : 예외가 발생되리라 예상되는 지역을 블럭으로 묶어서 관리 하는 예약어
        -> 프로그래며는 사용자의 입장을 고려하여 예외 발생 예상 지역을 알아야 한다.
        사용예:
        try {
            예외 발생 예상 지역
        } catch(NumberFormatException nfe) {
            이부분에.. 예외 상황 발생시 처리할 프로그램 구문을 적어주면 된다.
        } catch(ArrayIndexOutOfBoundsException afe) {

        }

       -> 문제점 : 어떤한 경우에도 에러가 발생하지 않는 부분을 묶으면 프로그램 자체에서 에러가 발생한다.(적어도 한라인은 에러 발생 유발 지점이 포함되어 있어야 한다.)

       * 참고) 블럭안에서 선언된 변수는 블럭을 빠져 나가면 사라진다.(공통 사항)

    b) catch
        -> NumberFormatException 이 발생하면 이것을 잡아서(catch) 예외 발생시 담아 둘수 있는 공간이 필요하다.
        -> 그리고 그 다음 블럭에 다음 처리할 명령어를 적어 준다.
        -> 아무것도 적지 않으면 무시하고 그냥 넘어 간다.
        -> catch 는 여러번 적을 수도 있다.(발생할 수 있는 예상 에러 수 만큼) if ~ else 를 연상 하면 된다.

    c) finally 적지 않아도 되는 선택 사항이다.
        -> 에러가 발생하던 발생하지 않던 간에 무조건 실행하고 싶은 구문을 여기다 적어 준다.
        -> 무조건적으로 실행하는 구문 이다. break;나 return;문을 중간에 만나더라도 이것은 무조건 실행 한다.
           (단, System.exit(0); 는 프로세서가 아예 죽는 상황 이므로 이부분에서만 실행 되지 않는다.)

//---------------------------------------------------------------------------//

* 상속성

o 누군가가 임의의 클래스 A를 만들었다고 하자.
    class A {
        String name;
        int age;

        A() {
            name = null;
            age = 0;
        }

        A(String name, int age) {
            this.name = name;
            this.age = age;
        }

        void disp() {
            System.out.println(name);
            System.out.println(age);
        }

    }

    - 위의 클래스에서 전화번호 까지 관리하는 클래스를 만들고 싶다는 생각이 들었다..
    - 또 누군가는 주소까지 관리하는 클래스를 만들고 싶다는 생각을 하게 되었다.
    - 이렇게 동일한 기능을 가지는 클래스가 있는데도 계속해서 만들면 다른 사람이 만든 클래스는 의미가 없어 진다.
      그래서 이것을 간단히 사용하고 싶은 생각이 들었다.
      그래서 나온 것이 포함 오브젝트라는 개념이 나왔다.


    class B {
        A ap = new A();
        String tel;
        .
        .
    }


    class C {
      B bp = new B();
      String addr();
    }

    1) 포함 오브젝트를 사용하더라도
    2) 상위 클래스로 접근을 하기 위해서는 cp.addr,  cp.bp.tel, cp.bp.ap.name  등으로 사용하게 되면,
     사용자가 너무 복잡 하게 되어서 나온 개념이 상속 성이다.
    3) 상속성은 상위 부모 클래스의 것을 그대로 받아서 사용해야 한다.


//---------------------------------------------------------------------------//

1. 상속성
  1) 형식 
      접근자 지정어 class 클래스명 extends 상위클래스 {     }
    a) 일반 클래스와 동일 하지만 extends 를 사용해서 상위 클래스를 지정할 수 있다.
    b) Object 를 최상위 클래스로서 가진다.
    c) 자바의 클래스 상속은 Object 를 제외하고는 단일 상속만 가능하다.
    d) 상위 멤버를 지칭 할 때는 예약어로서 super 를 사용하고 하위 멤버를 지칭 할 때는 예약어로서 this 를 사용한다.
      * 참고) 상위의 상위 클래스를 나타 낼 때는 super.super 을 하면 된다.

    e) 생성자는 상속이 되지 않는다. -> 상위 클래스의 생성자는 super() 메소드를 사용할 수 있고.
                                    -> 하위 클래스의 생성자는 this() 메소드를 사용할 수 있다.

    f) private, public, package, protected 는 상속이 무조건 된다.(메모리 할당이 된다.)
       -> 디폴트 값을 가진다.
       -> 그러나 private 은 상속은 되지만 사용을 할 수 없다.
       -> 접근자의 역할은 멤버 Field 의 사용을 할 수 있는가? 없는가?를 나타내는 것이다.

  2) 기본적으로 모든 것을 상속한다는 개념으로 클래스를 만들어 보자
      class A {             // 하나의 점을 관리 할 수 있는 클래스
        protected int x;    //상속 관계에서는 사용할 수 있게 하기위해 protected를 사용 하였다.
        protected int y;
        public A() {
          x = y = 0;
        }
        public A(int i, int y) {
          this.x = x;
          this.y = y;
        }
        public void view() {
          System.out.println("x = " + this.x);
          System.out.println("y = " + this.y);
        }
      }
      
      class B extends A { //x, y, view
        private int x;
        private int y;
        public B() {
          x = y = 0;
        }
        public B(int x, int y, int x1, int y2) {
          super.x = x;      super.y = y;
          this.x = x1;      this.y = y1;
        }
        public void view() {
          System.out.println(super.x);
          System.out.println(super.y);
          System.out.println(this.x);
          System.out.println(this.y);
        }
      }

    // 하지만 대부분의 사람은 private를 사용한다.
      class A {             //하나의 점을 관리 할 수 있는 클래스
        private int x;
        private int y;
        public A() {
          x = y = 0;
        }
        public A(int i, int y) {
          this.x = x;
          this.y = y;
        }
        public void view() {
          System.out.println("x = " + this.x);
          System.out.println("y = " + this.y);
        }
      }
      

    // 누군가 이 클래스를 이용하여 사각형을 그리고 싶다.

      class B extends A { //x, y, view
        private int x;
        private int y;
        public B() {       //자바에서는 { (블럭의 시작)의 다음에 super(); 가 있다고 가정 하고 디폴트로 이것이 생성된다.
          x = y = 0;       
        }
        //super메소드나 this메소드 모두 블럭의 시작 다음에 위치해야 하기 때문에 일반적으로 this메소드를 사용하지 않는다.
        //위의 특징으로 둘중 하나만 사용을 해야 한다.
        public B(int x, int y, int x1, int y2) {
          super(x, y);   //super.x = x;      super.y = y;
                         //이렇게 사용한다.
          this.x = x1;
          this.y = y1;
        }

        //같은 이름을 가지고 있을때는 super를 사용해야 한다.
        //super를 적지 않는 것은 기본적으로 this가 붙는다.
        public void view() {
          super.view();        //  System.out.println(super.x);
                               //  System.out.println(super.y);
          System.out.println(this.x);
          System.out.println(this.y);
        }
      }

// 상속 관계에서
// 메소드 이름이 같고 매개 변수가 다르면(갯수, 타입) -> overloading 이라고 하고

// 메소드 이름이 같고, 매개변수의 타입과 개수가 같은면 -> overriding(메소드 재정의)라고 한다.
// 이것은 this와 super를 사용해서 구분 해 주어야 한다.
// 상단부에 예외 전가가 있으면 무조건 예외 전가를 시켜 주어야 한다.

중요 채크 사항)
  a) 상단부의 접근자가 protected이면, 하단부의 재정의 접근자는 protected이거나, public일 수 있다.
  b) 상단부의 접근자가 package이면, 하단부의 재정의 접근자는 package이거나, public일 수 있다.
  c) 상단부의 접근자가 public이면, 하단부는 public일 수 밖에 없다.


다이아몬드 그램..
1. 인터페이스는 클래스에 상속을 줄 수 있지만 클래스는 인터페이스에 상속을 줄 수 없다.
2. 클래스는 단일 상속만 가능하고, 인터페이스는 다중 상속을 할 수 있다.


//---------------------------------------------------------------------------//

오늘의 과제 :
** 그림 그리기 **
1. 원 그리기
2. 사각형 그리기
3. 그림 전체 보기
4. 종료
--->  1                  //무한적으로 돌면서 실행 되어야 한다.
x = 12
y = 12
r = 5
원이하나 저장되었습니다.

---> 2
x = 30
y = 20
w = 7
h = 10
사각형이 저장 되었습니다.

---> 3                        // 만들지 않아도 된다.
원 : 점좌표 x = 12, y = 12
     반지름 r = 5
사각형 : 점좌표 x = 30, y = 20
         폭 = 7, 높이 = 10

---> 4 
종료



//---------------------------------------------------------------------------//
// 수업중 소스 : Ex0113_01.java
import java.io.*;
public class Ex0113_01 {
    public static void main(String[] ar) throws IOException{
        BufferedReader br = new BufferedReader(
                                new InputStreamReader(System.in));
        int su1, su2, tot;
        su1 = su2 = tot = 0;
        boolean err = false;
        
        do{
            System.out.print("Su1 = ");
            try {
                su1 = Integer.parseInt(br.readLine());
                err = false;
            } catch(NumberFormatException nfe) {
                System.out.println("ErrorMessage = " + nfe);
                System.out.println("숫자를 입력하셔야 합니다.");
                err = true;
            }
        } while(err);
        
        
        do{
            System.out.print("Su2 = ");
            try {
                su2 = Integer.parseInt(br.readLine());
                tot = su1 / su2;
                err = false;
            } catch(NumberFormatException nfe) {
                System.out.println("ErrorMessage = " + nfe);
                System.out.println("숫자를 입력하셔야 합니다.");
                err = true;
            } catch(ArithmeticException ae) {
                System.out.println("ErrorMessage = " + ae);
                System.out.println("정수연산에서 0으로 나누시면 안됩니다.");
                err = true;
            }
        } while(err);
        
        
        System.out.println("su1 / su2 = " + tot);
        
    }
}


//---------------------------------------------------------------------------//
// 수업중 소스 : Point1.java
import java.io.*;
public class Point1 {
    private int x;
    private int y;

    public Point1() throws IOException {
      System.out.print("x = ");
        x = System.in.read();
        if(System.in.read() == '\r') System.in.read();
      System.out.print("y = ");
        y = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }
    
    public Point1(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public void view() {
        System.out.println("x = " + this.x);
        System.out.println("y = " + this.y);
    }
}


// 수업중 소스 : Rect1.java
public class Rect1 extends Point1 {
    private int w;
    private int h;
    
    public Rect1() throws IOException {
//    super();
        System.out.print("w = ");
        w = System.in.read();
        if(System.in.read() == '\r') System.in.read();
        System.out.print("h = ");
        h = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }
    
    public Rect1(int x, int y, int w, int h) throws IOException {
        super.view();
        this.w = w;
        this.h = h;
    }
    
    public void view() {
        super.view();
        System.out.println("w = " + this.w);
        System.out.println("h = " + this.h);
    }
}

// 수업중 소스 : Circle1.java
import java.io.*;

class Circle1 extends Point1 {
    private int r;
    
    public Circle1() throws IOException {
      super();
        System.out.print("r = ");
        r = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }
    
    public Circle1(int x, int y, int r) throws IOException {
      super();
        this.r = r;
    }
    
    public void view() {
        super.view();
        System.out.println("r = " + this.r);
    }
}

//===========================================================================//

>>> 답글들

예외처리에 대해서 약간 첨언하자면...
Java Checked Exception은 java.lang.Exception을 상속한 Exception으로 컴파일 시점에 이 Exception을 try~catch 구문으로 처리하지 않는 경우 에러가 발생한다. 예를 들어 java.io.IOException이 대표적인 Checked Exception 이다.
Unchecked Exception은 java.lang.RuntimeException을 상속한 Exception으로 컴파일 시점에 try ~ catch 구문으로 처리하지 않아도 컴파일 에러가 발생하지 않는다. 예를 들어 java.lang.NullPointerException이 대표적인 Unchecked Exception이다.
참고자료) Spring 프레임워크 워크북 : 한빛미디어 87 페이지

-------------------------------------------------------------------------------------------------------

상속(inheritance)과 구성(composition)에 대해서
일반적으로 사용이 편한 상속을 주로 사용하지만, 패턴관련 책들을 읽다보면 구성을 활용하는 것이 더 나은 방향이라고들 합니다. 
몇몇 이유가 있겠지만 생각나는 것은 상속을 사용할 경우 상위 클래스와의 종속 관계가 너무 강해지고, 하위 클래스에서 상위 클래스의 변경 여부를 체크해야 하지만,
구성을 이용할 경우 해당 클래스를 선언 후 사용하는 형태이므로, 자신이 사용하는 메소드에 대한 안정성만 보장 받으면되기 때문 이었던 것으로 기억납니다. ㅎㅎ..

-------------------------------------------------------------------------------------------------------

OOP관점에서 보면 link 에는 association 과 inheritance 가 있죠... 

저도 첨에는 inheritance 를 이용하는 extends 나 implements 를 많이 사용했었는데,
inheritance 는 강한 결합입니다.

하지만, 프로그램의 유지보수, 분업을 위한 모듈화 등을 보면 약한 결합을 많이 강조하죠.

그리고, 최근에 관심가지는 퍼포먼스나 튜닝면에서도 컴파일러관점에서 override 체킹이라는 것이
악영향을 미치는 것 중에 하나라고 알게되면서 부터...

association 형태의 약한 결합들을 많이 씁니다

-------------------------------------------------------------------------------------------------------

아무래도 자바도 SmallTalk를 기원으로 하는 언어다보니 "모든 것은 객체다." 라는 철학에 너무 심취하면
상속이 멋있어보이고 그를 이용한 구현도 많이 하게 됩니다만...

시스템이란게 하다보면 하나의 객체에서 그를 확장해 나가는 형태는 매우 특수하거나 혹은 소규모이거나 혹은 작은 부분일때이고 대게는 매우 다양한 객체의 조합들과 관계로 이뤄지게 되죠. 

겉보기에는 상속인거 같으면서도 실제론 관계로 풀어나가는 경우도 많구요 ^^..

최근에는 언어의 철학이란 것도 좀 생각해보면서 Ruby 란 것에도 많이 관심이 갑니다. ㅋㅋ

-------------------------------------------------------------------------------------------------------