[Java] 오버라이딩(override)이란? 오버라이딩 vs 오버로딩 / 오버라이딩의 조건

오버라이딩

 

 

오버라이딩의 사전적 의미는 어떻게 될까? 

override : ~위에 덮어쓰다(overwrite)
조상클래스로부터 상속받은 메서드의 내용을 변경하는 것

상속받은 메서드를 그대로 사용하기도 하지만, 자손 클래스 자신에 맞게 변경해야 하는 경우가 많다.
그럴때 오버라이딩이 쓰인다. 

 

 

 

2차원 x,y 좌표에 대한 클래스 Point와 3차원 x, y, z좌표에 대한 클래스 Point3D의 예제 코드를 보자.

class Point {
    int x;
    int y;

    String getLocation() {
        return "x :" + x + ", y :"+ y;
    }
}

class Point3D extends Point { // Point 상속 받음
    int z;

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

클래스 Point는 x, y 좌표를 반환하는데 3D Point는 x, y, z 세 개의 점이 필요하기 때문에 클래스 Point의 getLocation()는 x, y만 반환하기 때문에 Point3D에 맞게 오버라이딩을 해줬다.

그럼 오버라이딩의 조건은 어떻게 될까? 

오버라이딩의 조건

메서드 오버라이딩 조건

자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서드와
- 이름이 같아야 한다.
- 매개변수가 같아야 한다.
- 반환타입이 같아야 한다.

이름, 매개변수, 반화타입 세가지가 같아야 한다. 

위의 예제 코드에서도 

이름 : getLocation

매개변수 : 없음

반환타입 : String

으로 동일했다.

 

 

 

 

오버라이딩 제약

조상 클래스의 메서드를 자손 클래스에서 오버라이딩할 때
1. 접근 제어자를 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없다.
2. 예외는 조상 클래스의 메서드보다 많이 언급할 수 없다.
3. 인스턴스메서드를 static 메서드로 또는 그 반대로 변경할 수 없다.

 

3가지 제약이 있다.

각각 자세히 살펴보자.

 

 

 

 

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

class Parent {
    public void method1() {
        System.out.println("Parent의 method1");
    }

    protected void method2() {
        System.out.println("Parent의 method2");
    }
}

class Child extends Parent {
    // public -> protected로 변경할 수 없다.
    // 컴파일 에러 발생
    @Override
    protected void method1() {
        System.out.println("Child의 method1");
    }

    // 접근 제어자를 넓은 범위로 변경하는 것은 허용된다.
    // protected -> public으로 변경 가능합니다.
    @Override
    public void method2() {
        System.out.println("Child의 method2");
    }
}

 

접근 제어자는 넓은 범위로 변경하는 것은 허용되지만, 좁은 범위로는 변경할 수 없다. 
public > protected > (default)> private
public이 가장 넓은 범위이고, private으로 갈수록 좁은 범위이다. 

 

 

 

 

 

2️⃣ 조상 클래스의 메서드보다 많은 수의 예외를 선언할 수 없다.

class Parent {
    public void doSomething() throws IOException {
        // ...
    }
}

class Child extends Parent {
    // 컴파일 에러 발생!
    // 자식 클래스에서 더 많은 예외를 선언할 수 없다.
    public void doSomething() throws IOException, SQLException {
        // ...
    }
}

조상 클래스에선 IOException만 예외를 선언했고, 자식 클래스에선 IOException, SQLException을 선언했다.
조상과 동일한 예외만을 가져올 수 있기 때문에 위 코드에서는 에러가 발생한다.

 

 

 

 

❓ 근데 SQLException도 쓰고 싶은데 그럼 어떻게 해 ❓

class Child extends Parent {
    public void doSomething() throws IOException {
        try {
            // ...
        } catch (SQLException e) {
            // SQLException 처리
        }
    }
}

그럴 때는 try-catch문을 이용하여 예외 처리를 할 수 있다.

 

 

 

 

 

 

 

3️⃣ 인스턴스메서드를 static 메서드로 또는 그 반대로 변경할 수 없다.

 

인스턴스 메서드 → static 메서드로 변경하려고 시도하는 예제 코드

class Parent {
    // 인스턴스 메서드
    public void instanceMethod() {
        System.out.println("부모 클래스의 인스턴스 메서드");
    }
}

class Child extends Parent {
    // static 메서드로 변경하려고 시도
    // 컴파일 에러 발생!
    public static void instanceMethod() {
        System.out.println("자식 클래스의 static 메서드");
    }
}

instance 메서드를 static 메서드로 변경할 수 없다.

 

 

 

static 메서드→ 인스턴스 메서드로 변경하려고 시도하는 예제 코드

class Parent {
    // static 메서드
    public static void staticMethod() {
        System.out.println("부모 클래스의 static 메서드");
    }
}

class Child extends Parent {
    // 인스턴스 메서드로 변경하려고 시도
    // 컴파일 에러 발생!
    public void staticMethod() {
        System.out.println("자식 클래스의 인스턴스 메서드");
    }
}

static 메서드를 instance 메서드로 변경할 수 없다. 

 

 

 

 

import java.io.*;

class Parent {
    public static void staticMethod() {
        System.out.println("부모 클래스의 static 메서드");
    }

