Object-Oriented Programming (OOP) for Edexcel A-Level | Edexcel A-Level面向对象编程

📚 Object-Oriented Programming (OOP) for Edexcel A-Level | Edexcel A-Level面向对象编程

Object-Oriented Programming (OOP) is a cornerstone of modern software development and a key topic in the Edexcel A-Level Computer Science specification. This article unpacks the essential OOP concepts – from classes and objects to inheritance and polymorphism – with clear explanations and Python code examples. You’ll learn how to recognise ‘is-a’ and ‘has-a’ relationships, implement encapsulation, use abstract base classes, and avoid common exam pitfalls. Whether you are writing pseudocode or fully‑fledged Python on your Paper 2, a solid grasp of OOP will help you model real‑world systems elegantly and score top marks.

面向对象编程（OOP）是现代软件开发的基石，也是Edexcel A-Level计算机科学考试的核心主题。本文通过清晰的概念讲解和Python代码示例，系统地梳理了类和对象、封装、继承、多态等必备知识。你将学会如何识别“is-a”与“has-a”关系、实现数据隐藏、使用抽象基类，并避开考试中的常见陷阱。无论你在试卷二中编写伪代码还是完整的Python程序，牢固掌握OOP都能让你优雅地建模真实世界系统，从而斩获高分。

1. What is OOP? | 什么是面向对象编程？

Object-Oriented Programming is a paradigm that organises software design around data, or objects, rather than functions and logic. An object is a self-contained entity that contains attributes (data) and methods (behaviours). OOP promotes modularity, code reuse, and easier debugging by mimicking the way real-world entities interact. The four fundamental principles are encapsulation, inheritance, polymorphism, and abstraction.

面向对象编程是一种将软件设计围绕数据（即对象）而非函数和逻辑来组织的范式。对象是一个自包含的实体，包含属性（数据）和方法（行为）。OOP通过模拟真实世界实体的交互方式，提升了模块化程度、代码复用性和调试的便利性。四项基本原则是：封装、继承、多态和抽象。

In Edexcel exams you are expected to apply OOP concepts in scenario-based questions – for example, modelling a library system, a vehicle fleet, or a game character hierarchy. The questions often ask you to draw class diagrams, identify relationships, and write Python methods that follow OOP best practices.

在Edexcel考试中，你需要将OOP概念应用于情景题——例如，模拟图书馆系统、车辆车队或游戏角色等级体系。题目常要求你绘制类图、识别关系，并编写遵循OOP最佳实践的Python方法。

2. Classes and Objects | 类与对象

A class is a blueprint for creating objects. It defines the attributes (variables that hold the state) and methods (functions that define behaviour). An object is an instance of a class – each object has its own copy of the attributes but shares the method definitions with other instances of the same class. In Python, a class is defined using the class keyword, and objects are created by calling the class name as if it were a function.

类是创建对象的蓝图。它定义了属性（保存状态的变量）和方法（定义行为的函数）。对象是类的实例——每个对象拥有自己的一份属性副本，但与同一类的其他实例共享方法定义。在Python中，使用class关键字定义类，并通过像调用函数一样使用类名来创建对象。

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

    def bark(self):
        return "Woof!"

my_dog = Dog("Rex", 3)
print(my_dog.bark())   # Woof!

Exam markers expect you to use the correct terminology: instance variable (attribute), constructor (__init__), and self to refer to the current object. Always show proper indentation and use meaningful names for identifiers.

阅卷官期望你使用正确的术语：实例变量（属性）、构造函数（__init__）以及用self引用当前对象。请始终保持正确的缩进，并为标识符起有意义的名字。

3. Encapsulation and Data Hiding | 封装与数据隐藏

Encapsulation means bundling the data and methods that operate on that data into a single unit (the class). It also restricts direct access to some of an object’s components, which is known as data hiding. In Python, encapsulation is achieved through naming conventions: a single underscore prefix (_) indicates a protected member, and a double underscore prefix (__) triggers name mangling to make an attribute pseudo‑private.

