[CH07] 객체지향프로그래밍2 (OOP)

본 포스팅은 자바의 정석 교재를 공부하며, 간단히 정리/기록 용도로 작성하였습니다. 혹여, 잘못된 내용이 있다면 지적해주시면 감사하겠습니다.

 

---

1. 상속(Inheritance)

  [상속의 정의와 장점]

상속이라는 것은 기존 클래스를 활용하여 새로운 클래스를 작성하는 것을 말하며, 이를 이용하면 보다 적은 양의 코드로 새로운 클래스를 작성할 수 있고 관리가 용이해진다. 이를 통해 코드의 재사용성을 높이고 중복을 제거하여 생산성과 유지보수에 크게 기여할 수 있게된다. 자바에서 상속을 구현하려면 새로 작성하고자 하는 클래스 이름 뒤에 extends 를 작성해주면 된다.

 

class Child extends Parent { ... }

 

위와 같이 하면 Child 라는 새로운 Class 는 Parent 라는 Class 로부터 상속받는다는 것이다. 이러한 관계에서 Parent 는 조상 클래스(부모/parent 클래스, 상위/super 클래스, 기반/base 클래스) 라고 하며, Child 는 자손 클래스(자식/child, 하위/sub, 파생/derived) 라고 한다. 클래스 간의 관계를 그림으로 표현하기도 하는데 이는 상속계층도(class hierarchy) 라고 한다. 

https://www.researchgate.net/figure/The-asset-class-hierarchy_fig2_228584037

 

Parent 클래스에 멤버 변수를 하나 추가하면 자식 클래스는 부모 클래스의 멤버를 모두 상속받아서, child 클래스에는 자동적으로 해당 멤버 변수를 가지게 된다. 그러면 반대로 자식 클래스에 메서드를 하나 추가하면 어떻게 될까? child 클래스에 추가적으로 코드를 작성하더라도 Parent 클래스는 아무런 영향을 받지 않는다. 자손 클래스는 조상 클래스의 모든 멤버들을 상속받기 때문에, 상속을 거듭할 수록 자식 클래스는 더 많은 멤버를 가지게 될 것이다. 상속을 받는다는 것은 그래서 조상 클래스로부터 확장(extend)된다는 개념으로 이해할 수 있고, 이것이 상속을 지정하는 키워드가 extends 인 이유가 되기도 한다.

 

- 생성자와 초기화 블럭은 상속되지 않으며, 멤버만 상속된다.

- 또한 자손 클래스의 멤버 개수는 조상 클래스보다 항상 같거나 많다.

 

Parent 클래스로부터 상속받은 Child, Child2 클래스가 있다고 생각해보자. 각각의 클래스는 상속받은 클래스와의 멤버를 공유하나, Child 와 Child2 는 서로 아무런 관계도 성립되지 않음에 주의하자. 클래스 간의 관계에서는 부모 - 자식 관계만 존재하며, 형제 관계는 고려치 않는다. 상속 관계가 복잡해지더라도 코드의 변경이 필요한 경우, 최상단 클래스의 코드만 변경하면 모두 반영되기 때문에 코드의 중복을 방지하고 유지보수가 쉬워진다.

 

class Parent {...}

class Child extends Parent { ... }

class Child2 extends Parent { ... }

class GrandChild extends Child { ... }

 

위와 같이 작성하면, GrandChild 클래스는 Child 클래스와 Parent 클래스의 모든 멤버를 상속받는다. 이러한 경우 GrandChild 클래스와 Parent 클래스는 서로 간접 상속 관계에 놓여있다고 표현한다. Parent 클래스에 하나의 멤버 변수를 추가한다면, Child, Child2 클래스는 이를 상속받는다. 그리고 GrandChild 클래스 또한 Child 클래스를 상속받으므로 반영된다. 전체 프로그램을 구성하는 클래스들을 적절하게 설계해주는 것이 객체지향 프로그래밍에서 가장 중요한 부분이다.

class Tv{
    boolean power;
    int channel;

    void power(){power = !power;}
    void channelUp(){++channel;}
    void channelDown(){--channel;}
}

