Live Study - Java 상속 (Inheritance)

정리한 내용
- Java 의 상속과 특징
- Super
- 오버라이딩
- 제어자
- 다형성
- Dynamic Method Dispatch
- 추상 클래스
- Object 클래스

---

Java 의 상속(Inheritance)과 특징

클래스를 상속 받는 다는 것은 기존의 클래스를 재사용해서 새로운 클래스를 작성하는 것이다. 
상속의 목적도 결국 중복의 제거인 것 같다. 프로그래밍의 많은 개념은 코드의 재사용성을 높이고, 중복을 제거하기 위해 만들어지고 발전되는 것들이 정말 많은것 같고, 상속이라는 개념도 그 과정 속의 산물이라고 생각한다.

Java 에서 클래스를 상속 받기 위해서는 extends 라는 키워드를 사용한다.

class Product {
    String productCode;
    String productType;
}

public class Book extends Product {
    String author;
    String title;
    // ..
}

상속 받는 Book 같은 클래스를 Child(자식), Sub(하위), Derived(파생) 클래스 라고 많이 표현하고, 상속을 해주는 Product 같은 클래스를 Parent(부모), Super(상위), Base(기반) 클래스라고 자주 표현한다.

자식 클래스는 부모 클래스의 멤버 변수, 메소드들을 모두 상속 받게 된다. 이 때 접근 제어자로 상속 받지 못하는 자원들도 있지만, 부모 클래스의 자원을 자식 클래스에서 사용할 수 있다. 그리고 상속 받지 못하는 것들도 있는데, 생성자와 초기화 블록은 상속되지 않는다.

자식 클래스는 부모 클래스의 모든 멤버를 상속 받기 때문에 이를 확장, Extend 라고 표현할 수 있고, 그래서 상속 받을 때의 키워드가 extends 인 이유라고 한다.

class Product {
    String productCode;
    String productType;
}

class Book extends Product {
    String author;
    String title;
    
    void display() {
        System.out.printf("%s, %s, %s, %s%n", 
                this.productCode, this.productType, this.author, this.title);
    }
}

 

상속이라는건 어쨋든 클래스 간의 관계를 만들어서 중복을 줄이고 재사용성을 높인 방법이다.
상속이 아니라 클래스 간의 포함이라는 관계를 맺어 좋은 구조의 코드를 작성할 수도 있다.

class Car {
    Wheel[] wheels = new Wheel[4];
    // ..
}

class Wheel {
    String brand;
    String type;
}

위의 클래스는 '자동차가 바퀴를 가지고 있다' 라고 표현할 수 있다. 자동차라는 커대한 클래스를 작성하는 것보다 구성 요소 별로 여러개의 클래스를 만들고 포함 관계로 재사용하면, 보다 좋은 구조의 프로그램을 만들 수 있는 것 같다.

클래스의 관계를 결정할 때 'A는 B이다(is - a)', 'A는 B를 가지고 있다(has - a)' 에 대입해서 생각해보면 가닥을 잡을 수 있는 것 같다.

책은 상품이다. (is - a)
차는 바퀴들을 가지고 있다. (has - a)

 

다시 상속으로 돌아와서, Java 는 하나의 클래스만 상속 받을 수 있다. 단일 상속 이라고 표현한다. 다중 상속을 허용하는 언어(C++, Python 등)도 있다.

다중 상속을 허용하는 경우 여러 클래스에서 상속을 받을 수 있게 되므로 복합적인 기능을 가진 클래스를 쉽게 작성할 수 있게 되지만, 상속 받는 클래스들 중 같은 이름의 메소드가 있는 경우 구별하기 어렵다는 단점이 있다. 

그래서 파이썬에서는 Method Resolution Order (MRO) 라는 개념이 있어서 앞의 상황에서 어떤 메소드가 사용되는지에 대한 규칙이 있다. 

Java 에서는 위와 같은 이유로 다중 상속을 허용하지 않는다. 클래스 간의 관계가 보다 명확해지는 장점이 있다.

 

Super

super 는 자식 클래스에서 부모 클래스의 자원을 참조하는데 사용되는 변수다. 

부모 클래스의 자원도 this 키워드를 사용해 참조할 수 있고, 자식 클래스의 자원과 부모 클래스의 자원을 구별해서 사용해야 할 때 super 키워드를 사용하면 된다.

class Product {
    String productCode;
    String type = "Product Type";

}

class Book extends Product {
    String author;
    String type = "Book Type";

    void displayType() {
        System.out.println(String.format("Super: %s, This: %s", super.type, this.type));
    }
}

