# 不需要聲明“我實現(xiàn)了Readable接口”
# 只要對象有 read() 方法，它就可以被當(dāng)作“可讀對象”
class FileReader:
    """文件讀取器"""
    def read(self):
        return "從文件讀取的數(shù)據(jù)"
class NetworkReader:
    """網(wǎng)絡(luò)數(shù)據(jù)讀取器""" 
    def read(self):
        return "從網(wǎng)絡(luò)讀取的數(shù)據(jù)"
class DatabaseReader:
    """數(shù)據(jù)庫讀取器"""
    def read(self):
        return "從數(shù)據(jù)庫讀取的數(shù)據(jù)"
# 使用這些對象時，不需要知道它們的具體類型
# 只需要知道它們都有 read() 方法
def process_reader(reader):
    """處理任何有read()方法的對象"""
    data = reader.read()  # 不關(guān)心reader的具體類型
    print(f"處理數(shù)據(jù): {data}")
# 所有對象都可以傳入，因為它們都有read()方法
process_reader(FileReader())
process_reader(NetworkReader())
process_reader(DatabaseReader())

# 定義兩個“接口”的預(yù)期行為
class JSONSerializable:
    """期望對象有 to_json() 方法"""
    pass  # 這只是文檔說明，沒有實際約束
class XMLSerializable:
    """期望對象有 to_xml() 方法"""
    pass
# 實現(xiàn)類
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def to_json(self):
        import json
        return json.dumps({"name": self.name, "age": self.age})
    def to_xml(self):
        return f"<user><name>{self.name}</name><age>{self.age}</age></user>"
# 使用函數(shù)
def export_json(obj):
    """導(dǎo)出為JSON - 要求obj有to_json()方法"""
    if hasattr(obj, 'to_json'):  # 運行時檢查
        return obj.to_json()
    raise TypeError("對象必須實現(xiàn) to_json() 方法")
def export_xml(obj):
    """導(dǎo)出為XML - 要求obj有to_xml()方法"""
    return obj.to_xml()  # 直接調(diào)用，如果失敗會拋出異常
# 測試
user = User("張三", 25)
print(export_json(user))  # 正常執(zhí)行
print(export_xml(user))   # 正常執(zhí)行

from abc import ABC, abstractmethod
from typing import List
# 顯式定義接口
class DataRepository(ABC):
    """數(shù)據(jù)倉庫接口"""
    @abstractmethod
    def save(self, data: dict) -> bool:
        """保存數(shù)據(jù)"""
        pass
    @abstractmethod
    def find_by_id(self, id: str) -> dict:
        """按ID查找"""
        pass
    @abstractmethod
    def find_all(self) -> List[dict]:
        """查找所有"""
        pass
# 實現(xiàn)類
class UserRepository(DataRepository):
    def __init__(self):
        self._users = []
    def save(self, data: dict) -> bool:
        self._users.append(data)
        return True
    def find_by_id(self, id: str) -> dict:
        for user in self._users:
            if user.get('id') == id:
                return user
        return {}
    def find_all(self) -> List[dict]:
        return self._users.copy()
# 測試
try:
    repo = UserRepository()  # 正常實例化
    repo.save({"id": "1", "name": "Alice"})
    print(repo.find_by_id("1"))
except TypeError as e:
    print(f"錯誤: {e}")
# 不能實例化抽象類
try:
    abstract_repo = DataRepository()  # 會報錯！
except TypeError as e:
    print(f"正確：不能實例化抽象類 - {e}")

from typing import Protocol, runtime_checkable
from dataclasses import dataclass
# 定義協(xié)議（接口）
@runtime_checkable
class Renderable(Protocol):
    """可渲染對象的協(xié)議"""
    def render(self) -> str:
        """渲染為字符串"""
        ...
    width: int  # 期望有width屬性
    height: int  # 期望有height屬性
# 實現(xiàn)類 - 不需要繼承或聲明
class Button:
    def __init__(self, text, width, height):
        self.text = text
        self.width = width
        self.height = height
    def render(self) -> str:
        return f"[{self.text}]"
