매번 오버로딩(Overloading), 오버라이딩(Overriding)… 솔직히 개념 자체는 알고 있었고, 실제로 여러 번 사용도 해봤다. 그런데 가장 중요한 걸 놓치고 있었다. ‘왜 사용하는데? 어떤 상황에서 써야 하는데?’
이 질문이 나오면 항상 헉… 하면서 당황했다.
객체지향의 4가지 핵심 원칙(캡슐화, 다형성, 추상화, 상속)도 단순히 “알고 있다” 수준이 아니라, ‘왜(Why) 사용하는지’에 대한 고민을 제대로 해본 적이 없던 것 같다.
이번 기회에 그 부분까지 확실히 정리하고 넘어가보려 한다.

📚 객체지향 프로그래밍(OOP)

먼저 객체지향 프로그래밍(OOP, Object-Oriented Programming)이 무엇인지 간단하게 정리해보자.

데이터를 담는 변수와 그 데이터를 다루는 기능(메서드)을 하나로 묶어 '객체'로 만들고, 여러 객체들이 서로 협력하며 프로그램을 구성하는 방식

쉽게 말해서, “현실 세계의 사물이나 개념을 코드 안에서 객체 단위로 만들어 서로 상호작용하게 하는 방법”이라고 보면 된다.

그리고 객체지향을 이야기할 때는 항상 4가지 핵심 원칙(캡슐화, 상속, 다형성, 추상화)이 함께 나온다.

이 4가지 원칙이 객체지향 프로그래밍을 올바르게 설계하고 구현하는 근본적인 기준이 된다.

📌 1. 캡슐화(Encapsulation)

캡슐화는 데이터(변수)와 그 데이터를 다루는 기능(메서드)을 하나로 묶고, 외부에서 데이터를 직접 접근하지 못하도록 숨기는 것을 말한다.

즉, 정보 은닉(Information Hiding)을 통해 객체 내부 상태를 보호하고, 잘못된 접근이나 변경을 막는 것이다.

class Person {
    private String name;  // 외부에서 직접 접근 불가
    private int age;

    // Getter 메서드
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // Setter 메서드
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age > 0) { // 잘못된 값 방지
            this.age = age;
        }
    }
}

🤔 왜 캡슐화(Encapsulation)를 사용해?

1. 데이터 보호

• 객체 내부의 중요한 데이터가 외부에서 마음대로 바뀌는 걸 막을 수 있다.
  예: 나이(age)를 음수로 설정하는 실수를 방지
  2. 코드 안정성 향상
• 외부에서 직접 접근하지 못하게 막으므로, 객체 상태를 안전하게 유지할 수 있다.
  3. 유지보수 용이
• 내부 구현이 바뀌어도 getter/setter 같은 공개 인터페이스만 유지하면 외부 코드는 그대로 사용 가능
• 즉, 코드 수정 시 영향 범위를 최소화할 수 있다.
  4. 객체지향 설계 원칙 준수
• 정보 은닉(Information Hiding)을 통해 객체 간 결합도를 낮추고, 응집도를 높인다.

📌 2. 추상화 (Abstraction)

추상화는 불필요한 세부 사항은 숨기고, 중요한 특징이나 공통된 개념만 뽑아내는 것을 말한다.

즉, 객체의 핵심 속성과 기능만 정의하고, 구체적인 구현은 숨기는 것이다.

// 추상 클래스
abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    // 공통 기능은 선언만 (추상 메서드)
    abstract void sound();
}

// 구체 클래스
class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    void sound() {
        System.out.println(name + " : 멍멍!");
    }
}

class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    @Override
    void sound() {
        System.out.println(name + " : 야옹!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("철수");
        Animal cat = new Cat("나비");

        dog.sound(); // 철수 : 멍멍!
        cat.sound(); // 나비 : 야옹!
    }
}

🤔 왜 추상화(Abstraction)를 사용하는가?

1. 복잡성 감소

• 불필요한 세부 구현은 숨기고, 중요한 특징과 동작만 뽑아내므로 프로그램을 단순하게 설계할 수 있다.

2. 재사용성 향상

