다형성 (Polymorphism)

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

클래스별 VTable 구조:
┌─────────────┐
│  BaseClass  │
├─────────────┤
│ method1_ptr │ → BaseClass::method1()
│ method2_ptr │ → BaseClass::method2()
└─────────────┘

┌─────────────┐
│ DerivedClass│
├─────────────┤
│ method1_ptr │ → DerivedClass::method1() (오버라이드)
│ method2_ptr │ → BaseClass::method2() (상속)
│ method3_ptr │ → DerivedClass::method3() (새 메서드)
└─────────────┘

 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:
    def add(self, *args):
        if len(args) == 2:
            if all(isinstance(arg, int) for arg in args):
                return self._add_integers(args[0], args[1])
            elif all(isinstance(arg, str) for arg in args):
                return self._add_strings(args[0], args[1])
        elif len(args) == 3:
            return self._add_three_numbers(*args)
    
    def _add_integers(self, a, b):
        return a + b
    
    def _add_strings(self, a, b):
        return a + " " + b
    
    def _add_three_numbers(self, a, b, c):
        return a + b + c

# 사용 예시
calc = Calculator()
print(calc.add(5, 3))           # 8 (정수 덧셈)
print(calc.add("Hello", "World")) # "Hello World" (문자열 연결)
print(calc.add(1, 2, 3))        # 6 (세 수의 합)

 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

// 제네릭 함수 (타입스크립트 스타일로 설명)
class GenericContainer {
    constructor() {
        this.items = [];
    }
    
    add(item) {
        this.items.push(item);
    }
    
    get(index) {
        return this.items[index];
    }
    
    getAll() {
        return […this.items];
    }
    
    // 타입에 관계없이 동작하는 메서드
    findFirst(predicate) {
        return this.items.find(predicate);
    }
    
    map(transformer) {
        return this.items.map(transformer);
    }
}

// 다양한 타입으로 사용
const stringContainer = new GenericContainer();
stringContainer.add("Hello");
stringContainer.add("World");

const numberContainer = new GenericContainer();
numberContainer.add(1);
numberContainer.add(2);
numberContainer.add(3);

// 동일한 인터페이스로 다른 타입 처리
console.log(stringContainer.findFirst(s => s.length > 4)); // "Hello"
console.log(numberContainer.findFirst(n => n > 1)); // 2

 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

from abc import ABC, abstractmethod

# 추상 기본 클래스
class Shape(ABC):
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def calculate_area(self):
        pass
    
    @abstractmethod
    def calculate_perimeter(self):
        pass
    
    def describe(self):
        return f"{self.name}: Area={self.calculate_area():f}, Perimeter={self.calculate_perimeter():f}"

# 구체적인 구현 클래스들
class Rectangle(Shape):
    def __init__(self, width, height):
        super().__init__("Rectangle")
        self.width = width
        self.height = height
    
    def calculate_area(self):
        return self.width * self.height
    
    def calculate_perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        super().__init__("Circle")
        self.radius = radius
    
    def calculate_area(self):
        return 3.14159 * self.radius ** 2
    
    def calculate_perimeter(self):
        return 2 * 3.14159 * self.radius

class Triangle(Shape):
    def __init__(self, a, b, c):
        super().__init__("Triangle")
        self.a = a
        self.b = b
        self.c = c
    
    def calculate_area(self):
        # 헤론의 공식 사용
        s = (self.a + self.b + self.c) / 2
        return (s * (s - self.a) * (s - self.b) * (s - self.c)) ** 0.5
    
    def calculate_perimeter(self):
        return self.a + self.b + self.c

# 다형성 활용
def process_shapes(shapes):
    total_area = 0
    total_perimeter = 0
    
    for shape in shapes:
        # 런타임에 적절한 메서드가 호출됨
        area = shape.calculate_area()
        perimeter = shape.calculate_perimeter()
        
        total_area += area
        total_perimeter += perimeter
        
        print(shape.describe())
    
    print(f"\nTotal Area: {total_area:f}")
    print(f"Total Perimeter: {total_perimeter:f}")

# 사용 예시
shapes = [
    Rectangle(5, 3),
    Circle(4),
    Triangle(3, 4, 5)
]

process_shapes(shapes)

 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