class CaptionTv extends Tv{
    boolean caption;
    void displayCaption(String text){
        if(caption){
            System.out.println(text);
        }
    }
}

class source{
    public static void main(String[] args) {
        CaptionTv ctv = new CaptionTv();
        ctv.channel = 10;
        ctv.channelUp();
        System.out.println(ctv.channel);
        ctv.displayCaption("Hello, World");
        ctv.caption = true;
        ctv.displayCaption("Hello, World");
    }
}

자손 클래스의 인스턴스를 생성하면,

조상 클래스의 멤버와 자손 클래스의 멤버가 합쳐진 하나의 인스턴스로 생성된다.

 

[클래스 간의 관계 - 포함관계]

상속을 통해서 클래스 간 관계를 만들고 재사용하는 방법에 대해 살펴보았는데 상속 외에도 클래스를 재사용하는 또 다른 방법은 포함(Composite) 관계를 만들어 주는 것이다. 이는 하나의 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것을 말한다. 

class Point{
    int x;
    int y;
}
class Circle{
    Point c = new Point();
    int r;
}

위와 같이 하나의 클래스를 작성할 때, 다른 클래스를 멤버변수로 선언하여 포함시키면 보다 간결하게 클래스를 작성할 수 있다. 

 

[클래스 간의 관계 결정하기]

클래스를 작성할 때 상속관계를 사용할 지, 포함 관계를 사용할 지 정해주는 것은 다소 모호한 점이 있을 수 있다. 클래스를 가지고 문장을 만들었을 때, ~은 ~이다 라는 문장이 자연스럽다면 상속 관계가 좋을 것이고 ~은 ~을 가지고 있다는 문장이 자연스럽다면 포함 관계가 좋을 것이다. 

class Shape{
    String color = "black";
    void draw(){
        System.out.printf("[Color = %s]\n", color);
    }
}
class Point{
    int x;
    int y;

    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    Point() {
        this(0, 0);
    }
    String getXY(){
        return "(" + x + "," + y + ")";
    }
}
class Circle extends Shape{
    Point center;
    int r;

    Circle(){
        this(new Point(0, 0), 100);
    }
    Circle(Point center, int r){
        this.center = center;
        this.r = r;
    }
    void draw(){
        System.out.printf("[center = (%d, %d), r = %d, color = %s\n",
                center.x, center.y, r, color);
    }
}
class Triangle extends Shape{
    Point[] p = new Point[3];
    Triangle(Point[] p){
        this.p = p;
    }
    void draw(){
        System.out.printf("[p1=%s, p2 = %s, p3=%s, color = %s\n",
                p[0].getXY(), p[1].getXY(), p[2].getXY(), color);
    }
}
class source{
    public static void main(String[] args) {
        Point[] p = { new Point(100, 100),
                      new Point(140, 50),
                      new Point(200, 100)
        };

        Triangle t = new Triangle(p);
        Circle c = new Circle(new Point(150, 150), 50);

        t.draw();
        c.draw();
    }
}

class source {
    public static void main(String[] args) {
        Deck d = new Deck();
        Card c = d.pick(0);
        System.out.println(c.toString());

        d.shuffle();
        c = d.pick();
        System.out.println(c);
        // 참조 변수의 출력이나 덧셈연산자를 이용한 참조변수와 문자열의 결합에는 toString() 이 자동적으로 호출되어
        // 참조 변수를 문자열로 대치한 뒤에 처리한다.
        // toString() 은 모든 클래스의 조상인 Object 클래스에 정의된 것이다.
    }
}

class Deck {
    final int CARD_NUM = 52;
    Card cardArr[] = new Card[CARD_NUM];

    Deck() {
        int i = 0;
        for (int k = Card.KIND_MAX; k > 0; k--)
            for (int n = 0; n < Card.NUM_MAX; n++)
                cardArr[i++] = new Card(k, n + 1);
    }

    Card pick(int index) {
        return cardArr[index];
    }

    Card pick() {
        int index = (int) (Math.random() * CARD_NUM);
        return pick(index);
    }