• 공통된 속성과 기능을 추출하여 여러 객체에서 재사용 가능하다.
  예: Animal 추상 클래스에서 sound()를 정의하면, Dog, Cat 등 다양한 동물 클래스에서 그대로 활용 가능

3. 유지보수 용이

• 세부 구현이 바뀌더라도 추상화된 인터페이스(메서드)만 유지하면, 외부 코드는 변경할 필요가 없다.

4. 객체지향 설계 원칙 준수

• 핵심 개념 중심으로 설계하여, 객체 간 결합도를 낮추고 응집도를 높인다.
• 즉, 설계가 더 깔끔하고 이해하기 쉬워진다.

📌 3. 상속(Inheritance)

상속은 기존 클래스(부모 클래스, Superclass)의 속성과 기능을 새로운 클래스(자식 클래스, Subclass)가 물려받아 재사용하는 것을 말한다.

즉, 공통된 기능을 부모 클래스에 정의하고, 자식 클래스에서 필요에 따라 확장하거나 수정할 수 있다.

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

    Animal(String name) {
        this.name = name;
    }

    void eat() {
        System.out.println(name + "가 밥을 먹는다");
    }
}

// 자식 클래스
class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    void play() {
        System.out.println(name + "가 공놀이를 한다");
    }
}

class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    void sleep() {
        System.out.println(name + "가 잠을 잔다");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("철수");
        Cat cat = new Cat("나비");

        // 상속받은 메서드 사용
        dog.eat(); // 철수가 밥을 먹는다
        cat.eat(); // 나비가 밥을 먹는다

        // 자식 클래스 고유 기능
        dog.play(); // 철수가 공놀이를 한다
        cat.sleep(); // 나비가 잠을 잔다
    }
}

🤔 왜 상속(Inheritance)를 사용하는가?

1. 코드 재사용

• 이미 작성한 클래스의 속성과 기능을 그대로 사용 가능
• 중복 코드를 줄이고 개발 효율성을 높인다.

2. 유지보수 용이

• 부모 클래스의 기능을 수정하면, 이를 상속받은 모든 자식 클래스가 자동으로 적용된다.

3. 계층적 구조 표현

• 현실 세계의 “~은 ~이다” 관계를 코드로 표현할 수 있다.
  예: Dog은 Animal이다 → Dog extends Animal

4. 다형성과 연계 가능

• 상속을 통해 공통 부모 타입으로 다양한 자식 객체를 다룰 수 있어, 다형성 구현이 가능하다.

📌 4. 다형성(Polymorphism)

다형성은 하나의 타입(주로 부모 클래스)으로 여러 자식 객체를 다룰 수 있는 성질을 말한다.

즉, 같은 코드지만 실제 객체 타입에 따라 다르게 동작하도록 만드는 것.

오버로딩(Overloading)과 오버라이딩(Overriding)을 통해 다형성을 구현한다고 볼 수 있다.

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

    Animal(String name) {
        this.name = name;
    }

    // 기본 소리
    void sound() {
        System.out.println(name + "가 소리를 낸다");
    }

    // 오버로딩 예시: 같은 이름, 다른 매개변수
    void sound(int times) {
        for (int i = 0; i < times; i++) {
            sound();
        }
    }
}

// 자식 클래스 1
class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    // 오버라이딩: 부모 메서드 재정의
    @Override
    void sound() {
        System.out.println(name + " : 멍멍!");
    }
}

// 자식 클래스 2
class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    @Override
    void sound() {
        System.out.println(name + " : 야옹!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 부모 타입으로 여러 자식 객체를 다루는 다형성
        Animal a1 = new Dog("철수");
        Animal a2 = new Cat("나비");

        a1.sound();       // 철수 : 멍멍!
        a2.sound();       // 나비 : 야옹!

        // 오버로딩 활용
        a1.sound(3);      // 철수 : 멍멍! x3
        a2.sound(2);      // 나비 : 야옹! x2

        // 배열과 다형성
        Animal[] animals = {new Dog("뽀삐"), new Cat("코코"), new Dog("바둑이")};
        for (Animal a : animals) {
            a.sound();    // 각 객체 타입에 맞는 소리 출력
        }
    }
}

🤔 왜 다형성을 사용하는가?

1. 코드 재사용성 향상