class Temperature {
    constructor(value, unit = 'C') {
        this.value = value;
        this.unit = unit;
    }
    
    // 숫자로 변환 (암시적 변환)
    valueOf() {
        // 섭씨로 정규화하여 반환
        if (this.unit === 'F') {
            return (this.value - 32) * 5/9;
        } else if (this.unit === 'K') {
            return this.value - 273.15;
        }
        return this.value;
    }
    
    // 문자열로 변환
    toString() {
        return `${this.value}°${this.unit}`;
    }
    
    // 명시적 변환 메서드
    toCelsius() {
        return new Temperature(this.valueOf(), 'C');
    }
    
    toFahrenheit() {
        const celsius = this.valueOf();
        return new Temperature(celsius * 9/5 + 32, 'F');
    }
    
    toKelvin() {
        const celsius = this.valueOf();
        return new Temperature(celsius + 273.15, 'K');
    }
}

// 강제 다형성 예시
const temp1 = new Temperature(25, 'C');
const temp2 = new Temperature(77, 'F');
const temp3 = new Temperature(298.15, 'K');

// 암시적 변환을 통한 연산
console.log(temp1 + temp2); // 50 (25°C + 25°C, F에서 C로 자동 변환)
console.log(temp1 < temp3);  // false (25°C < 25°C, K에서 C로 자동 변환)

// 명시적 변환
console.log(temp1.toFahrenheit().toString()); // "77°F"
console.log(temp2.toCelsius().toString());    // "25°C"

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

# 부모 클래스
class Animal:
    def speak(self):
        return "Animal sound"

# 자식 클래스
class Dog(Animal):
    def speak(self):
        return "Bark"

class Cat(Animal):
    def speak(self):
        return "Meow"

# 함수에서 다형성 사용
def make_animal_speak(animal: Animal):
    print(animal.speak())

# 테스트
make_animal_speak(Dog())  # 출력: Bark
make_animal_speak(Cat())  # 출력: Meow

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

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement this method.")

class Dog(Animal):
    def speak(self):
        return "멍멍!"

class Cat(Animal):
    def speak(self):
        return "야옹!"

def animal_sound(animal: Animal):
    print(animal.speak())

dog = Dog()
cat = Cat()
animal_sound(dog)  # 멍멍!
animal_sound(cat)  # 야옹!

1
2
3
4
5

[Client Request] 
    → [AuthContext.authenticate(request)]
        → 전략에 따라 OAuth/JWT/BasicAuth 중 선택
            → 각 전략의 authenticate() 메서드 실행
                → 사용자 식별 및 인증 성공 여부 판단

 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

from abc import ABC, abstractmethod

# 공통 인터페이스
class AuthStrategy(ABC):
    @abstractmethod
    def authenticate(self, request):
        pass

# BasicAuth 구현
class BasicAuthStrategy(AuthStrategy):
    def authenticate(self, request):
        credentials = request.get("Authorization")
        # Basic 인증 로직…
        return credentials == "Basic YWRtaW46cGFzc3dvcmQ="

# JWT 구현
class JWTStrategy(AuthStrategy):
    def authenticate(self, request):
        token = request.get("Authorization")
        # JWT 디코딩 및 검증 로직…
        return token.startswith("Bearer ")

# OAuth 구현
class OAuthStrategy(AuthStrategy):
    def authenticate(self, request):
        token = request.get("access_token")
        # 외부 OAuth 서버 검증…
        return token == "valid-oauth-token"

# Context
class AuthContext:
    def __init__(self, strategy: AuthStrategy):
        self.strategy = strategy

    def authenticate(self, request):
        return self.strategy.authenticate(request)

# 테스트
request = {"Authorization": "Basic YWRtaW46cGFzc3dvcmQ="}
context = AuthContext(BasicAuthStrategy())
print(context.authenticate(request))  # True

  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
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313

from abc import ABC, abstractmethod
from enum import Enum
from typing import Dict, Any, Optional
import logging

# 결제 상태 열거형
class PaymentStatus(Enum):
    PENDING = "pending"
    PROCESSING = "processing"
    COMPLETED = "completed"
    FAILED = "failed"
    REFUNDED = "refunded"