class Image:
    def __init__(self, src, width, height):
        self.src = src
        self.width = width
        self.height = height
    def render(self) -> str:
        return f"<img src='{self.src}' width={self.width} height={self.height}>"
# 使用函數(shù)
def render_ui(component: Renderable) -> str:
    """渲染UI組件"""
    # 類型檢查器會驗證component是否符合Renderable協(xié)議
    return f"""
    組件: {component.render()}
    尺寸: {component.width}x{component.height}
    """
# 測試
button = Button("點擊我", 100, 40)
image = Image("logo.png", 200, 100)
print(render_ui(button))
print(render_ui(image))
# 運行時檢查
print(f"button符合Renderable協(xié)議嗎? {isinstance(button, Renderable)}")  # True
print(f"image符合Renderable協(xié)議嗎? {isinstance(image, Renderable)}")    # True
# 不符合協(xié)議的例子
class BadComponent:
    def render(self):
        return "bad"
bad = BadComponent()
print(f"bad符合Renderable協(xié)議嗎? {isinstance(bad, Renderable)}")  # False，缺少width/height屬性

// 定義接口
type Shape interface {
    Area() float64
    Perimeter() float64
}
// 實現(xiàn)接口
type Rectangle struct {
    Width, Height float64
}
// 必須顯式實現(xiàn)所有方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}
// 使用接口
func printArea(s Shape) {
    fmt.Println("面積:", s.Area())
}

# 不需要定義Shape接口
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    # 只要有area()和perimeter()方法
    # 就可以被當(dāng)作"形狀"
    def area(self):
        return self.width * self.height
    def perimeter(self):
        return 2 * (self.width + self.height)
# 使用函數(shù)
def print_area(shape):
    """期望shape有area()方法"""
    print(f"面積: {shape.area()}")
# 任何有area()方法的對象都可以傳入
print_area(Rectangle(10, 5))

from typing import Protocol, runtime_checkable
from dataclasses import dataclass
# 1. 使用Protocol定義接口
@runtime_checkable
class PaymentProcessor(Protocol):
    def charge(self, amount: float, currency: str) -> str:
        """處理支付，返回交易ID"""
        ...
    def refund(self, transaction_id: str) -> bool:
        """退款"""
        ...
# 2. 實現(xiàn)類
class StripeProcessor:
    def charge(self, amount: float, currency: str) -> str:
        # Stripe支付邏輯
        return f"stripe_tx_{hash((amount, currency))}"
    def refund(self, transaction_id: str) -> bool:
        # Stripe退款邏輯
        return True
class PayPalProcessor:
    def charge(self, amount: float, currency: str) -> str:
        # PayPal支付邏輯
        return f"paypal_tx_{hash((amount, currency))}"
    def refund(self, transaction_id: str) -> bool:
        # PayPal退款邏輯
        return True
# 3. 業(yè)務(wù)邏輯
class OrderService:
    def __init__(self, processor: PaymentProcessor):
        self.processor = processor
    def checkout(self, order_id: str, amount: float):
        # 類型檢查器會驗證processor是否符合PaymentProcessor
        tx_id = self.processor.charge(amount, "USD")
        print(f"訂單 {order_id} 支付成功，交易ID: {tx_id}")
# 4. 使用
service = OrderService(StripeProcessor())
service.checkout("order123", 99.99)
# 可以輕松切換實現(xiàn)
service = OrderService(PayPalProcessor())

# Go的：接口定義 → 強制實現(xiàn)
# type Storage interface { Save(data []byte) error }
# Python的等價做法：
# 1. Protocol（最接近Go）
class Storage(Protocol):
    def save(self, data: bytes) -> None: ...
# 2. ABC（強制實現(xiàn)）
class Storage(ABC):
    @abstractmethod
    def save(self, data: bytes) -> None: ...
# 3. 鴨子類型（最Pythonic）
# 不定義接口，直接寫函數(shù)：
def save_data(storage_obj, data: bytes):
    # 期望storage_obj有save()方法
    storage_obj.save(data)