Abstract Class

// Java - 결제 시스템 추상 클래스 예제
public abstract class PaymentProcessor {
    protected String merchantId;
    protected double amount;

    public PaymentProcessor(String merchantId, double amount) {
        this.merchantId = merchantId;
        this.amount = amount;
    }

    // 템플릿 메서드: 전체 결제 흐름 정의
    public final PaymentResult process() {
        validate();                    // 1. 검증 (공통)
        PaymentResult result = executePayment();  // 2. 실제 결제 (추상)
        saveTransaction(result);       // 3. 저장 (공통)
        return result;
    }

    // 공통 구현
    protected void validate() {
        if (amount <= 0) {
            throw new IllegalArgumentException("결제 금액은 0보다 커야 합니다");
        }
        System.out.println("검증 완료: " + amount + "원");
    }

    protected void saveTransaction(PaymentResult result) {
        System.out.println("거래 저장: " + result.getTransactionId());
    }

    // 추상 메서드: 자식 클래스에서 반드시 구현
    protected abstract PaymentResult executePayment();
    public abstract String getPaymentMethod();
}

// 구체 클래스: 카드 결제
public class CardPayment extends PaymentProcessor {
    private String cardNumber;

    public CardPayment(String merchantId, double amount, String cardNumber) {
        super(merchantId, amount);
        this.cardNumber = cardNumber;
    }

    @Override
    protected PaymentResult executePayment() {
        // 실제 카드 결제 로직
        String txId = "CARD-" + System.currentTimeMillis();
        System.out.println("카드 결제 처리: " + cardNumber.substring(0, 4) + "****");
        return new PaymentResult(txId, true, amount);
    }

    @Override
    public String getPaymentMethod() {
        return "CREDIT_CARD";
    }
}

// 사용 예시
PaymentProcessor payment = new CardPayment("SHOP001", 50000, "1234567890123456");
PaymentResult result = payment.process();
// 출력:
// 검증 완료: 50000.0원
// 카드 결제 처리: 1234****
// 거래 저장: CARD-1706123456789

# Python - abc 모듈을 활용한 추상 클래스
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import List
import time

@dataclass
class Document:
    title: str
    content: str

@dataclass
class ExportResult:
    filename: str
    size_bytes: int
    success: bool

# 추상 클래스 정의
class DocumentExporter(ABC):
    """문서 내보내기 추상 클래스"""

    def __init__(self, documents: List[Document]):
        self.documents = documents
        self._export_count = 0

    # 템플릿 메서드
    def export_all(self) -> List[ExportResult]:
        results = []
        for doc in self.documents:
            self._validate(doc)
            result = self._export_single(doc)  # 추상 메서드 호출
            self._log_export(result)
            results.append(result)
        return results

    # 공통 구현
    def _validate(self, doc: Document) -> None:
        if not doc.title or not doc.content:
            raise ValueError(f"문서 제목과 내용이 필요합니다: {doc.title}")

    def _log_export(self, result: ExportResult) -> None:
        self._export_count += 1
        status = "성공" if result.success else "실패"
        print(f"[{self._export_count}] {result.filename} - {status}")

    # 추상 메서드: 자식 클래스에서 구현 필수
    @abstractmethod
    def _export_single(self, doc: Document) -> ExportResult:
        """단일 문서를 특정 포맷으로 내보내기"""
        pass

    @property
    @abstractmethod
    def file_extension(self) -> str:
        """내보내기 파일 확장자"""
        pass

# 구체 클래스: PDF 내보내기
class PDFExporter(DocumentExporter):
    def _export_single(self, doc: Document) -> ExportResult:
        filename = f"{doc.title}.pdf"
        # 실제 PDF 생성 로직 (여기선 시뮬레이션)
        content_bytes = len(doc.content.encode('utf-8')) * 2  # PDF는 대략 2배
        return ExportResult(filename, content_bytes, True)

    @property
    def file_extension(self) -> str:
        return ".pdf"

# 구체 클래스: Markdown 내보내기
class MarkdownExporter(DocumentExporter):
    def _export_single(self, doc: Document) -> ExportResult:
        filename = f"{doc.title}.md"
        content = f"# {doc.title}\n\n{doc.content}"
        return ExportResult(filename, len(content.encode('utf-8')), True)

    @property
    def file_extension(self) -> str:
        return ".md"

# 사용 예시
docs = [
    Document("프로젝트 계획", "1분기 목표와 일정..."),
    Document("회의록", "참석자: 김팀장, 이과장...")
]

pdf_exporter = PDFExporter(docs)
results = pdf_exporter.export_all()
# 출력:
# [1] 프로젝트 계획.pdf - 성공
# [2] 회의록.md - 성공

// TypeScript - 추상 클래스와 제네릭 활용
interface CacheEntry {
    data: T;
    timestamp: number;
    ttl: number;
}

// 추상 캐시 저장소 클래스
abstract class CacheStore {
    protected entries: Map> = new Map();
    protected readonly defaultTTL: number;

    constructor(defaultTTLSeconds: number = 300) {
        this.defaultTTL = defaultTTLSeconds * 1000;
    }

    // 템플릿 메서드: 캐시 조회
    async get(key: string): Promise {
        const entry = this.entries.get(key);

        if (!entry) {
            // 캐시 미스: 원본 데이터 가져오기
            const data = await this.fetchFromSource(key);
            if (data !== null) {
                this.set(key, data);
            }
            return data;
        }

        // TTL 체크
        if (Date.now() > entry.timestamp + entry.ttl) {
            this.entries.delete(key);
            return this.get(key); // 재귀: 새로 가져오기
        }

        this.onCacheHit(key, entry);
        return entry.data;
    }

    set(key: string, data: T, ttlSeconds?: number): void {
        this.entries.set(key, {
            data,
            timestamp: Date.now(),
            ttl: (ttlSeconds ?? this.defaultTTL / 1000) * 1000
        });
        this.onCacheSet(key, data);
    }

    // 공통 구현
    protected onCacheHit(key: string, entry: CacheEntry): void {
        console.log(`[Cache HIT] ${key}`);
    }

    protected onCacheSet(key: string, data: T): void {
        console.log(`[Cache SET] ${key}`);
    }

    // 추상 메서드: 자식 클래스에서 구현
    protected abstract fetchFromSource(key: string): Promise;
    abstract clear(): void;
}

// 구체 클래스: 사용자 캐시
interface User {
    id: string;
    name: string;
    email: string;
}

class UserCache extends CacheStore {
    private apiEndpoint: string;

    constructor(apiEndpoint: string, ttlSeconds: number = 600) {
        super(ttlSeconds);
        this.apiEndpoint = apiEndpoint;
    }

    protected async fetchFromSource(userId: string): Promise {
        try {
            // 실제 API 호출 시뮬레이션
            console.log(`[API] Fetching user: ${userId}`);
            const response = await fetch(`${this.apiEndpoint}/users/${userId}`);
            if (!response.ok) return null;
            return await response.json();
        } catch {
            return null;
        }
    }

    clear(): void {
        const count = this.entries.size;
        this.entries.clear();
        console.log(`[Cache CLEAR] ${count}개 항목 삭제됨`);
    }
}

// 사용 예시
const userCache = new UserCache('https://api.example.com', 300);

// 첫 조회: API 호출 발생
const user1 = await userCache.get('user-123');
// 출력: [API] Fetching user: user-123
//       [Cache SET] user-123

// 두 번째 조회: 캐시에서 반환
const user2 = await userCache.get('user-123');
// 출력: [Cache HIT] user-123