public class SampleTest {

    public static void main(String[] args) {
        Book book = new Book();
        book.displayType();
    }

}

// 출력결과
// Super: Product Type, This: Book Type

예제는 변수에 대해 super 로 참조했는데, 메소드에 대해서도 super 로 참조할 수 있다.

super()

생성자에서 다른 생성자를 호출 할 때 this() 를 사용했었다. super() 도 생성자를 호출할 때 사용할 수 있다. 부모 클래스의 생성자를 호출하는 방법이다.

자식 클래스의 인스턴스를 생성하면, 부모 + 자식이 된 하나의 인스턴스가 생성되는 것이기 때문에, 자식 클래스의 생성자가 호출될 때 부모 클래스의 생성자도 함께 호출이 되어야 한다.

이때 자식 클래스에서 부모 클래스의 자원을 사용할 수 있기 때문에 자식 클래스 생성자의 첫 줄에서는 부모 클래스의 생성자를 호출해야 한다. 만약 첫 줄에서 super() 를 호출하지 않았다면 컴파일러가 자동으로 추가해준다.

만약 부모 클래스에 기본 생성자가 없는 경우에 컴파일러가 자식 생성자에서 super(); 를 추가하면 에러가 발생할 수 있기 때문에 주의해야 한다. 아래와 같은 경우이다.

class Product {
    String productCode;
    String productType;

    public Product(String productCode, String productType) {
        this.productCode = productCode;
        this.productType = productType;
    }
}

class Book extends Product {
    String author;
    String title;

    public Book(String productCode, String productType, 
                String author, String title) {
        this.author = author;
        this.title = title;
    }
}

위의 코드는 부모 클래스에는 기본 생성자가 없는데, 자식 생성자에서 부모 생성자를 호출하지 않았기 때문에 에러가 발생한다.

class Book extends Product {
    String author;
    String title;

    public Book(String productCode, String productType, String author, String title) {
        super(productCode, productType); // 추가!
        this.author = author;
        this.title = title;
    }
}

부모 클래스의 생성자를 호출해줘야 문제 없이 인스턴스를 생성할 수 있다.

 

오버라이딩, Overriding

부모 클래스에서 상속받은 메소드를 다시 작성하는 것을 오버라이딩 이라고 한다. 

class Product {
    String productCode;
    String productType;

    String getDisplayData() {
        return String.format("Product Code: %s, Product Type: %s", productCode, productType);
    }
}

class Book extends Product {
    String author;
    String title;

    @Override
    String getDisplayData() {
        return String.format("Product Type: %s, Book Title: %s, Book author: %s", 
            productType, title, author);
    }
}

Product 클래스를 상속받아 getDisplayData 메소드를 오버라이딩 했다. 

오버라이딩을 한다는 것은 메소드의 Body 부분만 재작성 하는 것이기 때문에 선언부는 완전히 동일해야 한다. 메소드 명, 매개변수, 반환 타입이 동일해야 한다. 대부분의 경우 부모 클래스의 선언부와 똑같이 사용하지만 접근 제어자와 예외는 조건적으로 변경할 수 있다.

부모 클래스의 메소드보다 넓은 범위의 접근 제어자로 변경할 수 있다. 접근 제어자의 범위는 public -> protected -> default -> private 순으로 좁혀진다.  예를 들면 부모 클래스의 메소드가 protected 였으면 자식 클래스는 똑같이 protected 이거나, public 이어야 한다는 것이다. private 로 변경하면 컴파일러가 에러를 알려준다.

그리고 부모 클래스의 메소드보다 많은 수의 예외를 선언할 수 없다. 예를 들어 부모 메소드가 IOException, IllegalArgumentException 예외를 던지는 경우 자식에서는 둘 중 하나의 예외만 던져도 된다. 하지만 다른 예외를 던지거나 하면 역시 에러가 생긴다. 

 

제어자, Modifier

제어자는 클래스, 변수, 메소드의 선언부에 사용되어 부가적인 의미를 부여한다. 크게 접근 제어자와 접근 제어자를 제외한 제어자들이 있다.

접근 제어자: public, protected, default, private
그 외 제어자: static, final, abstract, native, transient, synchronized, volatile, strictfp

접근 제어자는 한 번에 하나만 사용할 수 있고, 그 외의 제어자들은 여러가지를 조합해서 사용할 수 있다.

public static final int NUMBER = 10;

이렇게 사용할 수는 있지만, public private static 이렇게 public 과 private 을 함께 사용할 수는 없다.
제어자들을 조합해서 사용할 때, 제어자의 순서는 상관이 없다. 보통 접근 제어자를 가장 왼쪽에 두고, 그 외의 제어자들을 적절하게 작성하면 된다.