# 결제 결과 데이터 클래스
class PaymentResult:
    def __init__(self, success: bool, transaction_id: str, 
                 status: PaymentStatus, message: str, amount: float):
        self.success = success
        self.transaction_id = transaction_id
        self.status = status
        self.message = message
        self.amount = amount
        self.timestamp = None  # 실제로는 datetime.now()

# 추상 결제 프로세서 (다형성의 기반)
class PaymentProcessor(ABC):
    """결제 처리를 위한 추상 기본 클래스"""
    
    def __init__(self, name: str):
        self.name = name
        self.logger = logging.getLogger(f"payment.{name}")
    
    @abstractmethod
    def process_payment(self, amount: float, payment_data: Dict[str, Any]) -> PaymentResult:
        """결제 처리 추상 메서드"""
        pass
    
    @abstractmethod
    def refund_payment(self, transaction_id: str, amount: float) -> PaymentResult:
        """환불 처리 추상 메서드"""
        pass
    
    @abstractmethod
    def validate_payment_data(self, payment_data: Dict[str, Any]) -> bool:
        """결제 데이터 검증 추상 메서드"""
        pass
    
    # 공통 기능 (템플릿 메서드 패턴 적용)
    def execute_payment(self, amount: float, payment_data: Dict[str, Any]) -> PaymentResult:
        """결제 실행 템플릿 메서드"""
        self.logger.info(f"Starting payment process for amount: {amount}")
        
        # 1. 데이터 검증
        if not self.validate_payment_data(payment_data):
            return PaymentResult(
                success=False,
                transaction_id="",
                status=PaymentStatus.FAILED,
                message="Invalid payment data",
                amount=amount
            )
        
        # 2. 결제 처리 (다형성 호출)
        try:
            result = self.process_payment(amount, payment_data)
            self.logger.info(f"Payment processed: {result.transaction_id}")
            return result
        except Exception as e:
            self.logger.error(f"Payment failed: {str(e)}")
            return PaymentResult(
                success=False,
                transaction_id="",
                status=PaymentStatus.FAILED,
                message=f"Payment processing error: {str(e)}",
                amount=amount
            )

# 신용카드 결제 프로세서 (구체적 구현)
class CreditCardProcessor(PaymentProcessor):
    def __init__(self):
        super().__init__("CreditCard")
        self.transaction_counter = 0
    
    def validate_payment_data(self, payment_data: Dict[str, Any]) -> bool:
        required_fields = ['card_number', 'expiry_date', 'cvv', 'holder_name']
        return all(field in payment_data for field in required_fields)
    
    def process_payment(self, amount: float, payment_data: Dict[str, Any]) -> PaymentResult:
        # 신용카드 특화 처리 로직
        card_number = payment_data['card_number']
        
        # 카드 번호 마스킹 (보안)
        masked_card = f"****-****-****-{card_number[-4:]}"
        
        # 실제로는 외부 결제 게이트웨이 API 호출
        self.transaction_counter += 1
        transaction_id = f"CC_{self.transaction_counter:06d}"
        
        # 시뮬레이션: 가끔 실패하는 경우
        import random
        if random.random() < 0.1:  # 10% 실패율
            return PaymentResult(
                success=False,
                transaction_id=transaction_id,
                status=PaymentStatus.FAILED,
                message="Card declined by bank",
                amount=amount
            )
        
        return PaymentResult(
            success=True,
            transaction_id=transaction_id,
            status=PaymentStatus.COMPLETED,
            message=f"Payment successful using card {masked_card}",
            amount=amount
        )
    
    def refund_payment(self, transaction_id: str, amount: float) -> PaymentResult:
        return PaymentResult(
            success=True,
            transaction_id=f"RF_{transaction_id}",
            status=PaymentStatus.REFUNDED,
            message=f"Refund processed for {transaction_id}",
            amount=amount
        )