    public void instanceMethod() {
        System.out.println("부모 클래스의 인스턴스 메서드");
    }
}

class Child extends Parent {
    // 오버라이딩이 아니라 새로운 static 메서드를 정의한 것이다.
    public static void staticMethod() {
        System.out.println("자식 클래스의 static 메서드");
    }

    // 오버라이딩이다.
    @Override
    public void instanceMethod() {
        System.out.println("자식 클래스의 인스턴스 메서드");
    }
}

public class Main {
    public static void main(String[] args) throws IOException {
        Parent.staticMethod(); // "부모 클래스의 static 메서드"
        Child.staticMethod();  // "자식 클래스의 static 메서드"

        Parent parent = new Parent();
        parent.instanceMethod(); // "부모 클래스의 인스턴스 메서드"

        Child child = new Child();
        child.instanceMethod(); // "자식 클래스의 인스턴스 메서드"
    }
}

/* 출력 
부모 클래스의 static 메서드
자식 클래스의 static 메서드
부모 클래스의 인스턴스 메서드
자식 클래스의 인스턴스 메서드
*/

호출할때엔

static을 쓴다면 클래스이름.메서드이름() 이라고 써야 한다.

오버라이딩을 한다면 참조변수.메서드이름() 이라고 써야 한다.

 

static

• static은 클래스의 인스턴스화 없이 어디서든 호출 할 수 있기 때문에 오버라이딩 할 필요가 없다.

→ 객체 인스턴스와는 독립적으로 동작한다.

• static은 클래스 레벨에서 동작한다.

 

인스턴스

• 인스턴스 메서드는 객체 레벨에서 동작

오버라이딩을 할 때엔 static을 써선 안 된다.

 

 

오버로딩 vs 오버라이딩

오버로딩(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) {} // 오버로딩
}

 

 

Animal 예제 코드

class Animal {
    // 오버로딩: makeSound 메서드를 여러 버전으로 정의
    public void makeSound() {
        System.out.println("동물이 소리를 내고 있습니다.");
    }
    
    // 오버로딩: makeSound 메서드를 여러 버전으로 정의
    public void makeSound(String sound) {
        System.out.println("동물이 " + sound + " 소리를 내고 있습니다.");
    }
}

class Dog extends Animal {
    // 오버라이딩: 상위 클래스의 makeSound 메서드를 재정의
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // "동물이 소리를 내고 있습니다."
        animal.makeSound("끼룩"); // "동물이 끼룩 소리를 내고 있습니다."
        
        Dog dog = new Dog();
        dog.makeSound();    // "멍멍!"
        // dog.makeSound("끼룩"); // 컴파일 에러: Dog 클래스에는 makeSound(String sound) 메서드가 없음
    }
}

 

 

 

 

super

자손 클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조 변수이다.