접근 제어자

접근 제어자는 클래스, 변수, 메소드에 적용해서 외부에서 접근하지 못하도록 제한하는 역할을 한다. 
외부로부터 데이터를 보호하기 위해서, 불필요한 부분을 감추기 위해서 사용하는 것이다. 객체지향개념의 캡슐화 (Encapsulation)에 해당한다.

클래스에는 public, default 제어자가 허용되고,
변수와 메소드에는 public, protected, default, private 제어자가 허용된다.

접근 제어자를 따로 정의하지 않는 경우, default 제어자가 기본으로 적용된다.

public	접근 제한이 없다.
protected	같은 패키지 내에서, 다른 패키지인 경우 자식 클래스에서 접근이 가능하다.
default	같은 패키지 내에서 접근이 가능하다.
private	같은 클래스 내에서만 접근이 가능하다.

final

final 제어자는 클래스, 메소드, 변수 모두에 붙일 수 있다. 

클래스에 붙이면 변경, 확장할 수 없는 클래스가 되고, 메소드에 붙이면 오버라이딩을 통해 재정의 될 수 없고, 변수에 붙이면 값을 변경할 수 없는 상수가 된다.

final class FinalClass {
    final int MAX_VALUE = 1_000;
    
    final void getMaxValue() {
        return MAX_VALUE;
    }
}

final 이 붙은 변수는 상수가 되기 때문에 일반적으로 선언과 동시에 초기화를 한다. 하지만 인스턴스 변수에 붙은 final 변수는 생성자에서 초기화하도록 할 수 있다.

매개변수를 받는 생성자를 작성해서 인스턴스를 생성할 때 final 이 붙은 변수를 초기화 하는데 필요한 값을 제공받아 초기화 하는 것이다. 이때 기본 생성자가 있으면 에러가 발생한다.

class FinalClass {
    final int constValue;
    
    public FinalClass(int constValue) {
        this.constValue = constValue;
    }
}

상속을 막는 두 가지 방법

두 가지 방법 중 하나는 바로 위에서 봤던 final 을 class 에 붙이는 것이다. 또 다른 방법은 클래스의 생성자에 private 을 붙이는 것이다.

자식 클래스에서 부모 클래스의 생성자를 호출해야 하는데 부모 클래스 생성자의 접근 제어자가 private 이기 때문에 자식 클래스에서 접근이 불가능한 것이다.

class FinalClass {

    private FinalClass() {
    }
    
}

하지만 이런 경우 명시적으로 class 앞에 final 을 추가하는 것이 더 좋겠다.

생성자가 private 인 경우 static public 메소드를 작성해서 인스턴스를 생성해주는 작업을 한다. 인스턴스의 개수를 제한하거나 할 때 이런 방법을 사용한다.

 

다형성, Polymorphism

객체지향개념에서 다형성은 '여러 가지 형태를 가질 수 있는 능력'을 의미한다. Java 에서는 다형성을 부모 클래스의 참조 변수로 자식 클래스의 인스턴스를 참조할 수 있도록 구현했다.

class Product {
    private String productCode;
    private String productType;
}

class Book extends Product {
    private String author;
    private String title;
}


public class SampleTest {

    public static void main(String[] args) {
        Product bookProduct = new Book();
    }

}

bookProduct 는 Product 를 참조할 수 있는 참조변수이지만, Product 클래스를 상속 받은 Book 클래스의 인스턴스를 참조할 수 있다.
인스턴스를 부모 타입의 참조 변수로 참조하는 것과, 자식 타입의 참조 변수로 참조하는 것은 사용할 수 있는 자원의 범위에서 차이가 생긴다.

class Product {
    private String productCode;
    private String productType;
    
    void showCode() {}
    void showType() {}
}

class Book extends Product {
    private String author;
    private String title;
    
    void showAuthor() {}
    void showTitle() {}
}


public class SampleTest {

    public static void main(String[] args) {
        Product bookProduct = new Book();
        bookProduct.showCode();
        bookProduct.showType();
        // bookProduct.showAuthor(); 에러!
    }

}

Product 타입의 참조변수로는 부모 클래스에서 정의되어 있는 자원들에 한해서 접근할 수 있다.

자식 클래스의 레퍼런스로는 당연히 Book 인스턴스의 모든 자원에 접근이 가능하다.

 

 

 

반대로 자식 타입의 참조 변수로 부모 클래스의 인스턴스를 참조할 수는 없다.

