- [Java 기본]다형성, Abstract, Interface, Inner Class

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

 

ex0920.zip

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

<목차>
1. 다형성
2. Abstract(상속)
3. Interface
4. Inner Class

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

1. 다형성 : 부모의 이름으로 자식을 컨트롤 하겠다.

  1.1 Overridng(재정의)
    1) 부모의 이름으로 자식의 메소드를 컨트롤 할 수 있지만, 멤버 Field는 컨트롤 할수 없다.
    2) 그중에서도 overriding 된 메소드만 컨트롤 할 수 있다.

    3) Sample Program
        class A {
          int x = 100;
          void view() {
            System.out.println(x);
          }
        }

        class B extends A {
          int x = 200;
          void view() {
            System.out.println(x);
          }
        }

        public class Sample
            {
            public static void main(String[] args) {
                A bp = new B();
                System.out.println(bp.x);   // 부모 A의 값을 출력하므로 100 출력
                bp.view();                  // 자식 B의 메소드가 호출되어 200 출력
            }
        }

  1.2 다형성의 개념
      - 다형성 : 형태가 많이 존재한다.

    1) 자식의 값을 부모에게 대입 시켜서 자식의 부분을 부모의 이름으로 사용하자는 개념
      a) 메소드가 overriding이 되어 있으면 자식 것을 먼저 실행 한다.
      b) 변수는 절대 자식의 것을 컨트롤 할 수 없다.
      c) overriding되지 않은 메소드는 컨트롤 할 수 없다.
      d) overriding된 메소드는 부모의 메소트 처럼 사용하면 된다.
        -> 모두 부모의 메소드처럼 처리하고, overriding 된 메소드만 자식의 메소드를 사용할 수 있다고 생각하면 쉽다.

      특징) 객체를 부모이름으로 만들고, 자식의 이름을 대입해서 사용하는 것.

    2) 우리가 상속 관계의 클래스를 만들었다고 가정하자.

                       Company  클래스
                       멤버   : String name
                                int age
                                void view() {  }
        상속 받음
               전산부       자재부       인사부         총무부
            String          int year        .             .
            String work        .            .             .
            void view() {

            }

        정보를 출력하는 view메소드를 각 부서마다 모두 만들고,

        각 부서의 정보를 보고자 한다면
        전산부 a = new 전산부();
         a.view();
        자재부 b = new 자재부();
         b.view();
        .
        .
        .
        와 같이 부서가 늘어날 수록 코딩이 복잡해 진다.

        이것을 해결하기 위한 방안으로 나온 것이 다형성의 overriding이다.
        Comp[] cp = new Comp[4];
        cp[0] = new 전산부();
        cp[1] = new 자재부();
        cp[2] = new 인사부();
        cp[3] = new 총부부();
        for(int i=0; i<cp.length; i++) {
          cp[i].view();
        }

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

2. Abstract(추상 = virtual(순수에 가까운)과 유사하다.)
    - 메소드와 클래스 지정어로 사용할 수 있다.

  2.1 Method -> abstract
    1) 형식) 접근자 abstract [다른지정어] 결과형 리턴값 Method명(매개들) 예외전가;
                   -> ;(세미콜론)으로 끝난다는 특징이 있다.
      -> 정의부(메소드 내용)를 가지지 않는 Method 이다.

    2) 사용용도(목적) : 디자인된 메소드를 만들때 사용한다.
      abstract 를 생략해도 끝에 ;를 찍으면 자바 컴파일러가 자동으로 abstract 라고 인식한다.
      -> 다형성에서 사용한 개념에서 view() {}를 부모 노드에 정의하여 overriding

  2.2 Abstract 클래스 특징
    1) 클래스 -> 단일 상속만 가능하다.
    2) 객체를 발생 시킬 수 없는 객체이다.
      ex) abstract class A { }
        A ap = new A();    // new A()부분 에러 발생

      ex2) abstract Method 를 포함하는 클래스도 자동으로 abstract 클래스로 인식 된다.
        class A {
            abstract void aaa();
        }

        A ap = new A();    // 사용 시 new A() 부분 에러 발생

   3) 포함멤버 : Constructor, Method, Field, abstract Method

   4) 사용형태 : 하위로 상속 시킨 다음 만약 abstract Method 가 존재하면 overriding 해야함
     ex) abstract class A { }
         class B extends A{ }
            A ap = new A();     // 안된다.
            A ap = new B();     // 잘 된다.
            B bp = new B();     // 잘 된다.
     
     ex) abstract class A { abstract void aaa(); }    // 형태로 되어 있다면
         class B extends A{ void aaa() { }}   // 와 같이 재정의를 해서 사용해야 한다.

   5) 디자인 + 효율성    

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