this를 사용했듯이 상속받은 멤버와 자신의 멤버와 이름이 같을 때는 super를 붙여서 구별할 수 있다.

class Parent {
    int x=10;
}

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

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

/* 
x=10
this.x=10
super.x=10
*/

 

 

 

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); 
    }
}

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

/* 
x=20
this.x=20
super.x=10
*/

같은 이름의 멤버변수가 Parent에도 있고, Child에도 있을 때는 super.x와 this.x는 서로 다른 값을 참조하게 된다.

super.x → 조상 클래스로부터 상속받은 멤버변수 x

this.x → 자손 클래스에 선언된 멤버변수 x

 

 

super() - 조상 클래스의 생성자

this()와 마찬가지로 super() 역시 생성자이다.

this()→ 같은 클래스의 다른 생성자를 호출하는 데 사용

super() → 조상 클래스의 생성자를 호출하는 데 사용

 

Object 클래스를 제외한 모든 클래스의 생성자 첫 줄에 생성자,this() 또는 super(),를 호출해야 한다. 그렇지 않으면 컴파일러가 자동적으로 super();를 생성자의 첫 줄에 삽입한다.

 

 

class Parent {
    public Parent() {
        System.out.println("부모 클래스의 생성자");
    }
}

class Child extends Parent {
    public Child() {
        // 컴파일러가 자동으로 super();를 생성자의 첫 줄에 삽입
        // 따라서 부모 클래스의 기본 생성자가 호출됨
        System.out.println("자식 클래스의 생성자");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

Child 클래스에 생성자 정의를 하지 않으면 super();이 자동으로 생성된다. 

인스턴스를 생성할 때는 클래스를 선택하는 것만큼 생성자를 선택하는 것도 중요하다

 

클래스와 생성자의 역할 및 관계 
1️⃣ 클래스 - 어떤 클래스의 인스턴스를 생성할 것인가?
2️⃣ 생성자 - 선택한 클래스의 어떤 생성자를 이용해서 인스턴스를 생성할 것인가?

 

// Car 클래스 정의
public class Car {
    private String model;
    private String color;
    private int speed;

    // 생성자 - 모델과 색상을 인자로 받는 생성자
    public Car(String model, String color) {
        this.model = model;
        this.color = color;
        this.speed = 0; // 초기 속도는 0으로 설정
    }

    // 생성자 - 모델, 색상, 초기 속도를 인자로 받는 생성자
    public Car(String model, String color, int speed) {
        this.model = model;
        this.color = color;
        this.speed = speed;
    }

    // Getter와 Setter 메서드 생략
}

// 메인 클래스
public class Main {
    public static void main(String[] args) {
        // Car 클래스의 생성자를 선택하여 인스턴스 생성
        Car car1 = new Car("Toyota", "Red");
        Car car2 = new Car("Tesla", "Black", 100);

        // 생성된 인스턴스의 정보 출력
        System.out.println("Car 1: Model - " + car1.getModel() + ", Color - " + car1.getColor() + ", Speed - " + car1.getSpeed());
        System.out.println("Car 2: Model - " + car2.getModel() + ", Color - " + car2.getColor() + ", Speed - " + car2.getSpeed());
    }
}

여기서 어떤 생성자를 생성할지 잘 선택을 해야 한다.

speed가 필요하다면 두번째 생성자 메서드를 이용해야 한다.

class Point {
    int x = 10;
    int y = 20;

    Point(int x, int y){
        this.x = x; // 컴파일러에 의해 위에 super() 자동 생성 -> Object()를 의미한다.
        this.y = y; 
    }
}

class Point3D extend Point {
    int z = 30;

    Point3D() {
        this(100, 200, 300);
    }

    Point3D(int x, int y, int z) {
        super(x,y);
        this.z = z;
    }
}

class PointTest2 {
    public static void main(String args[]) {
        Point3D p3 = new Point3D();
        System.out.println("p.3x=" + p3.x);
        System.out.println("p.3y=" + p3.y);
        System.out.println("p.3z=" + p3.z);
    }
}

/* 
    p3.x=100
    p3.y=200
    p3.z=300
*/