Book book = new Product(); // 에러!

참조 변수의 형 변환

위에서 Product 의 참조 변수로는 Book 인스턴스의 메서드를 사용하지 못했는데, 참조 변수를 형 변환 해서 해결 할 수 있다.

public static void main(String[] args) {
    Product bookProduct = new Book();
    bookProduct.showType();

    Book book = (Book) bookProduct;
    book.showAuthor();
}

서로 상속 관계에 있는 클래스 사이에서만 가능하다. 자식 타입의 참조 변수를 부모 타입의 참조 변수로, 부모 타입의 참조 변수를 자식 타입의 참조 변수로 형변환이 가능하다.

자손 타입의 참조 변수를 부모 타입의 참조 변수로 형변환 하는 것을 Up-Casting
부모 타입의 참조 변수를 자식 타입의 참조 변수로 형변환 하는 것을 Down-Casting 라고 한다.

여기서 Up-Casting 할 때는 형변환 연산자를 생략할 수 있다.

    public static void main(String[] args) {
        Product bookProduct = new Book();
        bookProduct.showType();

        Book book = (Book) bookProduct; // (Book) 생략 불가
        book.showAuthor();

        Book book2 = new Book();
        Product bookProduct2 = book2; // (Product) 생략 가능
    }

형변환 시 주의할 것

public static void main(String[] args) {
    Product product = new Product();
    Book book = (Book) product;
}

위와 같이 형변환 하면 런타임 시 ClassCastException 예외가 발생한다.
문제는 product 가 참조하는 인스턴스가 Product 타입이기 때문에 Book 타입의 참조변수로 형변환 할 수 없다.

참조 변수가 사용할 수 있는 자원의 수는 인스턴스의 자원 수보다 같거나 적어야 하는데, Book 참조변수로는 Product 참조 변수가 참조할 수 있는 자원보다 더 많을 수 있기 때문에 문제가 발생하는 것이다.

그래서 항상 참조변수를 형변환 할 때에는 instanceof 연산자를 사용해서 인스턴스의 타입이 무엇인지 확인하는 작업이 중요하다.

public static void main(String[] args) {
    Product product = new Product();
    if (product instanceof Book) {
        Book book = (Book) product;
    }
}

Dynamic Method Dispatch

Dynamic Method Dispatch 는 오버라이딩 된 메소드를 호출할 때 어떤 메소드를 호출할지에 대한 결정을 컴파일 시점이 아니라 런타임 시점에 결정하는 메커니즘을 뜻한다.

덧붙여서 설명하면, 부모 클래스의 참조 변수로 오버라이딩 된 메소드를 호출하려고 하는 경우에 참조되는 인스턴스의 타입을 기준으로 어떤 메소드를 실행할지를 결정하는 것이다. 인스턴스의 타입을 보고 결정하기 때문에 런타임 시점에 결정한다는 것이다.

class Parent {
    void show() {
        System.out.println("Parent - show method is called.");
    }
}

class ChildA extends Parent {
    void show() {
        System.out.println("Child A - show method is called.");
    }
}

class ChildB extends Parent {
    void show() {
        System.out.println("Child B - show method is called.");
    }
}


public class SampleTest {

    public static void main(String[] args) {
        Parent parent = new Parent();
        ChildA childA = new ChildA();
        ChildB childB = new ChildB();

        Parent ref = null;

        ref = parent;
        ref.show(); // Parent - show method is called.

        ref = childA;
        ref.show(); // Child A - show method is called.

        ref = childB;
        ref.show(); // Child B - show method is called.
    }

}

show() 메소드는 호출 시에 참조되는 인스턴스의 타입에 따라서 부모의 show() 혹은 자식의 show() 중 어떤 메소드를 호출할지 결정하는 것이다.

Dynamic Method Dispatch 는 멤버 변수에 대해서는 적용되지 않는다. 어떤 인스턴스인지가 아니라 어떤 참조 변수를 사용하고 있는지를 보고 결정된다.

class Parent {
    int num = 100;
}

class ChildA extends Parent {
    int num = 200;
}

public class SampleTest {

    public static void main(String[] args) {
        Parent p = new ChildA();
        ChildA c = new ChildA();

        System.out.println("Parent Ref: " + p.num); // Parent Ref: 100
        System.out.println("Child Ref: " + c.num); // Child Ref: 200
    }

}

추상 클래스

추상 클래스는 추상 메소드를 가진 클래스를 뜻한다. 추상 메소드는 제어자에서 봤던 abstract 키워드를 사용해 만들 수 있다.

