오버라이딩(Overriding) vs. 오버로딩(Overloading)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 오버라이딩 예시
class Animal:
    def speak(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def speak(self):  # 오버라이딩
        print("멍멍!")

d = Dog()
d.speak()  # "멍멍!"

# 오버로딩 예시 (Python은 직접 지원하지 않으나 기본값/가변인자 활용)
class Calculator:
    def add(self, a, b=0, c=0):
        return a + b + c

calc = Calculator()
print(calc.add(1, 2))      # 3
print(calc.add(1, 2, 3))   # 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Bark"

a = Animal()
d = Dog()
print(a.speak())  # ...
print(d.speak())  # Bark

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from functools import singledispatch

@singledispatch
def process(value):
    print("Default")

@process.register
def _(value: int):
    print("Processing int")

@process.register
def _(value: str):
    print("Processing str")

process("hello")  # Processing str
process(10)       # Processing int

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

# 오버라이딩(Overriding) 예시 - 온라인 쇼핑몰 결제 시스템

from abc import ABC, abstractmethod
from typing import Union, List
import logging

# 로깅 설정
logging.basicConfig(level=logging.INFO)

class PaymentProcessor(ABC):
    """결제 처리 추상 클래스 - 오버라이딩의 기반"""
    
    def __init__(self, merchant_id: str):
        self.merchant_id = merchant_id
        self.transaction_log = []
    
    def validate_amount(self, amount: float) -> bool:
        """공통 검증 로직"""
        return amount > 0 and amount <= 1000000
    
    @abstractmethod
    def process_payment(self, amount: float, **kwargs) -> dict:
        """추상 메서드 - 자식 클래스에서 반드시 오버라이딩"""
        pass
    
    def log_transaction(self, transaction_data: dict):
        """공통 로깅 기능"""
        self.transaction_log.append(transaction_data)
        logging.info(f"Transaction logged: {transaction_data['transaction_id']}")

class CreditCardProcessor(PaymentProcessor):
    """신용카드 결제 처리 - 오버라이딩 구현"""
    
    def process_payment(self, amount: float, card_number: str, cvv: str, expiry: str) -> dict:
        """신용카드 결제 로직 - 오버라이딩"""
        # 부모 클래스의 검증 로직 활용
        if not self.validate_amount(amount):
            raise ValueError("Invalid payment amount")
        
        # 신용카드 특화 로직
        transaction_id = f"CC_{self.merchant_id}_{len(self.transaction_log) + 1:04d}"
        
        # 결제 처리 시뮬레이션
        result = {
            "transaction_id": transaction_id,
            "payment_method": "Credit Card",
            "amount": amount,
            "status": "approved",
            "card_last_four": card_number[-4:],
            "authorization_code": f"AUTH_{transaction_id}"
        }
        
        # 부모 클래스의 로깅 기능 활용
        self.log_transaction(result)
        return result

class PayPalProcessor(PaymentProcessor):
    """PayPal 결제 처리 - 오버라이딩 구현"""
    
    def process_payment(self, amount: float, paypal_email: str, **kwargs) -> dict:
        """PayPal 결제 로직 - 오버라이딩"""
        if not self.validate_amount(amount):
            raise ValueError("Invalid payment amount")
        
        # PayPal 특화 로직
        transaction_id = f"PP_{self.merchant_id}_{len(self.transaction_log) + 1:04d}"
        
        result = {
            "transaction_id": transaction_id,
            "payment_method": "PayPal",
            "amount": amount,
            "status": "approved",
            "paypal_email": paypal_email,
            "payer_id": f"PAYER_{transaction_id}"
        }
        
        self.log_transaction(result)
        return result

# 오버로딩(Overloading) 예시 - Python에서는 기본 매개변수와 *args, **kwargs로 구현

class Calculator:
    """계산기 클래스 - 오버로딩 시뮬레이션"""
    
    def add(self, *args) -> Union[int, float]:
        """덧셈 - 오버로딩 시뮬레이션 (가변 인자 사용)"""
        if len(args) == 0:
            return 0
        elif len(args) == 1:
            return args[0]
        else:
            return sum(args)
    
    def multiply(self, x, y=1, z=1) -> Union[int, float]:
        """곱셈 - 오버로딩 시뮬레이션 (기본 매개변수 사용)"""
        return x * y * z
    
    def process_data(self, data, operation_type="sum"):
        """데이터 처리 - 타입별 다른 처리 (오버로딩 패턴)"""
        if isinstance(data, (int, float)):
            # 단일 숫자 처리
            return self._process_number(data, operation_type)
        elif isinstance(data, list):
            # 리스트 처리
            return self._process_list(data, operation_type)
        elif isinstance(data, dict):
            # 딕셔너리 처리
            return self._process_dict(data, operation_type)
        else:
            raise TypeError(f"Unsupported data type: {type(data)}")
    
    def _process_number(self, num: Union[int, float], operation: str) -> Union[int, float]:
        """숫자 처리 내부 메서드"""
        if operation == "square":
            return num ** 2
        elif operation == "double":
            return num * 2
        else:
            return num
    
    def _process_list(self, data_list: List, operation: str) -> Union[int, float, List]:
        """리스트 처리 내부 메서드"""
        if operation == "sum":
            return sum(data_list)
        elif operation == "average":
            return sum(data_list) / len(data_list) if data_list else 0
        elif operation == "max":
            return max(data_list) if data_list else None
        else:
            return data_list
    
    def _process_dict(self, data_dict: dict, operation: str) -> Union[int, float, dict]:
        """딕셔너리 처리 내부 메서드"""
        values = list(data_dict.values())
        if operation == "sum":
            return sum(v for v in values if isinstance(v, (int, float)))
        elif operation == "count":
            return len(data_dict)
        else:
            return data_dict

# 실사용 예시 및 테스트
def demonstrate_overriding():
    """오버라이딩 동작 시연"""
    print("=== 오버라이딩(Overriding) 시연 ===")
    
    # 다형성을 통한 동일한 인터페이스, 다른 구현
    processors = [
        CreditCardProcessor("MERCHANT001"),
        PayPalProcessor("MERCHANT001")
    ]
    
    for processor in processors:
        print(f"\n{processor.__class__.__name__} 결제 처리:")
        
        if isinstance(processor, CreditCardProcessor):
            result = processor.process_payment(
                amount=99.99,
                card_number="1234567812345678",
                cvv="123",
                expiry="12/25"
            )
        else:  # PayPalProcessor
            result = processor.process_payment(
                amount=99.99,
                paypal_email="user@example.com"
            )
        
        print(f"결제 결과: {result}")
        print(f"거래 로그 수: {len(processor.transaction_log)}")

def demonstrate_overloading():
    """오버로딩 동작 시연"""
    print("\n=== 오버로딩(Overloading) 시연 ===")
    
    calc = Calculator()
    
    # 같은 메서드명, 다른 매개변수로 다양한 동작
    print(f"add() 호출:")
    print(f"  매개변수 없음: {calc.add()}")
    print(f"  단일 매개변수: {calc.add(5)}")
    print(f"  두 매개변수: {calc.add(3, 7)}")
    print(f"  여러 매개변수: {calc.add(1, 2, 3, 4, 5)}")
    
    print(f"\nmultiply() 호출:")
    print(f"  기본값 사용: {calc.multiply(5)}")
    print(f"  두 매개변수: {calc.multiply(5, 3)}")
    print(f"  세 매개변수: {calc.multiply(2, 3, 4)}")
    
    print(f"\nprocess_data() 타입별 처리:")
    print(f"  숫자 처리: {calc.process_data(10, 'square')}")
    print(f"  리스트 처리: {calc.process_data([1, 2, 3, 4, 5], 'sum')}")
    print(f"  딕셔너리 처리: {calc.process_data({'a': 1, 'b': 2, 'c': 3}, 'sum')}")

def demonstrate_polymorphism():
    """다형성 시연 - 오버라이딩의 핵심"""
    print("\n=== 다형성(Polymorphism) 시연 ===")
    
    def process_payment_batch(processor: PaymentProcessor, transactions: List[dict]):
        """배치 결제 처리 - 다형성 활용"""
        results = []
        for transaction in transactions:
            try:
                if isinstance(processor, CreditCardProcessor):
                    result = processor.process_payment(**transaction)
                elif isinstance(processor, PayPalProcessor):
                    result = processor.process_payment(**transaction)
                results.append(result)
            except Exception as e:
                print(f"결제 실패: {e}")
        return results
    
    # 동일한 함수로 다른 타입의 프로세서 처리
    cc_processor = CreditCardProcessor("BATCH001")
    pp_processor = PayPalProcessor("BATCH001")
    
    cc_transactions = [
        {"amount": 29.99, "card_number": "1111222233334444", "cvv": "456", "expiry": "01/26"},
        {"amount": 149.50, "card_number": "5555666677778888", "cvv": "789", "expiry": "06/27"}
    ]
    
    pp_transactions = [
        {"amount": 75.25, "paypal_email": "buyer1@email.com"},
        {"amount": 200.00, "paypal_email": "buyer2@email.com"}
    ]
    
    print("신용카드 배치 처리:")
    cc_results = process_payment_batch(cc_processor, cc_transactions)
    for result in cc_results:
        print(f"  - {result['transaction_id']}: {result['amount']}")
    
    print("\nPayPal 배치 처리:")
    pp_results = process_payment_batch(pp_processor, pp_transactions)
    for result in pp_results:
        print(f"  - {result['transaction_id']}: {result['amount']}")

# 메인 실행
if __name__ == "__main__":
    demonstrate_overriding()
    demonstrate_overloading()
    demonstrate_polymorphism()
    
    print("\n=== 성능 비교 시연 ===")
    import time
    
    # 오버라이딩 성능 (런타임 바인딩)
    start_time = time.time()
    processors = [CreditCardProcessor("PERF001"), PayPalProcessor("PERF001")]
    for _ in range(1000):
        for processor in processors:
            if isinstance(processor, CreditCardProcessor):
                processor.process_payment(10.0, "1234567890123456", "123", "12/25")
            else:
                processor.process_payment(10.0, "test@email.com")
    
    overriding_time = time.time() - start_time
    
    # 오버로딩 성능 (컴파일타임 바인딩)
    start_time = time.time()
    calc = Calculator()
    for _ in range(1000):
        calc.add(1, 2)
        calc.add(1, 2, 3)
        calc.multiply(5)
        calc.multiply(5, 3)
    
    overloading_time = time.time() - start_time
    
    print(f"오버라이딩 1000회 실행 시간: {overriding_time:f}초")
    print(f"오버로딩 2000회 실행 시간: {overloading_time:f}초")
    print(f"성능 비율 (오버라이딩/오버로딩): {overriding_time/overloading_time:f}x")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 부모 클래스
class Animal {
    public void makeSound() {
        System.out.println("동물이 소리를 냅니다");
    }
}

// 자식 클래스
class Dog extends Animal {
    @Override  // 오버라이딩 명시
    public void makeSound() {
        System.out.println("멍멍!");
    }
}

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Calculator {
    // 정수 덧셈
    public int add(int a, int b) {
        return a + b;
    }
    
    // 실수 덧셈
    public double add(double a, double b) {
        return a + b;
    }
    
    // 세 정수의 덧셈
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 배열의 덧셈
    public int add(int[] numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}