封装意味着将数据以及操作这些数据的方法捆绑到一个单一的单元（类）中。它还限制了对对象某些组件的直接访问，这被称为数据隐藏。在Python中，封装通过命名约定实现：单下划线前缀（_）表示受保护的成员，双下划线前缀（__）会触发名称改写，使属性成为伪私有。

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

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

    def get_balance(self):
        return self.__balance

Although Python does not enforce strict access control like Java, the Edexcel specification expects you to understand the principle. In pseudocode you can use the keywords PRIVATE and PUBLIC to mark the visibility of attributes and methods, which is explicitly tested.

尽管Python不像Java那样强制执行严格的访问控制，但Edexcel大纲要求你理解这一原则。在伪代码中，你可以使用PRIVATE和PUBLIC关键字来标记属性和方法的可见性，这是考试中明确会考查的内容。

4. Inheritance: the Is‑a Relationship | 继承：Is‑a关系

Inheritance allows a new class (subclass or child) to adopt the attributes and methods of an existing class (superclass or parent). It models an ‘is‑a’ relationship – for example, a Car is a Vehicle. The subclass can reuse, extend, or override the behaviour of the parent class. In Python, the parent class name is placed in parentheses in the subclass definition.

继承允许新类（子类）采纳现有类（父类）的属性和方法。它建模了“is‑a”关系——例如，Car是一个Vehicle。子类可以重用、扩展或覆盖父类的行为。在Python中，父类名放在子类定义时的括号内。

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

class Car(Vehicle):
    def __init__(self, make, model, num_doors):
        super().__init__(make, model)  # call parent constructor
        self.num_doors = num_doors

In Edexcel exams, you might be asked to draw an inheritance tree. Clearly label the superclass at the top, with arrows pointing downwards to subclasses. Remember that a subclass inherits all public and protected members but not private ones (in pseudocode). When writing Python, use super() to invoke the parent’s __init__().

在Edexcel考试中，你可能会被要求绘制继承树。需要清晰地将父类标注在顶部，并向下箭头指向子类。请记住，子类继承所有公有和受保护的成员，但不继承私有的（在伪代码中）。编写Python时，使用super()调用父类的__init__()。

5. Polymorphism | 多态

Polymorphism allows objects of different classes to respond to the same method call in their own way. It derives from Greek ‘poly’ (many) and ‘morph’ (form). In practice, polymorphism is often achieved through method overriding – a subclass provides a specific implementation of a method that is already defined in its superclass. The decision of which method to execute is made at runtime, enabling flexible and extensible code.

多态允许不同类的对象以自己的方式响应同一个方法调用。这个词源自希腊语“poly”（多）和“morph”（形）。在实践中，多态通常通过方法重写实现——子类提供对父类中已定义方法的具体实现。运行时决定执行哪个方法，从而使代码灵活、可扩展。

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h
    def area(self):
        return self.w * self.h

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return 3.14 * self.r * self.r

def print_area(s):
    print(s.area())

In the Edexcel specification, polymorphism is a high‑band topic. You should be able to explain how it differs from overloading (which Python does not natively support in the traditional sense) and give practical examples. The exam may ask you to complete a method that demonstrates polymorphic behaviour, so practise with code.

在Edexcel大纲中，多态是一个高难度主题。你应该能够解释它如何不同于重载（Python原生不支持传统意义上的重载），并给出实际例子。考试可能要求你补全展示多态行为的代码，因此务必动手练习。

6. Association, Aggregation and Composition | 关联、聚合与组合

Beyond inheritance, OOP uses three types of relationships to model real-world connections. Association is a general ‘uses‑a’ relationship between two classes – for example, a Driver uses a Car. Aggregation is a ‘has‑a’ relationship where the container and contained objects can exist independently – a Team has Players, but removing the team doesn’t delete the players. Composition is a stronger ‘owns‑a’ relationship where the contained objects cannot exist without the container – a House has Rooms; destroy the house and the rooms cease to exist.

