Java - Overloading & Overriding

Overloading (오버로딩)

메서드 시그니처(Method Signature)

메서드 오버로딩의 핵심은 메서드 시그니처에 있다. 메서드 시그니처란 메서드의 선언부에 명시되어 있는 매개변수의 리스트를 말한다. 두 개의 메서드는 다음 조건을 만족하면 같은 시그니처를 가진다고 할 수 있다.

 

1. 메서드의 이름

2. 매개변수의 수

3. 매개변수 타입의 순서

 

여기서 중요한 점은 리턴 타입이 메서드 시그니처에 포함되지 않는다는 점이다.

 

public class Test {
    
    /** 기준이 되는 메서드 */
    public int method(int x, int y) {
        return x + y;
    }
    
    /** 메서드 정의 가능 */
    public int method(int x) {
        return x;
    }
    
    /** 메서드 정의 가능 */
    public String method(String s) {
        return s;
    }
    
    /** 메서드 정의 불가능(매개변수의 수, 매개변수 타입의 순서가 동일) */
    public void method(int a, int b) {
    
    }
    
    /** 메서드 정의 불가능(매개변수의 수, 매개변수 타입의 순서가 동일) */
    public int method(int x, int y) {
        return 1;
    }
}

 

오버로딩이란?

1. 메서드 오버로딩

Java에서는 한 클래스 내에 같은 이름의 메서드를 두 개 이상 가질 수 없다. 하지만, 매개변수의 개수나 타입의 순서를 다르게 한다면, 하나의 이름으로 여러 개의 메서드를 작성할 수 있다.

메서드 오버로딩은 같은 이름의 메서드를 중복해서 정의하는 것을 의미한다. 즉, 서로 다른 메서드 시그니처를 갖는 여러 개의 메서드를 같은 이름으로 정의하는 것이라고 할 수 있다.

 

/**
* Terminates the current line by writing the line separator string.  The
* line separator string is defined by the system property
* {@code line.separator}, and is not necessarily a single newline
* character ({@code '\n'}).
*/
public void println() {
    newLine();
}