# PayPal 결제 프로세서 (구체적 구현)
class PayPalProcessor(PaymentProcessor):
    def __init__(self):
        super().__init__("PayPal")
        self.transaction_counter = 0
    
    def validate_payment_data(self, payment_data: Dict[str, Any]) -> bool:
        required_fields = ['email', 'password']
        return all(field in payment_data for field in required_fields)
    
    def process_payment(self, amount: float, payment_data: Dict[str, Any]) -> PaymentResult:
        # PayPal 특화 처리 로직
        email = payment_data['email']
        
        self.transaction_counter += 1
        transaction_id = f"PP_{self.transaction_counter:06d}"
        
        # PayPal API 시뮬레이션
        return PaymentResult(
            success=True,
            transaction_id=transaction_id,
            status=PaymentStatus.COMPLETED,
            message=f"PayPal payment successful for {email}",
            amount=amount
        )
    
    def refund_payment(self, transaction_id: str, amount: float) -> PaymentResult:
        return PaymentResult(
            success=True,
            transaction_id=f"RF_{transaction_id}",
            status=PaymentStatus.REFUNDED,
            message=f"PayPal refund processed for {transaction_id}",
            amount=amount
        )

# 암호화폐 결제 프로세서 (구체적 구현)
class CryptocurrencyProcessor(PaymentProcessor):
    def __init__(self):
        super().__init__("Cryptocurrency")
        self.transaction_counter = 0
    
    def validate_payment_data(self, payment_data: Dict[str, Any]) -> bool:
        required_fields = ['wallet_address', 'currency_type', 'private_key']
        return all(field in payment_data for field in required_fields)
    
    def process_payment(self, amount: float, payment_data: Dict[str, Any]) -> PaymentResult:
        # 암호화폐 특화 처리 로직
        currency = payment_data['currency_type']
        wallet = payment_data['wallet_address']
        
        self.transaction_counter += 1
        transaction_id = f"CRYPTO_{self.transaction_counter:06d}"
        
        # 블록체인 처리 시뮬레이션 (시간이 더 오래 걸림)
        return PaymentResult(
            success=True,
            transaction_id=transaction_id,
            status=PaymentStatus.PROCESSING,  # 블록체인 확인 대기
            message=f"{currency} payment initiated to {wallet[:10]}…",
            amount=amount
        )
    
    def refund_payment(self, transaction_id: str, amount: float) -> PaymentResult:
        return PaymentResult(
            success=True,
            transaction_id=f"RF_{transaction_id}",
            status=PaymentStatus.PROCESSING,  # 블록체인 처리 시간 필요
            message=f"Cryptocurrency refund initiated for {transaction_id}",
            amount=amount
        )

# 결제 관리자 (다형성 활용의 핵심)
class PaymentManager:
    """다형성을 활용한 결제 관리 클래스"""
    
    def __init__(self):
        self.processors: Dict[str, PaymentProcessor] = {}
        self.payment_history = []
    
    def register_processor(self, payment_type: str, processor: PaymentProcessor):
        """결제 프로세서 등록 (새로운 결제 방식 추가 용이)"""
        self.processors[payment_type] = processor
    
    def process_payment(self, payment_type: str, amount: float, 
                       payment_data: Dict[str, Any]) -> PaymentResult:
        """다형성을 통한 결제 처리"""
        if payment_type not in self.processors:
            return PaymentResult(
                success=False,
                transaction_id="",
                status=PaymentStatus.FAILED,
                message=f"Unsupported payment type: {payment_type}",
                amount=amount
            )
        
        # 다형성 호출: 런타임에 적절한 프로세서의 메서드가 호출됨
        processor = self.processors[payment_type]
        result = processor.execute_payment(amount, payment_data)
        
        # 결제 이력 저장
        self.payment_history.append({
            'payment_type': payment_type,
            'result': result,
            'processor_name': processor.name
        })
        
        return result
    
    def process_refund(self, payment_type: str, transaction_id: str, 
                      amount: float) -> PaymentResult:
        """다형성을 통한 환불 처리"""
        if payment_type not in self.processors:
            return PaymentResult(
                success=False,
                transaction_id="",
                status=PaymentStatus.FAILED,
                message=f"Unsupported payment type: {payment_type}",
                amount=amount
            )
        
        processor = self.processors[payment_type]
        return processor.refund_payment(transaction_id, amount)
    
    def get_supported_payment_types(self):
        """지원되는 결제 방식 목록 반환"""
        return list(self.processors.keys())