除了继承，OOP还使用三种关系来建模真实世界中的联系。关联是两个类之间一般的“uses‑a”关系——例如，Driver使用Car。聚合是一种“has‑a”关系，容器对象和被包含对象可以独立存在——一个Team拥有Player，但删除队伍并不会删除球员。组合是一种更强的“owns‑a”关系，被包含对象不能独立于容器存在——House拥有Room，摧毁房屋则房间也不复存在。

In class diagrams, composition is shown with a filled diamond at the whole end, aggregation with a hollow diamond, and association with a simple line. Edexcel exam questions often ask you to label these symbols or decide which relationship fits a scenario. Be precise: confused terminology loses marks.

在类图中，组合用实心菱形表示整体端，聚合用空心菱形，关联则用普通线条。Edexcel考题经常要求你标注这些符号或判断哪种关系适合给定情景。务必准确使用术语，混淆不清会导致失分。

7. Abstract Classes and Interfaces | 抽象类与接口

An abstract class is a class that cannot be instantiated; it exists solely as a blueprint for subclasses. It may contain abstract methods (methods without a body) that subclasses are forced to implement. Python provides the abc module to create abstract base classes. Using abstract classes enhances design clarity and enforces a contract for derived classes.

抽象类是不能被实例化的类，它只作为子类的蓝图存在。抽象类可以包含抽象方法（没有方法体的方法），子类必须实现它们。Python提供abc模块来创建抽象基类。使用抽象类可以提升设计清晰度，并强制派生类遵守约定。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Cat(Animal):
    def make_sound(self):
        return "Meow"

Edexcel focuses mainly on pseudocode for abstract concepts, but you may be given Python code that uses @abstractmethod. You should recognise that an abstract method has no implementation in the parent and must be overridden in concrete subclasses. Interfaces (a collection of abstract methods) are not explicitly distinguished in Python, but the concept still appears in pseudocode questions.

Edexcel主要考查伪代码中的抽象概念，但你可能会遇到使用@abstractmethod的Python代码。你应该认识到抽象方法在父类中没有实现，并且必须在具体子类中被重写。接口（一组抽象方法的集合）在Python中没有明确的语法区分，但这一概念仍会出现在伪代码问题中。

8. Constructors and Destructors | 构造函数与析构函数

A constructor is a special method that is automatically called when an object is instantiated. In Python it is __init__. It typically initialises the instance’s attributes. A destructor (__del__ in Python) is called when an object is about to be destroyed, and it can be used for cleanup like closing files or releasing resources. However, in Python, destructors are rarely needed because garbage collection handles memory management.

构造函数是一个在对象实例化时自动调用的特殊方法。在Python中它是__init__。它通常用于初始化实例的属性。析构函数（Python中的__del__）在对象即将被销毁时调用，可用于清理工作，如关闭文件或释放资源。不过，在Python中，析构函数很少需要，因为垃圾回收负责内存管理。

In pseudocode, you may see new for the constructor. Edexcel expects you to know that constructors can be overloaded (in languages like Java) or accept default parameters. In Python you can simulate overloading by using default argument values.

在伪代码中，你可能会看到用new表示构造函数。Edexcel期望你知道构造函数可以被重载（在像Java这样的语言中），或者可以接受默认参数。在Python中，可以通过使用默认参数值来模拟重载。

9. Method Overriding vs Overloading | 方法重写与重载

Method overriding occurs when a subclass provides its own version of a method that is already defined in the parent. Overloading, on the other hand, means defining multiple methods with the same name but different parameter lists within the same class. Python does not support traditional method overloading natively – the last method definition wins. However, you can achieve similar behaviour by using variable‑length arguments (*args, **kwargs) or default parameter values.

方法重写发生在子类提供与父类中已定义方法的自身版本时。重载则指在同一个类中定义多个同名但参数列表不同的方法。Python原生不支持传统意义上的方法重载——最后一个方法定义会覆盖前面的。但你可以通过使用可变长参数（*args, **kwargs）或默认参数值来实现类似的行为。

For Edexcel, you need to distinguish these two concepts clearly. The exam may present pseudocode with overloaded constructors or ask you to explain the difference. Use examples: overriding is for polymorphism, overloading is for convenience with different input types or counts.

