OOP

"""
OOP 핵심 개념 예제 - Python
캡슐화, 상속, 다형성, 추상화 + SOLID 원칙 적용
"""

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import List, Protocol


# ===== 추상화 (Abstraction) =====
class PaymentProcessor(ABC):
    """결제 처리기 추상 클래스 - ISP 원칙 적용"""

    @abstractmethod
    def process_payment(self, amount: float) -> bool:
        """결제 처리 (구현 필수)"""
        pass

    @abstractmethod
    def refund(self, transaction_id: str) -> bool:
        """환불 처리"""
        pass


# ===== 캡슐화 (Encapsulation) =====
@dataclass
class Money:
    """금액을 캡슐화한 값 객체"""
    _amount: float
    _currency: str = "KRW"

    @property
    def amount(self) -> float:
        return self._amount

    def add(self, other: 'Money') -> 'Money':
        if self._currency != other._currency:
            raise ValueError("통화가 다릅니다")
        return Money(self._amount + other._amount, self._currency)

    def __str__(self) -> str:
        return f"{self._amount:,.0f} {self._currency}"


# ===== 상속 (Inheritance) + 다형성 (Polymorphism) =====
class CreditCardProcessor(PaymentProcessor):
    """신용카드 결제 - LSP 원칙 준수"""

    def __init__(self, api_key: str):
        self._api_key = api_key
        self._transactions: dict = {}

    def process_payment(self, amount: float) -> bool:
        # 실제로는 PG사 API 호출
        transaction_id = f"CC_{id(self)}"
        self._transactions[transaction_id] = amount
        print(f"[신용카드] {amount:,.0f}원 결제 완료")
        return True

    def refund(self, transaction_id: str) -> bool:
        if transaction_id in self._transactions:
            print(f"[신용카드] {transaction_id} 환불 완료")
            return True
        return False


class KakaoPayProcessor(PaymentProcessor):
    """카카오페이 결제 - 다형성 활용"""

    def process_payment(self, amount: float) -> bool:
        print(f"[카카오페이] {amount:,.0f}원 결제 완료")
        return True

    def refund(self, transaction_id: str) -> bool:
        print(f"[카카오페이] {transaction_id} 환불 완료")
        return True


# ===== DIP 원칙 - 추상화에 의존 =====
class OrderService:
    """주문 서비스 - DIP 원칙 적용 (구체 클래스가 아닌 추상화에 의존)"""

    def __init__(self, payment_processor: PaymentProcessor):
        # 구체 클래스가 아닌 추상 클래스에 의존
        self._processor = payment_processor

    def checkout(self, items: List[dict]) -> bool:
        total = sum(item['price'] * item['quantity'] for item in items)
        print(f"\n총 금액: {total:,.0f}원")
        return self._processor.process_payment(total)


# ===== SRP 원칙 - 단일 책임 =====
class OrderValidator:
    """주문 검증만 담당 - SRP 원칙"""

    @staticmethod
    def validate(items: List[dict]) -> bool:
        if not items:
            raise ValueError("주문 항목이 비어있습니다")
        for item in items:
            if item.get('quantity', 0) <= 0:
                raise ValueError("수량은 1 이상이어야 합니다")
        return True


# ===== 실행 예시 =====
if __name__ == "__main__":
    # 다형성 활용: 동일 인터페이스로 다양한 결제 수단 처리
    items = [
        {"name": "AI 강의", "price": 50000, "quantity": 1},
        {"name": "교재", "price": 30000, "quantity": 2}
    ]

    # 신용카드로 결제
    cc_processor = CreditCardProcessor(api_key="test_key")
    order_service = OrderService(cc_processor)
    order_service.checkout(items)

    # 카카오페이로 결제 (동일 코드, 다른 결제 수단)
    kakao_processor = KakaoPayProcessor()
    order_service = OrderService(kakao_processor)
    order_service.checkout(items)

/**
 * OOP 핵심 개념 예제 - Java
 * 인터페이스, 상속, SOLID 원칙 적용
 */

import java.util.ArrayList;
import java.util.List;

// ===== 추상화 + ISP 원칙 =====
interface PaymentProcessor {
    boolean processPayment(double amount);
    boolean refund(String transactionId);
}

interface Notifiable {
    void sendNotification(String message);
}

// ===== 캡슐화 =====
class Money {
    private final double amount;
    private final String currency;

    public Money(double amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    // getter만 제공 - 불변 객체
    public double getAmount() {
        return amount;
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("통화가 다릅니다");
        }
        return new Money(this.amount + other.amount, this.currency);
    }

    @Override
    public String toString() {
        return String.format("%,.0f %s", amount, currency);
    }
}

// ===== 상속 + 다형성 =====
class CreditCardProcessor implements PaymentProcessor {
    private final String apiKey;

    public CreditCardProcessor(String apiKey) {
        this.apiKey = apiKey;
    }

    @Override
    public boolean processPayment(double amount) {
        System.out.printf("[신용카드] %,.0f원 결제 완료%n", amount);
        return true;
    }

    @Override
    public boolean refund(String transactionId) {
        System.out.printf("[신용카드] %s 환불 완료%n", transactionId);
        return true;
    }
}

class KakaoPayProcessor implements PaymentProcessor, Notifiable {
    @Override
    public boolean processPayment(double amount) {
        System.out.printf("[카카오페이] %,.0f원 결제 완료%n", amount);
        sendNotification("결제가 완료되었습니다");
        return true;
    }

    @Override
    public boolean refund(String transactionId) {
        System.out.printf("[카카오페이] %s 환불 완료%n", transactionId);
        return true;
    }

    @Override
    public void sendNotification(String message) {
        System.out.println("[알림] " + message);
    }
}

// ===== DIP 원칙 - 생성자 주입 =====
class OrderService {
    private final PaymentProcessor processor;

    // 추상화(인터페이스)에 의존
    public OrderService(PaymentProcessor processor) {
        this.processor = processor;
    }

    public boolean checkout(List items) {
        double total = items.stream()
            .mapToDouble(item -> item.getPrice() * item.getQuantity())
            .sum();

        System.out.printf("%n총 금액: %,.0f원%n", total);
        return processor.processPayment(total);
    }
}

// ===== SRP 원칙 =====
class OrderItem {
    private final String name;
    private final double price;
    private final int quantity;

    public OrderItem(String name, double price, int quantity) {
        this.name = name;
        this.price = price;
        this.quantity = quantity;
    }

    public double getPrice() { return price; }
    public int getQuantity() { return quantity; }
}

// ===== 메인 클래스 =====
public class OOPExample {
    public static void main(String[] args) {
        List items = new ArrayList<>();
        items.add(new OrderItem("AI 강의", 50000, 1));
        items.add(new OrderItem("교재", 30000, 2));

        // 다형성: 동일 타입으로 다양한 구현체 사용
        PaymentProcessor ccProcessor = new CreditCardProcessor("test_key");
        OrderService orderService = new OrderService(ccProcessor);
        orderService.checkout(items);

        // 결제 수단만 교체 - OCP 원칙
        PaymentProcessor kakaoProcessor = new KakaoPayProcessor();
        orderService = new OrderService(kakaoProcessor);
        orderService.checkout(items);
    }
}