3. Interface
  3.1 Interface의 특징
    1) 클래스 -> 다중 상속
    2) 객체를 발생 할 수 없는 클래스 이다.
        ex) interfatc A{ }
            A ap = new A();   // new A()에서 에러 발생

    3) 포함 멤버 : 단 두가지 밖에 없다.
      a) Field : public static final 자료형 변수명 = 값    // 무조건 이 종류만 포함 할 수 있다.
        ex) 
            interface A {
                int x = 10;     //public static final가 생략되어 있는 형태이다.
            }
        A.x 와 같이 클래스명으로의 접근이 가능하다.(static이 생략된 형태이므로)

      b) Method : public abstract 결과형리턴값 Method명(매개변수) 예외전가;  //abstract Method만 포함을 시킬 수 있다.
        interface A {
            int x = 80;      //public static final 생략된 형태
            void aaa();      //public abstract가 생략된 형태
        }

    4) 하위클래스로 상속 시킨다음 존재하는 MEthod 모두를 overriding 해야함
        ex) 
            interface A { }    A ap = new A() // 사용 안됨

            interface B extends A { }    B bp = new B() // 사용 안됨
            class C implements B { }
            A ap = new C();    //사용 가능
            B bp = new C();    //사용 가능
            C cp = new C();    //사용 가능

            // 상위에 메소드가 존재하면 overriding이 있어야 한다. 

            5) 순수 디자인 목적으로 사용

//---------------------------------------------------------------------------//
질문
   ex) Abstract
    abstract class A {
        int x = 10;
        A(int x) {
            this.x = x;
        }
        abstract void view();
    }

    class B extends A {
        int x = 20;
        B(int x, int x1) {
            super(x);
            this.x = x;
        }
        void view() {      // view1()이나 int view(), view(int x)라고 하면 overriding 되어있지 않으으므로 A bp = new B();  에서 에러가 발생한다. abstract 정의를 필요로 한다는 에러 메세지 출력됨.
            System.......(super.x);
            System.......(this.x);
        }
    }
    
    A ap = new A();     // 안됨 -> abstract 클래스이므로...
    A bp = new B();     // 실행 가능
    System.out.println(bp.x);      // 10출력

    abstract 메소드를 재정의 하지 않으면.. 에러메세지를 발생한다.


  ex) interface
    interface A {
        int x = 100;
        void view();
    }
    class B implements A {
        int x = 200;
        //B(int x, int x1) {
        // super(x);  //인터페이스는 생성자를 가질 수 없으므로 에러가 발생한다. super가 올수가 없다.
        B(int x) {
            this.x = x;
        }
        public void view() {      // void view() 로 사용하면 에러 발생 -> 클래스 A의 view()는 .. public abstract 가 생략되어 있기 때문이다.
            System.out.println(super.x);
            System.out.println(this.x);
        }
    }

    A ap = new A(); // 사용 안됨
    System.out.println(A.x);    // 100출력
    A.view();
    A ap = new B();
    B bp = new B();
    System.out.println(B.x);    // 200출력
    ap.view();                  // 두개 모두.. B의 view가 실행 된다.
    bp.view();

다이아 몬드 상속.. Ex0114_01로 만들 것임.