/**
* Prints a boolean and then terminate the line.  This method behaves as
* though it invokes {@link #print(boolean)} and then
* {@link #println()}.
*
* @param x  The {@code boolean} to be printed
*/
public void println(boolean x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

/**
* Prints a character and then terminate the line.  This method behaves as
* though it invokes {@link #print(char)} and then
* {@link #println()}.
*
* @param x  The {@code char} to be printed.
*/
public void println(char x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

메서드 오버로딩의 대표적인 예로는 println() 메서드를 들 수 있다. PrintStream 클래스에는 어떤 종류의 매개 변수를 지정해도 데이터를 출력할 수 있도록 아래와 같이 10개의 오버로딩된 println() 메서드를 정의하고 있다.

 

2. 생성자 오버로딩

생성자 오버로딩이란 하나의 클래스 안에 같은 이름의 메서드를 중복하여 정의하고, 클래스로부터 객체를 생성할 때 필요한 변수들로만 적절히 초기화하기 위해 사용되는 것을 의미한다.

 

오버로딩의 장점과 단점

장점

 - 다형성을 구현할 수 있다.

 - 소스 코드의 가독성이 좋아진다.

 - 메서드의 이름을 절약할 수 있다.

 - 기능 예측이 쉬워진다.

 

단점

 - 비슷한 기능이 아닌 메서드를 동일한 이름으로 사용하여 공동으로 개발할 경우, 다른 개발자에게 혼동을 줄 수 있다.

 

오버로딩을 잘못 사용한 경우

예시01

public class Main {
    public static void main(String[] args) {
        Collection<?>[] collections = {
            new HashSet<String>(),
            new ArrayList<Integer>(),
            new HashMap<String, String>().values()
        };
        
        for(Collection<?> collection : collections) {
            System.out.println(classify(collection);
        }
    }
        
    public static String classify(Set<?> s) {
        return "Set";
    }
        
    public static String classify(List<?> s) {
        return "List";
    }
        
    public static String classify(Collection<?> s) {
        return "Unknown Collection";
    }
}

위 코드의 결과는 "Unknown Collection"만 세 개 출력될 것이다.

그 이유는 오버로딩된 메서드 중 어떤 메서드를 호출할 것인지는 컴파일 시점에 결정되기 때문이다. 이러한 이유로 컴파일 시점에 Collection<?> 타입이었던 객체 모두 Collection을 파라미터로 가지는 메서드가 실행되는 것이다.

오버라이딩한 메서드는 동적으로 선택되고, 오버로딩한 메서드는 정적으로 선택된다는 점을 기억해야 한다.

 

public static String classify(Collections<?> c) {
    return c instanceof Set ? "SET" : c instanceof List ? "List" : "Unknown Collection";
}

위 문제를 해결하기 위해서는 위 코드와 같이 instanceof로 타입을 체크해야 한다.

 

예시02

public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        List<Integer> list = new ArrayList();
        
        for(int i = -3; i < 3; i++) {
            set.add(i);
            list.add(i);
        }
        
        for(int i = 0; i < 3; i++) {
            set.remove(i);
            list.remove(i);
        }
        
        System.out.println(set + " " + list);
    }
}

위 코드는 set과 list에 -3, -2, -1, 0, 1, 2를 넣고 0 이상의 수를 지우도록 하는 코드이다.

 

 

코드의 결과는 위와 같이 의도한 바와는 다르게 출력될 것이다.

 

set.remove(i) 메서드의 시그니처는 remove(Object)이다. 오버로딩한 다른 메서드가 없으니 기대한 대로 동작해서 0 이상의 수를 잘 제거한다. 하지만, list.remove(i)는 오버로딩한 remove(int index)와 remove(Object) 중 전자를 선택한다.

 

list.remove((Integer) i);

따라서, 의도한 대로 동작하기 위해서는 위와 같이 list.remove(i)의 인자를 Integer로 형변환해야 한다.

---

Overriding (오버라이딩)

오버라이딩이란?

상위 클래스가 가지고 있는 멤버 변수가 하위 클래스로 상속되는 것처럼 상위 클래스가 가지고 있는 메서드도 하위 클래스로 상속되어 하위 클래스에서 사용할 수 있다. 또한, 하위 클래스에서 메서드를 재정의해서 사용할 수 있다. 이때 상속 관계에 있는 클래스 간에 같은 이름의 메서드를 재정의하는 기술을 오버라이딩이라고 한다.

 

이러한 오버라이딩은 다음과 같은 조건을 가진다.

 

1. 부모 클래스의 메서드와 동일한 시그니처를 가져야 한다.

2, 접근 제어자는 부모 클래스의 메서드보다 좁은 범위로 변경할 수 없다.

3. 부모 클래스의 메서드보다 많은 수의 예외를 선언할 수 없다.

 

오버라이딩의 필요성

하위 클래스가 상속받은 메서드를 그대로 사용할 수도 있지만, 상황에 맞게 변경하여 사용하고 싶은 경우도 발생할 수 있다. 이때 오버라이딩을 하지 않으면 부모 클래스의 메서드와 비슷한 일을 하는 데도 불구하고 새로운 메서드를 선언해야 한다. 

예를 들어, 부모 클래스인 Car에서 move() 메서드가 있고 하위 클래스인 SuperCar, SnowCar 등이 있다면, 하위 클래스 자동차들이 다른 속도로 달리고 싶더라도 move() 메서드가 아닌 새로운 메서드를 만들어야 하기 때문에 상당히 비효율적이다.

---

Dispatch(디스패치)

디스패치란?

Java는 객체 지향 프로그래밍 언어로서 객체 간의 메시지 전송을 기반으로 문제를 해결해 나간다. 메시지 전송이라는 것은 결국 메서드 호출을 의미하는데, 이것을 디스패치라고 부른다.

디스패치는 정적 디스패치와 동적 디스패치가 있는데 정적은 구현 클래스를 이용해 컴파일 시점에서부터 어떤 메서드가 호출될지 정해져 있는 것이고, 동적은 인터페이스를 이용해 참조함으로써 호출되는 메서드가 동적으로 정해지는 것을 의미한다.

 

Static Method Dispatch(정적 메서드 디스패치)

class Parent {
    public void method01() {
        System.out.println("Parent method01입니다.");
    }
}

class Child extends Parent {
    @Override
    public void method01() {
        System.out.println("Child method01입니다.");
    }
}

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

위 코드에서 Child 클래스의 method01() 메서드는 부모 클래스 Parent method01() 메서드를 오버라이딩 하였다. Main 클래스에서 child.method01()을 호출했을 때 Child 타입의 객체를 생성했기 때문에 Child 클래스의 오버라이딩된 메서드가 호출된다는 것을 예상할 수 있다.

Java에서 객체 생성은 런타임 시 호출되기 때문에 컴파일 시점에서 알 수 있는 것은 타입에 대한 정보이다. 따라서, 컴파일러 역시 Child의 메서드를 호출하고 실행해야 할 것을 명확하게 알고 있다. 이를 정적 메서드 디스패치라고 한다.

 

Dynamic Method Dispatch(동적 메서드 디스패치)

class Parent {
    public void method01() {
        System.out.println("Parent method01입니다.");
    }
}

class Child extends Parent {
    @Override
    public void method01() {
        System.out.println("Child method01입니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        parent.method01();
    }
}

이 코드에서 parent.method01() 메서드를 호출하면 컴파일 시점에 어떤 객체의 메서드가 호출될지 알 수 없다. 왜냐하면 컴파일러는 타입만 체크하기 때문이다. parent 변수는 Parent라는 클래스 타입을 갖고 있기 때문에 Child 객체를 할당할지라고 Child 객체의 method01() 메서드에 접근할 수 없다.

하지만, 결과는 Child 객체의 method01() 메서드가 호출된다. 왜냐하면 컴파일러는 어떤 메서드를 호출해야 되는지 모르지만, 런타임 시점에 어떤 메서드를 호출할지 정해지기 때문이다. 이를 동적 메서드 디스패치라고 부른다.

---

출처

ㆍ http://wiki.hash.kr/index.php/%EC%98%A4%EB%B2%84%EB%A1%9C%EB%94%A9

ㆍ https://wedul.site/296

ㆍ http://wiki.hash.kr/index.php/%EC%98%A4%EB%B2%84%EB%9D%BC%EC%9D%B4%EB%94%A9

ㆍ https://github.com/highright96/java-livestudy/blob/main/live-study/week6/week6.md

ㆍ https://steady-coding.tistory.com/540