abstract class AbstractClass {
    abstract void doSomething();
}

추상 메소드가 있는 클래스에 abstract 제어자가 없으면 에러가 발생한다. 

추상 메소드는 아직 완성되지 않은 메소드를 뜻하고, 추상 클래스에서 추상 메소드는 선언부만 존재한다. 위에서도 doSomething(); 이렇게 끝난걸 볼 수 있다.

추상 클래스를 상속받는 자식 클래스에서 해당 추상 메소드의 정의를 강제한다. 이 같은 이유로 추상 클래스를 인스턴스로 생성할 수 없다. 정의되지 않는 메소드가 있는 인스턴스를 만들 수는 없기 때문이다.

abstract class Machine {
    abstract void run();
    abstract void stop();
}

class Tv extends Machine {
    @Override
    void run() {
        System.out.println("Tv Run");
    }

    @Override
    void stop() {
        System.out.println("Tv Stop");
    }
} 

public class SampleTest {

    public static void main(String[] args) {
        // Machine m = new Machine(); 에러!
        Tv tv = new Tv();
        Machine tv2 = new Tv(); // 추상 클래스도 다형성 적용이 가능하다.
    }

}

추상 클래스는 추상 메소드가 있다는 것 말고는 일반 클래스와 다를 것은 없다. 똑같이 변수, 메서드를 작성할 수 있다.

 

Object 클래스

Object 클래스는 모든 클래스의 최고 조상이 되는 클래스이다. 모든 클래스는 사실 Object 클래스를 상속받고 있는 것이다. 따로 extends 해서 상속 받는 클래스가 없었다면 자동으로 Object 클래스를 상속 받게된다.

Object 클래스는 java.lang 패키지에 있는데 자바 프로그래밍에서 가장 기본이 되는 클래스들을 포함하고 있다. java.lang 하위의 클래스들은 따로 import 하지 않아도 사용이 가능하다. 

Object 클래스는 모든 클래스의 조상이 되기 때문에 Object 클래스의 멤버들을 모든 클래스에서 사용이 가능하다.

Object 클래스는 멤버 변수는 없고, 11 개의 메소드만 가지고 있다.

clone()	객체 자신의 복사본 반환
equals()	객체 자신과 같은 객체인지 boolean 타입으로 반환
finalize()	객체가 소멸될 때 GC 에 의해 자동적으로 호출, 소멸시 수행해야할 작업이 있으면 재정의 하면 된다. (거의 사용하지 않음)
getClass()	객체의 클래스 정보를 담고 있는 Class 인스턴스 반환
hashCode()	객체의 hash code 반환
toString()	객체의 정보를 문자열로 반환
notify()	객체를 사용하려는 Thread 를 하나만 깨운다.
notifyAll()	객체를 사용하려는 모든 Thread 를 깨운다.
wait()	다른 Thread 가 notify(), notifyAll() 를 호출할 때까지 현재 Thread 를 기다리게 한다. 무한하게 혹은 지정된 시간동안 기다리게 할 수 있다. (timeout 은 1/1000 초, nanos 는 1/10^9 초)
wait(long timeout)()
wait(long timeout, int nanos)

equals(Object obj)
매개변수로 참조 변수를 받아서 같은 참조 변수인지 결과를 boolean 타입으로 알려준다.
주소 값이 아니라 실제 인스턴스의 내용을 비교하고 싶은 경우 equals 를 재정의한다. String 클래스의 equals() 메소드는 실제 문자열 값을 비교하도록 되어있다.

hashCode()
hashCode() 메소드는 객체의 유일한 해시 코드 값을 만들어 반환한다. Object 클래스의 hashCode() 메소드는 객체의 주소 값을 이용한다. 
같은 해시코드가 존재할 수 있지만 Object 의 hashCode() 메소드는 객체의 주소 값을 사용해서 코드를 만들기 때문에 두 객체는 결코 같은 값을 가질 수 없다. 인스턴스 내용을 가지고 해시 코드를 만들고 싶다면 재정의해야한다. 

인스턴스 값으로 두 객체를 비교하고 싶다면 equals, hashCode 두가지 메소드를 모두 적절히 재정의해야한다.

toString()
인스턴스에 대한 정보를 문자열로 제공한다. 재정의 하지 않으면 클래스 이름과 16진수 해시 코드가 반환된다. 적절히 재정의 하는 것이 좋다.

 

References

https://www.geeksforgeeks.org/dynamic-method-dispatch-runtime-polymorphism-java/
자바의 정석 (www.yes24.com/Product/Goods/24259565)