//---------------------------------------------------------------------------//
4. Inner 클래스
  4.1 중첩 클래스
    1) 사용 목적
      a) 접근상에 제약을 두기 위해서 
      b) 클래스 이름의 충돌 방지
      c) static을 사용할 수 없다.

    2) 형식 : 일반 클래스가 가질 수 있는 것은 모두 가질 수 있고, 클래스 자체를 덩어리 통체로 포함 시킬 수 있다.
       밖의 클래스를 Outer클래스라 하고, 안쪽에 있는 것을 Inner라고 한다.

    class A {
        int ..
        A () { };
        class B {

        }
    }

      - 2개의 .class 파일이 생성 된다.
        -> 파일명 : A.class 와 A$B.class 두개의 파일이 생겨 난다.
      // 내부로 들어갈 수록 $표시가 붙는다.
      // 이름 끼리의 충돌을 방지 시킬 수 있다.

    class A {
        int x = 10;
        class B {
            int y = 20;
        }
    }

    -> y값을 출력 하기 위해서의 접근 방법
       A ap = new A();
       A.B bp = ap.new B();     // ap.B bp = ap.new B();로는 에러가 발생한다.
       System.out.println(bp.y);

    -> static을 사용하기위해서는 정적 중복 클래스로 만들면 된다.
    class A {
        int x = 10;
        static class B {
            int y = 20;
        }
    }
    A.B bp = new A.B();  // 정적 중첩 클래스는 객체의 이름으로 바로 만들어 사용할 수 있다.

    -> 다음과 같은 파일이 있을때..
    public class A {
        public static class B {
            public static void main(String [] ar) {
                System.out.println();
            }
        }
    }

    다음의 파일명은 -> A.java
    컴파일시 두개의 파일이 생김 A.class, A$B.class 파일이 생긴다.
    실행을 시킬 때는 java A$B 로 실행을 해야 실행이 된다.

  2. 정적 중첩 클래스

  3. 지역 중첩 클래스
    -> 현재는 거의 사용하지 않는 클래스

  4. 익명 중첩 클래스
    -> 지역 중첩클래스의 확장..
    -> 내일 배울 것이다.. awk event part에서 배우게 될 것이다.

과제.. 상속성과 다형성 공부해 올것..


//---------------------------------------------------------------------------//
// 수업중 소스
// Ex0114_1.java
class A {
  public String toString() {
      return "AAA";
    }
}

class B {
  public String toString() {
      return "BBB";
    }
}

class C {
  public String toString() {
      return "CCC";
    }
}

public class Ex0114_1 {
    public static void main(String [] ar) {
        A ap = new A();
        System.out.println(ap);
        B bp = new B();
        System.out.println(bp);
        C cp = new C();
        System.out.println(cp);

        Object[] ob = new Object[3];
        ob[0] = new A();
        ob[1] = new B();
        ob[2] = new C();

        for(int i=0; i < ob.length; i++)
            System.out.println(ob[i]);
    }

}


//---------------------------------------------------------------------------//
// FirstInter.java
public interface FirstInter {
    int red = 1;
    int green = 2;
    int blue = 3;
}

// FirstClass.java
public abstract class FirstClass implements FirstInter{
    private String str;
    public FirstClass(String str) {
        this.str = str;
    }
    public String getText(){
        return str;
    }
    public abstract void viewText();
}


// FirstInter.java
public interface SecondInter extends FirstInter{
    void viewColor();
}

// SecondClass.java
public class SecondClass extends FirstClass implements SecondInter {
    public SecondClass(String str) {
        super(str);
    }
    public void viewColor() {
        System.out.println("Red = " + red);
        System.out.println("Green = " + green);
        System.out.println("Bluew = " + blue);
    }
    public void viewText() {
        System.out.println("문자열 = " + getText());
    }
}



