[JAVA] 상속이란? (추상클래스, super, final, 오버라이딩...)

👶 상속

기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것

장점 및 특징

• 적은 양의 코드로 새로운 클래스 작성 가능
• 코드를 공통적으로 관리해 코드의 추가/변경이 용이
• 코드의 재사용성을 높이고 코드의 중복을 제거하여 프로그램의 생산성과 유지보수에 크게 기여

상속방법

[새로 작성하고자 하는 클래스] extends [상속 받고자하는 클래스]
[자식 클래스] extends [조상 클래스]
[하위 클래스] extends [상위 클래스]
[파생된 클래스] extends [기반 클래스]

Child extends Parent

📢 단일 상속
JAVA는 다중 상속이 불가능 하다. 단일 상속만 가능하다.
❌: (자손) extends (조상1), (조상2)

상속 계층도

상속 계층도

다이어그램

다이어그램

🚨 조상클래스가 면경되면 자손클래스는 자동적으로 영향을 받는다
🚨 자손클래스가 변경되는 것은 조상 클래스에 영향 없다
🚨 생성자와 초기화 블럭은 상속되지 않는다
🚨 자손 클래스의 멤버개수는 조상 클래스보다 항상 같거나 많다 (그래서 extends : 확장이라는 단어를 씀)

예제

package com.week.six;

class Tv {
    boolean power; 
    int channel;

    void power() {
        power = !power;
    }

    void channelUp() {
        ++channel;
    }

    void channelDown() {
        --channel;
    }
}

class CaptionTv extends Tv {
    boolean caption;
    void displayCaption() {
        if (caption) {
            System.out.println("Hello, World");
        }
    }
}

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

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

포함 관계

상속 외에 클래스를 재사용하는 방법.
한 클래스의 멤버변수로 다른 클래스 타입의 참조 변수를 선언.

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

상속/포함 관계는 어떻게 결정 짓는가?

🚨 상속: (자식)은 (조상)이다.
🚨 포함관계 : (자식)은 (조상)을 가지고 있다.

위 문장에 대입해보고 적절한 것을 선택하면 된다.
ex)
⭕ : '원'은 '도형'이다. '원'은 '점'을 가지고 있다.
❌ : '원'은 '점'이다. '원'은 '도형'을 가지고 있다.

👶 super

super 와 super()는 차이가 있다.
먼저 super는 자손 클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조변수이다.
멤버변수와 지역 변수의 이름이 같을 때 this를 붙여서 구별했듯이 상속받은 멤버와 자신의 멤버와 이름이 같을 때 쓴다.

class SuperTest {
    public static void main(String args[]) {
        Child c = new Child();
        c.method();
    }
}

class Parent {
    int x = 10;
}
class Child extends Parent {
    void method() {
        System.out.println("x=" + x);
        System.out.println("this.x=" + this.x); // Child의 x
        System.out.println("super.x=" + super.x); // Parent의 x
    }
}

변수 만이 아니라 메서드 역시 super를 써서 호출할 수 있다.
조상 클래스의 메서드를 자손 클래스에서 오버라이딩 한 경우에 super를 사용한다.

class Point {    
    int x;
    int y;

    String getLocation() {
        int x;
        String getLocation() { // 오버라이딩
            // return "x: " + x + ", y : " + y + ", z : " + z; 
            return super.getLocation() + ", z :" + z; // 조상의 메서드 호출
    }
}

super()

this() 와 마찬가지로 super() 역시 생성자이다.
this()는 클래스의 다른 생성자를 호출하는 데 사용되지만
super()는 조상 클래스의 생성자를 호출하는 데 사용된다.

 

조상클래스의 생성자를 호출해야하는 이유는 자손 클래스의 멤버가 조상클래스의 멤버를 사용할 수도 있으므로 조상의 멤버들이 먼저 초기화되어 있어야하기 때문이다.
때문에 무조건 Object 클래스를 제외한 모든 클래스의 생성자는 첫 줄에 반드시 자신의 다른 생성자 또는 조상의 생성자를 호출해야한다.
(넣지 않으면 컴파일러가 자동으로 추가할 것이다.)

class PointTest {    
    public static void mian(String args[]) {    
        Point 3D p3 = new Point3D(1, 2, 3);
    }
}

class Point {
    int x, y;

    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();를 삽입한다.
        // super()는 Point3D의 조상인 Point클래스의 기본 생성자인 Point()를 의미한다.
            this.x = x;
            this.y = y;
            this.z = z;
        }

        String getLocation() { // 오버라이딩
            retrun "x: " + x + ", y : " +  y + ", z : " + z;
        }
    }

