class ParentClass:
    def __init__(self, value):
        self.value = value

    def display_value(self):
        print(f"Value in parent class: {self.value}")

class ChildClass(ParentClass):
    def __init__(self, value, extra_value):
        super().__init__(value)
        self.extra_value = extra_value

    def display_extra_value(self):
        print(f"Extra Value in child class: {self.extra_value}")

child_instance = ChildClass(10, 20)
child_instance.display_value()       # 調(diào)用了父類的方法
child_instance.display_extra_value() # 調(diào)用了子類自己的方法

# 父類
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound."

# 子類    繼承于父類animal
class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"
        
# 子類  重寫父類的speak方法
class Bird(Animal):
    def speak(self):
        return f"{self.name} says chirp!"

# 創(chuàng)建子類對象
my_cat = Cat("Whiskers")
print(my_cat.speak())  # 輸出: Whiskers says meow!

my_bird = Bird("Tweety")
print(my_bird.speak())  # 輸出: Tweety says chirp!

class A:
    def method(self):
        return "A"

class B:
    def method(self):
        return "B"

class C(A, B):
    pass

my_object = C()
print(my_object.method())  # 輸出: A（遵循方法解析順序 MRO）

class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method.")
 
    @classmethod
    def class_method(cls):
        print("This is a class method.")
 
MyClass.static_method()  # 輸出: This is a static method.
MyClass.class_method()   # 輸出: This is a class method.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 重寫字符串表示
    def __str__(self):
        return f"Point({self.x}, {self.y})"

    # 重寫加法操作
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

# 使用
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)          # 輸出: Point(1, 2)
print(p1 + p2)     # 輸出: Point(4, 6)

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner                # 公有屬性
        self._account_number = "A12345" # 受保護屬性
        self.__balance = balance         # 私有屬性
    
    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self.__balance += amount
            return f"Deposited {amount}. New balance: {self.__balance}"
        else:
            return "Invalid deposit amount."
    
    def withdraw(self, amount):
        """取款"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return f"Withdrew {amount}. Remaining balance: {self.__balance}"
        else:
            return "Insufficient funds or invalid withdrawal amount."
    
    def get_balance(self):
        """獲取余額"""
        return f"Current balance: {self.__balance}"

# 測試BankAccount類的功能
account = BankAccount("Alice", 100)

# 正常操作
print(account.deposit(50))          # 輸出: Deposited 50. New balance: 150
print(account.withdraw(70))         # 輸出: Withdrew 70. Remaining balance: 80
print(account.get_balance())        # 輸出: Current balance: 80

# 嘗試非法訪問私有屬性
try:
    print(account.__balance)       # 這里會拋出 AttributeError 錯誤
except AttributeError as e:
    print(e)                       # 輸出: 'BankAccount' object has no attribute '__balance'

# 使用名稱改寫的機制間接訪問私有屬性
print(account._BankAccount__balance)  # 輸出: 80 【不推薦】

class Logger:
    _instance = None                 # 靜態(tài)變量用于存儲唯一實例
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:        # 如果尚未創(chuàng)建過實例，則初始化一個新的實例
            cls._instance = super(Logger, cls).__new__(cls)
        return cls._instance         # 返回已存在的實例
    
    def log(self, message):
        print(f"[LOG]: {message}")

# 測試Logger類的行為
logger1 = Logger()
logger2 = Logger()

assert logger1 is logger2           # True，表明兩個引用指向同一個對象
logger1.log("System started.")      # 輸出: [LOG]: System started.
logger2.log("User logged in.")     # 輸出: [LOG]: User logged in.