Object-Oriented Programming (Intro)面向对象编程（入门）

Procedural approach (messy, hard to scale).过程式方式（混乱，难以扩展）。

dog1_name = "Fido"
dog1_age  = 3
dog2_name = "Bella"
dog2_age  = 5
# Adding dog3 means adding two more variables...

OOP approach (clean, scalable).面向对象方式（简洁，可扩展）。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

fido  = Dog("Fido",  3)
bella = Dog("Bella", 5)
print(fido.name, fido.age)   # Fido 3
print(bella.name, bella.age) # Bella 5

The Dog class is defined once. fido and bella are separate instances, each with their own data. Adding a third dog is one line: rex = Dog("Rex", 2).只需一行就能添加第三条狗：rex = Dog("Rex", 2)。

class Student:
    def __init__(self, name, grade):
        self.name  = name
        self.grade = grade

    def is_passing(self):
        return self.grade >= 50

# Create two instances
s1 = Student("Alice", 78)
s2 = Student("Bob",   42)

print(s1.name, s1.is_passing())   # Alice True
print(s2.name, s2.is_passing())   # Bob   False

Key points: (1) self.name and self.grade are stored per-object — s1 and s2 each have their own copies. (2) is_passing() uses self.grade to access the current object's data. (3) You call the method as s1.is_passing(), not Student.is_passing(s1) (Python does that internally).要点：(1) self.name 和 self.grade 按对象存储——s1 和 s2 各有自己的副本。(2) is_passing() 用 self.grade 访问当前对象的数据。(3) 调用方式为 s1.is_passing()，而非 Student.is_passing(s1)（Python 在内部完成这一步）。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner   = owner
        self.balance = balance

acc1 = BankAccount("Alice", 1000)
acc2 = BankAccount("Bob",    500)

acc1.balance += 200          # deposit $200 into Alice's account
print(acc1.owner, acc1.balance)  # Alice 1200
print(acc2.owner, acc2.balance)  # Bob    500  (unchanged)

Notice: acc1.balance += 200 modifies only Alice's account object. Bob's account is completely separate in memory. This isolation is impossible with procedural global variables.注意：acc1.balance += 200 只修改 Alice 的账户对象。Bob 的账户在内存中完全独立。这种隔离是过程式全局变量无法实现的。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner   = owner
        self.balance = balance

    def deposit(self, amount):       # mutator — changes state
        self.balance += amount

    def withdraw(self, amount):      # mutator — changes state
        if amount <= self.balance:
            self.balance -= amount
        else:
            print("Insufficient funds")

    def get_balance(self):           # accessor — returns data
        return self.balance

acc = BankAccount("Alice", 1000)
acc.deposit(200)
acc.withdraw(50)
print(acc.get_balance())   # 1150

The withdraw method has a guard: if amount exceeds balance, it prints a message instead of creating a negative balance. This is encapsulation in action — the object protects its own data integrity.withdraw 方法有一个保护检查：如果取款额超过余额，则打印消息而不产生负余额。这是封装（encapsulation，封装）的实际体现——对象保护自身数据的完整性。

class Rectangle:
    def __init__(self, width, height):
        self.width  = width
        self.height = height

    def area(self):
        return self.width * self.height

    def is_square(self):
        return self.width == self.height

r1 = Rectangle(5, 3)
r2 = Rectangle(4, 4)

print(r1.area())       # 15
print(r1.is_square())  # False
print(r2.area())       # 16
print(r2.is_square())  # True

Trace through r1 = Rectangle(5, 3): Python calls Rectangle.__init__(r1, 5, 3). Inside: self.width = 5 and self.height = 3. After __init__ returns, r1 is a fully initialised object with both attributes set.追踪 r1 = Rectangle(5, 3)：Python 调用 Rectangle.__init__(r1, 5, 3)。内部：self.width = 5 且 self.height = 3。__init__ 返回后，r1 是已完全初始化的对象，两个属性均已设置。

class Student:
    def __init__(self, name, grade):
        self.name  = name
        self.grade = grade

    def is_passing(self):
        return self.grade >= 50

# Create objects and store in a list
roster = [
    Student("Alice",  88),
    Student("Bob",    72),
    Student("Carol",  95),
    Student("David",  61),
    Student("Emma",   45),
]

# Compute class average
total = sum(s.grade for s in roster)
avg   = total / len(roster)
print(f"Class average: {avg:.1f}")   # 72.2

# Find top scorer
top = max(roster, key=lambda s: s.grade)
print(f"Top scorer: {top.name} ({top.grade})")  # Carol (95)

# List failing students
failing = [s.name for s in roster if not s.is_passing()]
print("Failing:", failing)           # ['Emma']

Key pattern: iterate over a list of objects with a for loop and call methods or read attributes on each one. This is OOP's main productivity advantage over procedural code for managing collections of related data.关键模式：用 for 循环遍历对象列表，对每个对象调用方法或读取属性。对于管理相关数据集合，这是 OOP 相较过程式代码的主要生产力优势。

Encapsulation with private attribute.用私有属性实现封装。

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner    = owner
        self._balance = balance      # private by convention

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount

    def get_balance(self):           # accessor — safe read
        return self._balance

Inheritance — SavingsAccount extends BankAccount.继承——SavingsAccount 继承 BankAccount。

class SavingsAccount(BankAccount):   # inherits BankAccount
    def __init__(self, owner, balance, rate):
        super().__init__(owner, balance)  # call parent __init__
        self.rate = rate              # new attribute

    def add_interest(self):           # new method
        self._balance *= (1 + self.rate)

savings = SavingsAccount("Alice", 1000, 0.05)
savings.deposit(200)          # inherited from BankAccount
savings.add_interest()        # new method
print(savings.get_balance())  # 1260.0

Inheritance says "a SavingsAccount is a BankAccount with extra features." It inherits all methods from the parent and adds new ones. CSE3120 1.1.2 lists "inheritance" as a key OOP feature. ICS4U A2.2 names "inheritance, method overloading, method overriding, polymorphism" as the full picture (covered in AP CSA). This guide stops at one level of inheritance.继承表示"SavingsAccount 是具有额外功能的 BankAccount"。它从父类继承所有方法并添加新方法。CSE3120 1.1.2 将"继承"列为关键 OOP 特性。ICS4U A2.2 命名了"继承、方法重载、方法覆盖、多态"（在 AP CSA 中完整介绍）。本指南止于一层继承。