# 사용 예시 및 테스트
def main():
    # 결제 관리자 초기화
    payment_manager = PaymentManager()
    
    # 다양한 결제 프로세서 등록 (다형성 활용)
    payment_manager.register_processor("credit_card", CreditCardProcessor())
    payment_manager.register_processor("paypal", PayPalProcessor())
    payment_manager.register_processor("crypto", CryptocurrencyProcessor())
    
    # 다양한 결제 방식으로 결제 처리
    payments = [
        {
            "type": "credit_card",
            "amount": 99.99,
            "data": {
                "card_number": "1234567890123456",
                "expiry_date": "12/25",
                "cvv": "123",
                "holder_name": "John Doe"
            }
        },
        {
            "type": "paypal",
            "amount": 149.50,
            "data": {
                "email": "user@example.com",
                "password": "password123"
            }
        },
        {
            "type": "crypto",
            "amount": 0.005,
            "data": {
                "wallet_address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
                "currency_type": "BTC",
                "private_key": "private_key_hash"
            }
        }
    ]
    
    # 다형성을 통한 일괄 처리
    for payment in payments:
        print(f"\nProcessing {payment['type']} payment…")
        result = payment_manager.process_payment(
            payment['type'], 
            payment['amount'], 
            payment['data']
        )
        
        print(f"Success: {result.success}")
        print(f"Transaction ID: {result.transaction_id}")
        print(f"Status: {result.status.value}")
        print(f"Message: {result.message}")
    
    # 지원되는 결제 방식 출력
    print(f"\nSupported payment types: {payment_manager.get_supported_payment_types()}")

if __name__ == "__main__":
    main()

 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

# 문제 상황
class A:
    def method(self):
        print("A")

class B(A):
    def method(self):
        print("B")

class C(A):
    def method(self):
        print("C")

class D(B, C):  # 다이아몬드 문제 발생
    pass

# 해결책 1: 명시적 메서드 정의
class D(B, C):
    def method(self):
        B.method(self)  # 또는 C.method(self)

# 해결책 2: 조합 패턴 사용
class D:
    def __init__(self):
        self.b_component = B()
        self.c_component = C()
    
    def method(self):
        # 필요에 따라 선택적 호출
        self.b_component.method()

 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

# 문제를 방지하는 설계
from abc import ABC, abstractmethod

class StableInterface(ABC):
    """안정적인 인터페이스 정의"""
    
    @abstractmethod
    def core_operation(self):
        pass
    
    # 템플릿 메서드로 안정성 보장
    def process(self):
        self.pre_process()
        result = self.core_operation()
        self.post_process()
        return result
    
    def pre_process(self):
        """기본 전처리 (오버라이드 가능)"""
        pass
    
    def post_process(self):
        """기본 후처리 (오버라이드 가능)"""
        pass

class ConcreteImplementation(StableInterface):
    def core_operation(self):
        return "Implementation specific logic"

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

from typing import TypeVar, Generic, Type, get_type_hints
import inspect

T = TypeVar('T')

class TypePreservingContainer(Generic[T]):
    def __init__(self, item_type: Type[T]):
        self._item_type = item_type
        self._items = []
    
    def add(self, item: T):
        if not isinstance(item, self._item_type):
            raise TypeError(f"Expected {self._item_type}, got {type(item)}")
        self._items.append(item)
    
    def get_type(self) -> Type[T]:
        return self._item_type

# 사용 예시
string_container = TypePreservingContainer(str)
string_container.add("Hello")  # OK
# string_container.add(123)    # TypeError 발생

 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

# 성능 최적화 예시
class OptimizedProcessor:
    def __init__(self):
        # 자주 사용되는 구현체들을 캐시
        self._processor_cache = {}
        self._default_processor = None
    
    def get_processor(self, processor_type: str):
        # 캐시된 인스턴스 반환으로 객체 생성 비용 절약
        if processor_type not in self._processor_cache:
            self._processor_cache[processor_type] = self._create_processor(processor_type)
        return self._processor_cache[processor_type]
    
    def _create_processor(self, processor_type: str):
        # 팩터리 메서드로 구현체 생성
        if processor_type == "fast":
            return FastProcessor()
        elif processor_type == "secure":
            return SecureProcessor()
        else:
            return self._default_processor or DefaultProcessor()

# 인라인 최적화 힌트 (언어별로 다름)
class PerformanceCriticalClass:
    def __hot_path_method(self):
        # 성능이 중요한 메서드는 가상 함수 호출 최소화
        pass