对于Edexcel，你需要清晰地区分这两个概念。考试可能会给出带有重载构造函数的伪代码，或要求你解释二者区别。请用例子说明：重写用于多态，重载则是为了方便处理不同的输入类型或数量。

10. OOP in Python: A Worked Example | Python中的OOP：一个完整示例

Let’s bring everything together by modelling a simple library system. We have an abstract LibraryItem class, concrete subclasses Book and DVD, and a Member class that shows aggregation. This design uses inheritance, encapsulation, polymorphism, and aggregation, covering most OOP concepts tested in the exam.

让我们通过模拟一个简单的图书馆系统来综合运用所学知识。我们有一个抽象类LibraryItem，具体子类Book和DVD，以及一个展示聚合关系的Member类。此设计使用了继承、封装、多态和聚合，覆盖了考试中测试的大多数OOP概念。

from abc import ABC, abstractmethod

class LibraryItem(ABC):
    def __init__(self, title, item_id):
        self.__title = title
        self.__item_id = item_id
        self.__on_loan = False

    def set_on_loan(self, status):
        self.__on_loan = status

    def is_on_loan(self):
        return self.__on_loan

    @abstractmethod
    def get_loan_period(self):
        pass

class Book(LibraryItem):
    def __init__(self, title, item_id, author, pages):
        super().__init__(title, item_id)
        self.author = author
        self.pages = pages

    def get_loan_period(self):
        return 21  # days

class DVD(LibraryItem):
    def __init__(self, title, item_id, runtime):
        super().__init__(title, item_id)
        self.runtime = runtime

    def get_loan_period(self):
        return 7

class Member:
    def __init__(self, name):
        self.name = name
        self.borrowed_items = []  # aggregation

    def borrow(self, item):
        if not item.is_on_loan():
            item.set_on_loan(True)
            self.borrowed_items.append(item)
            return True
        return False

This example shows encapsulation (private attributes with getters/setters), inheritance (Book and DVD from LibraryItem), polymorphism (each subclass implements get_loan_period() differently), and aggregation (Member holds a list of LibraryItems). Such integrated scenarios are common in Edexcel 12‑mark questions.

这个例子展示了封装（私有属性配合getter/setter）、继承（Book和DVD继承自LibraryItem）、多态（每个子类以不同方式实现get_loan_period()）以及聚合（Member持有一个LibraryItem列表）。这种综合情景在Edexcel 12分大题中十分常见。

11. Exam Tips for OOP Questions | OOP考题应试技巧

When tackling OOP questions, read the scenario carefully and underline the nouns that could become classes and actions that could become methods. Always show relationships explicitly in class diagrams: hollow or filled diamonds, open triangles for inheritance, and multiplicities (1, 1..*) where given. In pseudocode, follow the Edexcel reference notation – e.g., CLASS Car INHERITS Vehicle and PRIVATE speed : INTEGER. In Python, use standard conventions and comment your code to explain non‑obvious design choices.

解答OOP问题时，仔细阅读情景，将可能成为类的名词以及可能成为方法的动作划出来。在类图中要明确标出关系：实心或空心菱形，用空心三角形表示继承，以及题目给出的多重性（1, 1..*）。在伪代码中，遵循Edexcel参考标记法——例如使用CLASS Car INHERITS Vehicle和PRIVATE speed : INTEGER。编写Python代码时，使用标准约定，并为不够明显的设计选择添加注释。

Common pitfalls include forgetting to call the parent constructor with super().__init__, mixing up aggregation and composition, and providing an insufficiently detailed class diagram. Practise by past‑paper questions, timing yourself to sketch a class diagram in under 5 minutes and write a short Python implementation.

常见陷阱包括忘记用super().__init__调用父类构造函数、混淆聚合与组合、以及提供的类图不够详细。请通过历年真题进行练习，计时在5分钟内画出类图并编写简短的Python实现。

Published by TutorHao | Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

Object-Oriented Programming (OOP) for Edexcel A-Level | Edexcel A-Level面向对象编程