🚨 생성자가 정의되어 있는 클래스에는 컴파일러가 기본 생성자를 자동으로 추가하지 않는다.
때문에 위 코드는 Point()가 정의되어 있지 않기 때문에 super()가 호출되면 에러가 난다.
이를 해결하기 위해선 super()가 Point(int x, int y) 를 호출하도록 super(x, y); 로 수정하면 된다.

👶 메소드 오버라이딩

오버라이딩이란?

조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것.
Overied의 사전적인 의미는 위에 덮어쓰다(OverWrite) 이다.

class SuperTest2 {

}

오버라이딩 조건

✏ 이름이 같아야한다.
✏ 매개변수가 같아야한다.
✏ 반환 타입이 같아야한다.
✏ 접근 제어자는 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없다.
public > protecte > default > private
✏ 조상 클래스의 메서드 보다 많은 수의 예외를 선언할 수 없다.
조상클래스에 정의된 메서드보다 적은 개수의 예외를 선언해도 Exception 같은 모든 예외의 최고 조상을 선언하는 것도 할 수 없다. 조상보다 범위가 좁아야한다.
✏ 인스턴스 메서드를 static 메서드로 또는 그 반대로 변경할 수 없다.

오버로딩이란?

기존에 없는 새로운 메서드를 정의하는 것이다.
오버로딩은 너무 많이 적재했다(Overload) 를 의미한다.

같은 이름의 메서드에 매개변수의 타입, 개수를 다르게 한 것을 말한다.

class Parent {
    void parentMethod() {}
}

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

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

👶 다이나믹 메소드 디스패치

런타임에 오버라이딩 된 메서드가 실행되는 것을 의미한다.

런타임 시점에 다형성을 만족하도록 할 수 있다.

public class Animal {
  public void move() {
    System.out.println("Animals can move");
  }
}

public class Dog extends Animal {
  @Override
  public void move() {
    System.out.println("Dogs can walk and run");
  }
}

public class Main {

  public static void main(String[] args) {
    Animal a = new Animal(); // Animal 참조, Animal 객체
    Animal b = new Dog(); // Animal 참조, Dog 객체

    a.move(); // Animal 클래스에 정의된 메서드 실행
    b.move(); // Dog 클래스에 정의된 메서드가 실행됨(다이나믹 메소드 디스패치)
  }
}

👶 추상 클래스

추상 클래스는 추상메서드를 포함하고 있는 클래스를 말한다.

추상 메서드를 포함하고 있다는 것을 제외하고는 일반클래스와 전혀 다르지 않다.
추상 클래스에도 생성자가 있고, 멤버변수와 메서드도 가질 수 있다.

 

클래스에 abstract 키워드만 붙여주면 추상 클래스가 된다.

abstract class 클래스 이름 {
    ...
}

추상 메서드

기본적인 메서드는 선언부와 구현부(중괄호로 감싸진 부분)로 나뉘어져 있는데
추상 메서드는 구현부는 없고 선언부만 있는 것이다.
말 그대로 정확한 내용을 알 수 없으니 "추상적"인 메소드인 것이다.

 

추상 메서드도 abstract 키워드만 붙여주면 된다.

abstract 리턴타입 메서드 이름();

추상메서드를 사용하는 이유

메서드의 내용이 상속받는 클래스에 따라 달라질 수 있기 때문에 조상클래스에서는 선언부만 작성하고,
실제 내용은 상속받는 클래스에서 구현하도록 비워두는 것이다.

abstract class Player { // 추상클래스
    abstract void play(int pos); // 추상메서드
    abstract void stop(); // 추상메서드
}

class AudioPlayer extends Play {
    void play(int pos) { ... } // 추상 메서드를 구현(오버라이딩)
    void stop() { ... } // 추상 메서드를 구현(오버라이딩)
}

abstract class AbstractPlayer etends Player {
    void play(int pos) { ... } // 추상 메서드를 구현
}

추상화 : 클래스 간의 공통점을 찾아내서 공통의 조상을 만드는 작업
구체화 : 상속을 통해 클래스를 구현, 확장하는 작업

👶 제어자

제어자(modifier)는 클래스, 변수 또는 메서드의 선언부에 함께 사용되어 부가적인 의미를 부여한다.

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

static

"클래스의" 또는 "공통적인"의 의미를 가지고 있다.

인스턴스 변수는 하나의 클래스로부터 생성되었더라도 각기 다른 값을 유지하지만,

클래스 변수는 인스턴스 상관없이 같은 값을 가진다.

인스턴스를 사용하지 않고도 사용 가능하다.

 

인스턴스 메서드와 static메서드(클래스 메서드)의 차이는

메서드 내에서 인스턴스 멤버를 사용하는가의 여부에 있다.

static이 사용될 수 있는 곳 - 멤버변수, 메서드, 초기화 블럭