    void shuffle() {
        for (int i = 0; i < cardArr.length; i++) {
            int r = (int) (Math.random() * CARD_NUM);

            Card temp = cardArr[i];
            cardArr[i] = cardArr[r];
            cardArr[r] = temp;
        }
    }
}

class Card {
    static final int KIND_MAX = 4;
    static final int NUM_MAX = 13;
    static final int SPADE = 4;
    static final int DIAMOND = 3;
    static final int HEART = 2;
    static final int CLOVER = 1;

    int kind;
    int number;

    Card() {
        this(SPADE, 1);
    }

    Card(int kind, int number) {
        this.kind = kind;
        this.number = number;
    }

    public String toString() {
        String[] kinds = {"", "Clover", "Heart", "Diamond", "Spade"};
        String numbers = "0123456789XJQK";

        return "kind = " + kinds[this.kind] + ", number = " + numbers.charAt(this.number);
    }
}

 

[단일 상속: Single Inheritance]

  C++ 에서는 여러 조상 클래스로부터 상속받는 다중 상속(Multiple inheritance)을 허용하나 자바에서는 오로지 단일 상속만이 허용된다. 다중 상속을 사용할 수 있으면 여러 클래스로 부터 상속받는 복합적인 기능을 가지는 클래스를 쉽게 설계할 수 있지만, 서로 다른 클래스로부터 상속받은 멤버 간의 이름이 만약 겹치는 경우에는 구별할 수 없다는 큰 단점이 존재한다. 이를 해결할 수 있는 한가지 방법은 조상 클래스의 메서드 이름이나 매개변수를 바꾸는 수가 있지만, 이러면 조상 클래스의 겹치는 이름을 가진 메서드/변수를 사용하는 모든 클래스를 변경해야 하므로 결코 간단치 않은 방법이다. 자바에서는 다중 상속의 이러한 문제점을 해결하기 위해 다중상속의 장점을 과감히 포기하고 단일 상속만 허용하였따. 단일 상속은 하나의 조상 클래스만 가질 수 있어 다소 불편한 점이 있을 수 있지만, 아무래도 클래스 간의 관계가 보다 명확해지고 신뢰성이 높아진다는 것이 큰 장점이다. 단일상속만 허용하지만, 포함관계를 적절히 활용하면 효율적인 코드를 작성할 수 있다.

 

[Object 클래스 - 모든 클래스의 조상]

  Object 클래스는 모든 클래스 상속 계층도의 최상위 조상 클래스로, 다른 클래스로부터 상속받지 않는 모든 클래스는 Object 클래스로부터 상속을 받는다. 아무런 상속을 받지 않는 클래스를 정의하면 컴파일러에 의해 자동적으로 extends Object 를 추가한다. 이렇게 함으로써 자바이 모든 클래스들은 Object 클래스의 멤버들을 상속받기 때문에, Object 클래스 내부의 멤버들을 사용할 수 있다. toString() 이나 equals(Object o) 와 같은 메서드를 정의하지 않고도 사용할 수 있었던 이유는 이와 같이 Object 클래스에 의하여 상속받았기 때문이다. Object 클래스에 대해서는 이후에 자세하게 다루어보도록 하자.

 

 

 

2. 오버라이딩(overriding)

  [오버라이딩의 정의]

조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것을 오버라이딩이라고 한다. 상속 받은 메서드를 자식 클래스에 맞게 적절히 변경해야하는 경우에 조상 메서드를 오버라이딩한다. 

class Point{
    int x;
    int y;
    String getLocation(){
        return "x :" + x + ", y :" + y;
    }
}
class Point3D extends Point{
    int z;
    String getLocation(){
        return "x: " + x + ", y : " + y  + ", z :" + "z";
    }
}

Point 클래스의 getLocation 은 2차원 좌표를 반환하도록 작성되었으나, Point 의 자식 클래스인 Point3D 클래스는 3차원 좌표계를 표현하기 위한 것이므로, 상속받은 메서드를 오버라이딩한다. 새롭게 메서드를 제공하기 보다는 오버라이딩을 하는 것이 좋다.

 