public class Ex0114_02 {
    public static void main(String[] ar){
        SecondClass sc = new SecondClass("Test");
        System.out.println(sc.red);
        System.out.println(sc.blue);
        System.out.println(sc.green);
        System.out.println(SecondClass.red);
        System.out.println(sc.getText());
        sc.viewColor();
        sc.viewText();
        
        
        /*
        FirstClass fc = new SecondClass("Test");
        System.out.println(fc.red);//FirstClass.red
        System.out.println(fc.green);//FirstClass.green
        System.out.println(fc.blue);//FirstClass.blue
        System.out.println(fc.getText());
        //fc.viewColor();
        fc.viewText();
        */
        
        
        /*SecondInter si = new SecondClass("Test");
        System.out.println(si.red);//SecondInter.red
        System.out.println(si.green);//SecondInter.green
        System.out.println(si.blue);//SecondInter.blue
        //System.out.println(si.getText());
        si.viewColor();
        //si.viewText();
        */
        
        
        /*FirstInter fi = new SecondClass("Test");
        System.out.println(fi.red);//FirstInter.red
        System.out.println(fi.blue);//FirstInter.blue
        System.out.println(fi.green);//FirstInter.green
        //System.out.println(fi.getText());
        //fi.viewColor();
        //fi.viewText();
        */
    }
}

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

 

>>>>> 답글들

예전에 강사님께 말로 설명 들을때의 뉘앙스랑 노트의 뉘앙스가 사뭇 많이 달라서
오역할 수도 있을 것 같은데, 가능하면 샘플 위주로 해서 이론적인 것은 좋은 책의
좀 지루하더라도 체계적인 설명들을 볼 것을 추천합니다.
 
다형성의 활용적인 면에서 보자라면 클래스의 구성요소 중에서 메소드보다는 멤버
즉 데이터라는 면에서 많이 활용합니다.

파라미터를 넘기거나 받을 때에 메소드를 오버라이드 하거나 오버로딩 하기도 하지만
다형성을 이용하게되면 instanceOf 연산자 등을 통한 동적인 파라미터에 대한 
동적인 비즈니스 처리를 할 수 있으니까요.

물론, 요즘은 XML 이나 기타 여러가지 방법들이 많이 등장해서 개발자들이 직접적으로
다형성을 쓰기보다는 기반이 되는 라이브러리나 API 등에서 보통 이런 기법들을 많이
활용해서 쓰고 있죠.

예를들어 sql 문장에 대한 쿼리 처리를 할때에 String 변수를 쓰는 사람도 있고,
StringBuffer 를 쓰는 사람도 있고, StringBuilder 를 쓰는 사람도 있습니다.

이런 케이스를 다 만족하는 처리를 하고자 할때에 메소드의 파라미터를
CharSequence 로 해주게 되면 구별없이 동일한 처리를 할 수도 있죠 ^^;

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

글쎄.. 나도 다형성은 필요한 경우만 사용을해서리.. 개념적으로도 대충 잡고 있는 형태이고...
일반적으로 설계 단계에서 공통적인 부분을 인터페이스나 추상클래스로 정의 후에 구체적인 기능들을 구현하곤 하지요. 
혹은 기존에 존재하는 라이브러리에 필요한 부분을 약간 첨가해서 제것에 맞게 사용할때도 간혹 사용하곤 합니다.
상속을 이용하는 가장 큰 이유는 모듈간의 약속을 정의할 수가 있다는것이 아닐까 생각합니다.
글자만을 이용해서 예를 들기가 만만치 않군요. A라는 클래스는 abc(B b)라는 메소드가 있고 B가 Interface라면, 그리고 abc 메소드에서 하는 역할이 b.makeEvent(event) 이렇게 메소드를 호출하는 역할을 한다면.. 저는 B를 상속받은 클래스를 만들고, 그것에 makeEvent 메소드를 구현하면 되겠지요.. abc 메소드에서 전달해 주는 event를 받아서 파일로 저장하건 DB로 저장하건, 화면으로 출력하건 이런건 저의 몫이구요.. 저는 그냥 A클래스에 abc메소드를 호출하며 제가 구현한 B 클래스를 던져주기만 함녀 되겠죠..