• 부모 클래스 타입으로 여러 자식 객체를 다룰 수 있으므로, 같은 코드로 다양한 객체를 처리할 수 있다.
  예: Animal[] animals 배열에 Dog, Cat, Bird 등을 한 번에 담고 반복문으로 모두 다룰 수 있음

2.유연한 설계 가능

• 프로그램 수정이나 확장이 쉽다.
• 새로운 자식 클래스가 추가되어도 기존 코드를 거의 수정하지 않고 그대로 사용 가능

3. 중복 코드 감소

• 공통 기능은 부모 클래스에 정의 → 자식 클래스에서 필요 시 재정의(overriding)
• 반복적인 if/else 또는 switch문 없이 여러 객체 처리 가능

4. 동적 바인딩(Dynamic Binding) 활용

• 실행 시점에 실제 객체 타입에 맞는 메서드가 호출되므로, 코드가 더 직관적이고 안전해진다.

📚 오버로딩(Overloading)

메서드 시그니처(Method Signature)

메서드 오버로딩(Method Overloading)의 핵심은 메서드 시그니처(Method Signature)에 있다.

메서드 시그니처(Method Signature)란 메서드 선언부에서 메서드를 구분할 수 있는 정보, 즉 메서드 이름과 매개변수 리스트를 의미한다.

두 메서드가 서로 다른 오버로딩 메서드가 되려면 다음 조건 중 하나라도 달라야 한다.

1. 메서드 이름

2. 매개변수의 수

3. 매개변수 타입의 순서

⚠️ 주의: 리턴타입은 메서드 시그니처에 포함되지 않는다. 따라서 리턴타입만 다르고 매개변수 리스트가 같으면 오버로딩이 불가능하다.

예시

public class Calculator {

    // 가능: 기본 덧셈
    public int add(int a, int b) {
        return a + b;
    }

    // 가능: 하나의 값만 처리
    public int add(int a) {
        return a;
    }

    // 가능: 실수 타입 덧셈
    public double add(double a, double b) {
        return a + b;
    }

    // 가능: 문자열 연결
    public String add(String a, String b) {
        return a + b;
    }

    // 불가능: 매개변수 수와 타입이 기존 메서드와 동일
    // public void add(int x, int y) { }

    // 불가능: 매개변수 수와 타입이 기존 메서드와 동일
    // public int add(int a, int b) { return 0; }
}

메서드 오버로딩(Method Overloading)

자바에서는 한 클래스 내에 같은 이름의 메서드를 중복해서 정의할 수 없다.

하지만 매개변수의 개수나 타입, 순서를 다르게 하면, 하나의 이름으로 여러 메서드를 작성할 수 있다.

즉, 메서드 오버로딩(Method Overloading)은 같은 이름의 메서드를 서로 다른 시그니처(Signature)로 여러 개 정의하는 것을 의미한다.

대표적인 예로는 println() 메서드를 들 수 있다.
PrintStream 클래스에는 다양한 타입의 매개변수를 받을 수 있도록 약 10가지 이상의 오버로딩된 println() 메서드가 정의되어 있다.

public void println() {
    newLine();
}