[오버라이딩의 조건]

오버라이딩은 상속받은 메서드의 내용만을 수정하는 것으로, 선언부는 조상과 완전히 일치해야 한다. 그렇기 때문에 오버라이딩이 성립하려면 아래 조건을 만족해야만 한다.

 

자손 클래스에서 오버라이딩하는 메서드는  조상 클래스의 메서드와

1. 이름이 같아야 한다.

2. 매개변수가 같아야 한다.

3. 반환타입이 같아야 한다.

 

 선언부가 서로 일치해야 한다는 것인데, 접근 제어자(access modifier)와 예외(exception)는 제한된 조건 하에서만 다르게 변경할 수 있기도 하다.

 

• 접근 제어자는 조상 클래스의 메서드보다 좁은범위로 변경할 수 없다.
  만약 조상 클래스에 정의된 메서드의 접근 제어자가 protected 이면, 해당 메서드를 오버라이딩하는 메서드는 public 이거나 protected 여야만 한다. 대부분 같은 접근 제어자를 사용한느데, 접근 범위는 public > protected, default, private 순으로 넓다.
• 조상 클래스의 메서드보다 많은 수의 예외를 선언할 수 없다.
  
  class Parent{
            void parentMethod() throws IOException, SQLException{
              ...
           }
  }
  class Child extends Parent{
            void parentMethod() throws IOException{
              ...
           }
  }
  위와 같이 작성하면 조상 클래스보다 자식 클래스에서 예외의 개수가 적으므로 오버라이딩이 올바르게 되었다고 할 수 있다. 중요한 것은 예외의 개수가 아니라는 것에 주의하자.
  class Parent{
            void parentMethod() throws IOException, SQLException{
              ...
           }
  }
  class Child extends Parent{
            void parentMethod() throws Exception{
              ...
           }
  }
  만약 위와 같이 작성한다면 Exception 은 모든 예외의 최고 조상이므로 자식 클래스의 예외의 개수가 조상 클래스의 예외의 개수보다 많으므로 오버라이딩의 조건을 만족하지 못한다.

조상 클래스의 메서드를 자손 클래스에서 오버라이딩 할 때에는 아래 3가지를 기억하도록 하자.

1. 접근 제어자를 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없다.

2. 예외는 조상 클래스의 메서드보다 많이 선언할 수 없다.
3. 인스턴스메서드를 static 메서드나 반대로 변경할 수 없다.

Q. 조상 클래스에 정의된 static 메서드를 자손 클래스에서 동일한 이름의 static 메서드로 정의할 수 있을까?

A. 가능하지만, 이는 오버라이딩은 아니고 각각의 클래스에 별도의 static 메서드를 정의한 것일 뿐이다. static 멤버들은 자신들이 정의된 클래스에 묶여있다고 생각하는 것이 자연스러우며 호출 시에는 참조변수를 이용하지 말고 클래스이름.메서드이름() 으로 하는 것이 좋다.

 