제어자	대상	의미
static	멤버변수	- 모든 인스턴스에 공통적으로 사용되는 클래스 변수가 된다. - 클래스 변수는 인스턴스를 생성하지 않고도 사용 가능하다. - 클래스가 메모리에 로드될 때 사용된다.
	메서드	- 인스턴스를 생성하지 않고도 호출이 가능한 static 메서드가 된다. - static 메서드 내에서는 인스턴스 멤버들을 직접 사용할 수 없다.

class Static Test {
    static int width = 200; // 클래스 변수(static 변수)
    static int height = 120; // 클래스 변수(static 변수

    static { 
        // static 변수의 복잡한 초기화 수행
    }

    static int max(int a, int b) { // 클래스 메서드(static 메서드)
        return a > b ? a : b;
    }
}

final

final은 '마지막의' 또는 '변경될 수 없는'의 의미를 가지고 있다.

변수에 사용되면 값을 변경할 수 없는 상수가 되고,

메서드에 사용되면 오버라이딩을 할 수 없고,

클래스에 사용되면 자신을 확장하는 자손 클래스를 정의하지 못하게 된다.

final이 사용될 수 있는 곳 - 클래스, 메서드, 멤버변수, 지역변수

제어자	대상	의미
final	클래스	변경될 수 없는 클래스, 확장될 수 없는 클래스가 된다. 그래서 final로 지정된 클래스는 다른 클래스의 조상이 될 수 없다.
	메서드	변경될 수 없는 메서드, final로 지정된 메서드는 오버라이딩을 통해 재정의될 수 없다.
	멤버변수	변수 앞에 final이 붙으면 값을 변경할 수 없는 상수가 된다.
	지역 변수

final class FinalTest { // 조상이 될 수 없는 클래스
    final int MAX_SIZE = 10; // 값을 변경할 수 없는 멤버변수(상수)

    final void getMaxSize() { // 오버라이딩 할 수 없는 메서드(변경 불가)
        final int LV = MAX_SIZE; // 값을 변경할 수 없는 지역변수(상수)
        return MAX_SIZE;
    }
}

생성자를 이용한 final 멤버 변수의 초기화

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

클래스 내에 매개변수를 갖는 생성자를 선언하여, 인스턴스를 생성할 때 final이 붙은 멤버 변수를 초기화하는데 필요한 값을 생성자의 매개벼수로부터 제공받는 것이다.

이 기능을 활용하면 인스턴스마다 final이 붙은 멤버변수가 다른 값을 갖도록 할 수 있다.

class Card {
    final int NUMBER; // 상수지만 선언과 함께 초기화하지 않고
    final String KIND; // 생성자에서 단 한번만 초기화할 수 있다.
    static int width = 100;
    static int height = 250;

    Card (String kind, int num) { // 매개변수로 넘겨받은 값으로 KIND와 NUMBER를 초기화한다.
        KINE = kind; 
        NUMBER = num;
    }

    Card() {
        this("HEART", 1);
    }

    public String toString() {
        return KIND + " " + NUMBER;
    }

    class FinalCardTest {
        public static void main(String args[]) {    
            Card c = new Card(HEART", 10);
            // c.NUMBER = 5 < 에러 발생
            System.out.pringln(c.KIND); // HEART
            System.out.pringln(c.NUMBer); // 10
            System.out.pringln(c) // HEART 10
        }
    }
}

abstract

abstract는 미완성의 의미를 가지고 있다.

absract가 사용될 수 있는 곳 - 클래스, 메서드

제어자	대상	의미
abstract	클래스	클래스 내에 추상 메서드가 선언되어 있음을 의미한다.
	메서드	선언부만 작성하고 구현부는 작성하지 않은 추상 메서드임을 알린다.

접근 제어자

접근 제어자는 멤버 또는 클래스에 사용되어 해당하는 멤버 또는 클래스를 외부에서 접근하지 못하도록 제한하는 역할을 한다.

접근 제어자가 사용될 수 있는 곳 - 클래스, 멤버변수, 메서드, 생성자
private - 같은 클래스 내에서만 접근이 가능하다.
default - 같은 패키지 내에서만 접근이 가능하다.
protected - 같은 패키지 내에서, 그리고 다른 패키지의 자손클래스에서 접근이 가능하다.
public - 접근 제한이 전혀 없다.

제어자	같은 클래스	같은 패키지	자손 클래스	전체
public	⭕	⭕	⭕	⭕
protected	⭕	⭕	⭕
(default)	⭕	⭕
private	⭕

public > protected > (default) > private

👶 Object 클래스

모든 클래스 상속 계층도의 최상위에 있는 조상 클래스.

클래스를 선언하면 컴파일러가 자동으로 extends Object를 붙인다.
toString(), equals(Object o) 등 모든 인스턴스가 가져야할 기본적인 메소드를 그냥 쓸 수 있는 이유이다.