상속 — 물려받아서 다시 쓰기

상속은 "기존 클래스가 가진 필드와 메서드를 그대로 물려받아, 재사용하고 확장하는 것"이에요. 새 클래스를 맨바닥부터 만드는 대신, 이미 잘 만들어 둔 클래스를 이어받아 필요한 부분만 더하는 거죠.

상속 관계에는 용어가 있어요. 물려주는 쪽을 부모(상위 클래스, 슈퍼클래스, super class), 물려받는 쪽을 자식(하위 클래스, 서브클래스, sub class)이라고 불러요.

상속은 extends(확장하다) 키워드로 표현해요. 자식 클래스 이름 뒤에 extends 부모클래스를 붙이면, 그 순간 자식은 부모의 필드·메서드를 모두 물려받습니다.

class 자식클래스 extends 부모클래스 {
    // 부모에게 물려받은 것 + 자식만의 새로운 것
}

아래 예제를 볼게요. Animal이 부모, Dog과 Cat이 자식이에요. 자식 안에는 eat()을 쓰지 않았는데도 부모에게서 물려받았기 때문에 그대로 호출할 수 있어요.

// 부모 클래스
class Animal {
    String name;

    void eat() {
        System.out.println(name + "가 먹이를 먹습니다.");
    }
    void sleep() {
        System.out.println(name + "가 잠을 잡니다.");
    }
}

// 자식 클래스 — Animal의 것을 물려받고, 자기 것을 추가
class Dog extends Animal {
    void bark() {                     // Dog만의 새로운 메서드
        System.out.println(name + ": 멍멍!");
    }
}

class Cat extends Animal {
    void scratch() {                  // Cat만의 새로운 메서드
        System.out.println(name + ": 스크래치!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "바둑이";     // 물려받은 필드
        d.eat();               // 물려받은 메서드 → 바둑이가 먹이를 먹습니다.
        d.bark();              // 자기 메서드     → 바둑이: 멍멍!

        Cat c = new Cat();
        c.name = "나비";
        c.sleep();             // 물려받은 메서드 → 나비가 잠을 잡니다.
        c.scratch();           // 자기 메서드     → 나비: 스크래치!
    }
}

super는 "부모(상위 클래스)"를 가리키는 키워드예요. 자식 안에서 부모의 필드나 메서드를 콕 집어 쓰고 싶을 때, 그리고 부모의 생성자를 호출할 때 사용해요.

class Animal {
    String name;

    Animal(String name) {              // 부모 생성자
        this.name = name;
        System.out.println("Animal 생성자 실행");
    }
    void info() {
        System.out.println("이름: " + name);
    }
}

class Dog extends Animal {
    String breed;                      // 품종 (Dog만의 필드)

    Dog(String name, String breed) {
        super(name);                   // ① 부모 생성자 먼저 호출 (반드시 첫 줄)
        this.breed = breed;
        System.out.println("Dog 생성자 실행");
    }
    void info() {
        super.info();                  // ② 부모의 info() 를 그대로 호출
        System.out.println("품종: " + breed);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("바둑이", "진돗개");
        d.info();
    }
}

오버라이딩(재정의)은 "부모에게 물려받은 메서드를, 자식이 같은 이름·같은 모양으로 새로 정의하는 것"이에요. 물려받은 대로 쓰는 게 아니라, 자식에 맞게 내용을 바꿔치기 하는 거죠.

class Animal {
    void sound() {
        System.out.println("동물이 소리를 냅니다.");
    }
}

class Dog extends Animal {
    @Override                          // 재정의라고 표시하는 애너테이션
    void sound() {                     // 이름·매개변수·반환형이 부모와 똑같음
        System.out.println("멍멍!");   // 내용만 자식 방식으로 교체
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("야옹!");
    }
}

public class Main {
    public static void main(String[] args) {
        new Animal().sound();   // 동물이 소리를 냅니다.
        new Dog().sound();      // 멍멍!   ← 재정의된 버전이 실행
        new Cat().sound();      // 야옹!
    }
}

여기서 자주 헷갈리는 게 오버로딩(Overloading)과의 차이예요. 이름이 비슷해서 섞이기 쉬운데, 완전히 다른 개념이에요. 표로 확실히 갈라 둡시다.

class Calculator {
    int add(int a, int b)         { return a + b; }        // ①
    int add(int a, int b, int c)  { return a + b + c; }    // ② 매개변수 개수 다름
    double add(double a, double b){ return a + b; }        // ③ 매개변수 타입 다름
}

자바의 모든 클래스는 Object 클래스를 맨 꼭대기 부모로 둡니다. extends를 안 써도, 자바가 자동으로 extends Object를 붙여줘요. 즉 세상의 모든 자바 클래스는 Object의 자손이에요.

// 이렇게 쓰면
class Person { }

// 자바 내부적으로는 이것과 같음
class Person extends Object { }

그 덕분에 우리가 만든 모든 객체는 Object에게 물려받은 메서드를 기본으로 가지고 있어요. 대표적인 두 가지를 봐요.

class Person {
    String name;
    Person(String name) { this.name = name; }

    @Override
    public String toString() {                 // Object의 toString() 재정의
        return "Person{name=" + name + "}";
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("홍길동");
        System.out.println(p);   // Person{name=홍길동}  ← 재정의한 toString() 자동 호출
    }
}

자바 클래스는 부모를 딱 하나만 가질 수 있어요. 이걸 단일 상속(Single Inheritance)이라고 해요. 즉 extends 뒤에는 클래스 하나만 올 수 있고, 여러 클래스를 동시에 상속받는 다중 상속은 불가능합니다.

class A { }
class B { }

// ✅ 가능 — 부모 하나
class C extends A { }

// ❌ 불가능 — 자바는 클래스 다중 상속을 지원하지 않음 (컴파일 오류)
// class D extends A, B { }

class Animal { }
class Pet extends Animal { }        // Pet 의 부모는 Animal
class Dog extends Pet { }           // Dog 의 부모는 Pet, 조상은 Animal → Object