Static 사용의 장단점 (출처 :https://velog.io/@gudonghee2000/static-vs-%EC%8B%B1%EA%B8%80%ED%86%A4-%ED%8C%A8%ED%84%B4#:~:text=%EC%B2%AB%EB%B2%88%EC%A7%B8%EB%8A%94%2C%20Static%EC%9D%B4%20%EB%A9%94%EB%AA%A8%EB%A6%AC,%EC%86%8D%EB%8F%84%EA%B0%80%20%EB%B9%A0%EB%A5%B4%EB%8B%A4%EB%8A%94%20%EA%B2%83%EC%9D%B4%EB%8B%A4.)

Static 은 클래스 메서드와 클래스 필드를 지정할 때 사용하는 것으로, 인스턴스를 생성하지 않아도 클래스의 메서드와 필드에 접근이 가능하도록 한다. 일반적으로 사용하는 Class 는 Static 영역에 생성되고, new operator 을 이용하여 생성한 객체는 Heap 영역에 생성된다. 

https://velog.io/@gudonghee2000/static-vs-%EC%8B%B1%EA%B8%80%ED%86%A4-%ED%8C%A8%ED%84%B4#:~:text=%EC%B2%AB%EB%B2%88%EC%A7%B8%EB%8A%94%2C%20Static%EC%9D%B4%20%EB%A9%94%EB%AA%A8%EB%A6%AC,%EC%86%8D%EB%8F%84%EA%B0%80%20%EB%B9%A0%EB%A5%B4%EB%8B%A4%EB%8A%94%20%EA%B2%83%EC%9D%B4%EB%8B%A4.

Static 의 장점은 아래와 같다.
1. 메모리 측면에서 효율적이다. Static 영역에 저장되면 고정된 메모리 영역을 사용하는 것이므로 매번 인스턴스를 생성하면서 낭비되는 메모리를 줄일 수 있다.
2. 객체 생성 없이도 사용가능하므로 속도가 빨라진다. 클래스가 메모리에 올라가는 시점에 생성되어서 사용이 바로 되므로 속도 면에서 이득이 있다.

Static 의 단점은 아래와 같다.
1. 프로그램 종료 시까지 메모리에 할당된 채로 존재한다.
Garbage Collector 를 통해서 수시로 관리받는 Heap 영역과 달리 Static 영역은 Garbage Collector 에 의한 관리를 받지 않기 때문에 Static 영역은 프로그램 종료 시 까지 메모리에 존재한다. 만약 Static 을 남용하게 된다면 종료 시 까지 많은 메모리가 할당된 채로 존재하므로 성능에 악영향을 주게 된다.
2. Static 은 객체지향적이지 못하다. 따로 객체를 생성하지 않고 메모리의 Static 영역에 할당된 곳에서 여러 클래스들이 데이터를 불러오는 구조인데, 이러한 특징은 객체의 데이터들이 캡슐화 되어야 한다는 객체 지향 프로그래밍의 원칙을 다소 위반한다는 것이다.
3. Static 메서드는 interface 구현에 사용 될 수 없다. Static 메서드는 코드의 재사용성을 높여주어 자바의 유용한 OOP 기능을 사용하는 것을 방해한다는 것이다.

[오버로딩과 오버라이딩의 차이점]

오버로딩(overloading) 은 기존에 없는 새로운 메서드를 정의하는 것(new)

오버라이딩(overriding) 은 상속받은 메서드의 내용을 변경하는 것(change, modify)

아래의 코드를 살펴보자.

 

class Parent{void parentMethod() {}}class Child extends Parent {void parentMethod() {}  // 오버라이딩void parentMethod(int i) {}  // 오버로딩

 

void childMethod() {}

void childMethod(int i) {}  // 오버로딩

void childMethod() {}  // 중복 정의 에러}

 

[Super]

  super 은 조상 클래스로부터 상속받은 멤버를 자식 클래스에서 참조할 때 사용하는 참조 변수이다. 멤버변수와 지역변수의 이름이 겹치면 this 를 붙여서 구별했듯 상속받은 멤버와 자신의 멤버의 이름이 겹치는 경우에는 super 을 붙여 구별이 가능하다. 물론 상속받은 멤버는 자손 클래스의 멤버이므로 this 를 사용할 수 있지만, 조상 클래스의 멤버와 자손 클래스의 멤버가 중복 정의되어 구별해야한다면 super 을 사용하도록 하자.

 

  조상의 멤버와 자신의 멤버를 구별해야한다는 점을 제외하면 super 와 this 는 근본적으로 같다. 모든 인스턴스 메서드에는 자신이 속한 인스턴스의 주소가 지역 변수로 저장된다. 이는 this 와 super 의 값이 된다. static 메서드는 인스턴스와 관련 없으며, this 와 마찬가지로 super 는 static 메서드에서 사용할 수 없고 인스턴스 메서드에서만 사용이 가능하다.

class source{
    public static void main(String[] args) {
        Child c = new Child();
        c.method();
    }
}
class Parent{
    int x = 10;
}
class Child extends Parent{
    int x = 20;

    void method(){
        System.out.println("x=" + x);
        System.out.println("this.x = " + this.x);
        System.out.println("super.x = " + super.x);
    }
}

위 예제에서는 부모 클래스인 Parent 에서도 x 라는 변수가 있고, 자식 클래스에서도 x 라는 변수가 존재한다. 중복정의된 것이고 이를 구분하기 위해, super 을 사용한다. 변수 뿐만이 아니라 메서드도 super 을 사용하여 호출이 가능하다. 조상 클래스의 메서드를 자식 클래스에서 오버라이딩한 경우에 super 을 사용한다. 

class Point{
    int x; int y;
    String getLocation(){
        return "x :" + x + ", y :" + y;
    }
}
class Point3D extends Point{
    int z;
    String getLocation(){
        return super.getLocation() + ", z : " + z;
    }
}

자식 클래스에서 사용하는 메서드가 조상 클래스의 메서드의 내용에 추가적인 작업을 하는 경우라면 super 을 이용하여 조상 클래스의 메서드를 포함시키는 것이 이후에 조상클래스의 메서드가 변경되더라도 자손 클래스의 메서드에도 자동 반영 될 것이기 때문에 효율적이다.

 

[Super() - 조상 클래스의 생성자]

this() 와 마찬가지로 super() 도 생성자이다. this() 는 같은 클래스의 다른 생성자를 호출할 때 사용하지만, super() 은 조상 클래스의 생성자 호출에 사용된다. 자손 클래스의 인스턴스를 생성하면, 자손 멤버와 조상의 멤버가 모두 합쳐진 하나의 인스턴스가 만들어진다. 그래서 자손 클래스에서 조상 클래스의 멤버를 사용할 수 있는 것이다. 이때 조상 클래스 멤버의 초기화 작업이 수행되어야 하므로, 자손 클래스의 생성자에서 조상 클래스의 생성자를 호출되어야한다. (자손 클래스의 멤버가 조상 클래스의 멤버를 사용할 수 있기 때문에 조상 클래스의 멤버의 초기화가 필요한 것이다.) 이러한 조상 클래스의 생성자는 계층 관계를 거슬러 올라가 결국 최고 조상인 Object 클래스의 생성자인 Object() 까지 수행된다. 그러므로 Object 생성자를 제외한 모든 클래스의 생성자는 첫 번째 줄에 반드시 다른 생성자나 조상의 생성자를 호출해야 하며, 그렇지 않으면 컴파일러에 의해 생성자의 첫 줄에 super(); 가 자동적으로 추가된다.

 

Object 클래스를 제외한 모든 클래스의 생성자 첫 줄에 생성자.this() 혹은 super() 을 호출해야 한다.

그렇지 않으면 컴파일러는 자동으로 super(); 를 생성자 첫 줄에 삽입한다.

 

class source{
    public static void main(String[] args) {
        Point3D p3 = new Point3D(1, 2, 3);
    }
}

class Point{
    int x; int y;
    Point(){
        this(0, 0);
    }
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    String getLocation(){
        return "x :" + x + ", y :" + y;
    }
}
class Point3D extends Point{
    int z;
    Point3D(int x, int y, int z)
    {
        // super();
        this.x =x;
        this.y = y;
        this.z = z;
    }
    String getLocation(){
        return super.getLocation() + ", z : " + z;
    }
}

 

Point 클래스를 상속받은 Point3D 클래스는 Point3D 생성자에서 조상 클래스의 생성자를 호출하지 않고 있기 때문에, 컴파일 시 컴파일러에 의해 생성자의 첫 줄에 super(); 가 실행된다. 이에 의해 조상 클래스인 Point() 가 실행된다. 마찬가지로 Point 클래스는 Object 클래스를 상속받는데, 생성자에서 상속받은 조상 클래스의 생성자가 없기 때문에 point() 생성자의 첫 줄에 컴파일러에 의해 super(); 가 자동으로 추가/실행되며 이는 Object() 를 의미한다. 

---

References

http://www.yes24.com/Product/Goods/24259565

Java의 정석 - YES24