public void println(boolean x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

public void println(char x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

public void println(int x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

public void println(String s) {
    synchronized (this) {
        print(s);
        newLine();
    }
}

private void print(boolean b) {
    System.out.print(b);
}

private void print(char c) {
    System.out.print(c);
}

private void print(int i) {
    System.out.print(i);
}

private void print(String s) {
    System.out.print(s);
}

private void newLine() {
    System.out.println();
}

오버로딩(Overloading)은 비슷한 기능이 아닌 메소드들을 동일한 이름으로 작성하면, 협업 하는 개발자들끼리 혼란을 줄 수 있다.

오버로딩(Overloading)을 잘못 사용한다면?

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Collection<?>[] collections = {
            new LinkedHashSet<Integer>(),
            new LinkedList<String>(),
            new ArrayList<Double>(),
            new TreeSet<Character>()
        };

        for (Collection<?> c : collections) {
            System.out.println(classify(c));
        }
    }

    public static String classify(Set<?> s) {
        return "Set";
    }

    public static String classify(List<?> l) {
        return "List";
    }

    public static String classify(Collection<?> c) {
        return "Other Collection";
    }
}

출력 결과

Other Collection
Other Collection
Other Collection
Other Collection

오버로딩은 컴파일 시점에 참조 타입 기준으로 결정된다. 즉, 실제 객체가 LinkedHashSet이든, LinkedList든 상관없이 Collection 타입이므로 `classify(Collection c)`가 호출된다.

이 문제를 해결할려면 instanceof 를 활용해야한다.

 public static String classify(Collection<?> c) {
        if (c instanceof Set) return "Set";
        if (c instanceof List) return "List";
        return "Other Collection";
    }

📚 오버라이딩(Overriding)

상위 클래스가 가진 멤버 변수뿐만 아니라 메소드도 하위 클래스로 상속되어 하위 클래스에서 그대로 사용할 수 있다.

하지만 하위 클래스에서 필요에 따라 상위 클래스의 메소드를 재정의하여 사용할 수도 있다.

이처럼 상속 관계에 있는 클래스에서 같은 이름의 메소드를 하위 클래스가 새롭게 정의하는 것을 오버라이딩(Overriding)이라고 한다.

오버라이딩(Overriding) 조건

• 부모 클래스의 메소드를 오버라이딩하려면 메소드 시그니처(리턴 타입, 메소드 이름, 매개변수 리스트)가 동일해야 한다.

• 접근 제어자는 부모 클래스 메소드보다 좁은 범위로 변경할 수 없다.
  -> 예: 부모 메소드가 protected라면, 자식 클래스의 오버라이딩 메소드는 protected나 public이어야 한다.
  대부분의 경우 같은 범위의 접근 제어자를 사용한다.

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

오버라이딩(Overriding) 사용 이유

상속받은 메소드를 그대로 사용할 수도 있지만, 자식 클래스의 특성이나 필요에 따라 동작을 다르게 하고 싶을 때 오버라이딩이 필요하다.

만약 오버라이딩을 하지 않고 메소드 이름을 바꾸면, 부모 클래스의 메소드는 여전히 그대로 존재하게 되어 의도치 않은 기능이 호출될 수 있다.

따라서 자식 클래스에서 부모 클래스의 메소드를 재정의함으로써 불필요하거나 부적절한 기능을 제한하고, 원하는 동작으로 수정하기 위해 오버라이딩을 사용한다.

기존 기능 제한 또는 수정
부모 클래스의 메소드가 제공하는 기능 중 일부가 자식 클래스에 적합하지 않을 경우, 오버라이딩을 통해 불필요하거나 부적절한 기능을 제한할 수 있습니다.

---

예상 질문

캡슐화는 왜 사용하나요?

캡슐화를 사용하면 객체 내부 데이터를 외부에서 마음대로 바꾸지 못하게 보호할 수 있다. 예를 들어, Person 클래스의 age를 private으로 선언하고, setAge() 메서드에서 음수가 들어가지 않도록 검증하면, 잘못된 값으로 객체 상태가 깨지는 것을 막을 수 있다. 이렇게 하면 프로그램의 안정성을 유지하고, 내부 구현이 바뀌더라도 외부 코드는 그대로 사용할 수 있어 유지보수가 쉬워진다.

오버로딩과 오버라이딩은 왜 사용하나요?

오버로딩은 같은 이름의 메서드를 매개변수에 따라 여러 개 만들 수 있게 해주는 기능이다. 예를 들어, add(int a, int b)와 add(double a, double b)처럼 같은 이름으로 정수와 실수를 더하는 메서드를 만들 수 있다. 만약 오버로딩을 쓰지 않으면 기능은 같아도 메서드 이름을 다르게 지어야 해서 코드가 산만해지고, 이해하기 어렵다.

반면, 오버라이딩은 부모 클래스에서 상속받은 메서드를 자식 클래스 상황에 맞게 바꿔서 쓸 수 있게 해주는 기능이다. 예를 들어, Animal 클래스에 sound() 메서드가 있고, Cat 클래스에서 이를 오버라이딩하면 Cat 객체가 sound()를 호출했을 때 ‘야옹’이라고 출력된다. 오버라이딩을 하지 않으면 부모 메서드대로 동작해서 자식 객체에 맞는 기능을 구현할 수 없다.