Mastering Object-Oriented Programming for Edexcel A-Level | Edexcel A-Level 面向对象编程精通指南

📚 Mastering Object-Oriented Programming for Edexcel A-Level | Edexcel A-Level 面向对象编程精通指南

Object-oriented programming (OOP) is a fundamental paradigm in the Edexcel A-Level Computer Science curriculum. It enables students to model real-world entities using classes and objects, making code more modular, reusable, and easier to maintain. This article covers all essential OOP concepts assessed in the examination, using Python as the primary language, and aligns with the Pearson Edexcel specification requirements.

面向对象编程（OOP）是 Edexcel A-Level 计算机科学课程中的基础范式。它使学生能够使用类和对象对现实世界实体进行建模，从而使代码更加模块化、可重用和易于维护。本文涵盖了考试中评估的所有核心 OOP 概念，以 Python 作为主要语言，并与 Pearson Edexcel 规范要求保持一致。

1. What is Object-Oriented Programming? | 什么是面向对象编程？

Object-oriented programming is a programming model organised around data, or objects, rather than functions and logic. An object is a self-contained entity that contains both data in the form of fields (often called attributes) and code in the form of procedures (often called methods). The four main principles of OOP are encapsulation, abstraction, inheritance, and polymorphism.

面向对象编程是一种围绕数据（即对象）而非函数和逻辑组织的编程模型。对象是一个自包含的实体，既包含字段（常称为属性）形式的数据，也包含过程（常称为方法）形式的代码。OOP 的四个主要原则是封装、抽象、继承和多态。

In Edexcel A-Level, you are expected to demonstrate the ability to design, implement, and evaluate OOP solutions. Typical exam questions ask you to identify classes from a scenario, write class definitions, and explain how OOP features improve code quality. Python’s OOP syntax is simple and consistent, making it the recommended choice for the practical programming project.

在 Edexcel A-Level 中，要求你展示设计、实现和评估 OOP 解决方案的能力。典型的考试问题要求你从场景中识别类，编写类定义，并解释 OOP 特性如何提高代码质量。Python 的 OOP 语法简单且一致，使其成为实践编程项目的推荐选择。

2. Classes and Objects | 类与对象

A class is a blueprint or template for creating objects. It defines the structure and behaviour that its objects will have. For example, a class Car might specify that every car has attributes like colour and speed, and methods like accelerate and brake. An object is an instance of a class, created by calling the class name followed by parentheses.

类是用于创建对象的蓝图或模板。它定义了其对象将具有的结构和行为。例如，一个 Car 类可以指定每辆车都有颜色和速度等属性，以及加速和刹车等方法。对象是类的一个实例，通过调用类名加括号来创建。

class Car:
    pass

my_car = Car()  # my_car is an object of class Car

Exam questions may ask you to identify suitable classes from a problem description. Look for nouns in the specification – these are often candidates for classes. Each object created from a class has its own copy of instance data, while sharing the same method definitions.

考试题目可能要求你从问题描述中找出合适的类。寻找规范中的名词——这些通常是类的候选项。从类创建的每个对象都有自己的实例数据副本，同时共享相同的方法定义。

3. Attributes and Methods | 属性与方法

Attributes are variables that belong to an object. They store the state of the object. In Python, attributes are usually defined inside the special method __init__. Methods are functions defined inside a class that describe the behaviours of objects. The first parameter of any instance method must be self, which refers to the current object.

属性是属于对象的变量。它们存储对象的状态。在 Python 中，属性通常在特殊方法 __init__ 内部定义。方法是在类内部定义的函数，描述对象的行为。任何实例方法的第一个参数必须是 self，它指向当前对象。

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

    def display_info(self):
        print(f"Name: {self.name}, Age: {self.age}")

When you call student1.display_info(), Python automatically passes the object as self. Always remember to include self in method definitions; forgetting to do so will cause a TypeError.

当你调用 student1.display_info() 时，Python 自动将对象作为 self 传递。始终记住在方法定义中包含 self；忘记这样做会导致 TypeError。

4. Constructor (init) and Instance Variables | 构造器与实例变量

The constructor is a special method called automatically when a new object is created. In Python, the constructor is __init__. It initialises the object’s attributes with initial values provided as arguments. Instance variables are those prefixed with self., meaning they belong to the specific instance.

构造器是一种特殊方法，在创建新对象时自动调用。在 Python 中，构造器是 __init__。它使用作为参数提供的初始值来初始化对象的属性。实例变量是那些以 self. 为前缀的变量，意味着它们属于特定实例。

class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn

Any attribute defined inside __init__ is an instance variable. In Edexcel exam scenarios, you may need to write a constructor that validates data, e.g., ensuring an age is positive. Mark schemes reward proper use of the constructor and appropriate default values when required.

在 __init__ 内部定义的任何属性都是实例变量。在 Edexcel 考试场景中，你可能需要编写一个验证数据的构造器，例如确保年龄为正数。评分方案对正确使用构造器以及在需要时提供适当的默认值给予奖励。

5. Encapsulation and Access Modifiers | 封装与访问修饰符

Encapsulation is the mechanism of bundling data (attributes) and methods that operate on that data within a single unit – the class. It also involves restricting direct access to some of an object’s internal components, which is typically achieved through naming conventions. In Python, a single underscore _attribute indicates a protected member (by convention), and double underscore __attribute triggers name mangling to make the attribute harder to access from outside.

封装是将数据（属性）和操作该数据的方法捆绑在一个单一单元（类）中的机制。它还涉及限制对对象某些内部组件的直接访问，这通常通过命名约定来实现。在 Python 中，单下划线 _attribute 表示受保护的成员（按约定），双下划线 __attribute 触发名称修饰，使从外部更难访问该属性。

Getters and setters are methods used to access and update private attributes. They provide controlled access, allowing validation before changes. In Python, the @property decorator is a more elegant way to implement getters and setters, but understanding the basic method pair is essential for the exam.

Getters 和 setters 是用于访问和更新私有属性的方法。它们提供受控访问，允许在更改前进行验证。在 Python 中，@property 装饰器是实现 getters 和 setters 的更优雅方式，但理解基本的方法对对于考试很重要。

class BankAccount:
    def __init__(self):
        self.__balance = 0

    def get_balance(self):
        return self.__balance

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

Exam questions often test your ability to explain why encapsulation improves maintainability and security, e.g., preventing invalid data from being stored directly in an attribute.

考试题目经常测试你解释为什么封装可以提高可维护性和安全性的能力，例如防止无效数据直接存储在属性中。

6. Inheritance | 继承

Inheritance allows a class (child or subclass) to derive attributes and methods from another class (parent or superclass). This promotes code reuse and establishes a hierarchical relationship. In Python, the parent class name is placed in parentheses after the child class name.

继承允许一个类（子类）从另一个类（父类或超类）派生属性和方法。这促进了代码重用并建立了层次关系。在 Python 中，父类名称放在子类名称后的括号中。

class Animal:
    def __init__(self, species):
        self.species = species

class Dog(Animal):
    def __init__(self, name):
        super().__init__('Canine')
        self.name = name

The function super() is used to call the parent class constructor and methods. In Edexcel exams, you might be asked to draw a class diagram showing inheritance or to implement a derived class that extends functionality while preserving the parent’s behaviour.

super() 函数用于调用父类的构造器和方法。在 Edexcel 考试中，可能要求你绘制显示继承的类图，或者实现一个扩展功能同时保留父类行为的派生类。

7. Polymorphism | 多态

Polymorphism means ‘many forms’. It allows objects of different classes to be treated as objects of a common superclass. The most common form is method overriding, where a subclass provides a specific implementation of a method already defined in its superclass. The correct method is determined at runtime based on the object’s type.

多态意味着“多种形式”。它允许将不同类的对象视为公共超类的对象。最常见的形式是方法覆盖，即子类提供其超类中已定义方法的具体实现。正确的方法在运行时根据对象的类型确定。

class Bird:
    def fly(self):
        return "Generic bird flying"

class Eagle(Bird):
    def fly(self):
        return "Eagle soaring high"

class Penguin(Bird):
    def fly(self):
        return "Penguins cannot fly"

When a function receives a Bird reference, it can call fly() on any bird object, and the specific version executes. This makes code flexible and extendable. In the Edexcel NEA (non-exam assessment), using polymorphism can demonstrate high-level design thinking.

当一个函数收到一个 Bird 引用时，它可以对任何鸟对象调用 fly()，并执行特定版本。这使得代码灵活且可扩展。在 Edexcel 非考试评估（NEA）中，使用多态可以展示高水平的设计思维。

8. Method Overriding and Overloading | 方法覆盖与重载

Method overriding is when a subclass provides its own version of a method inherited from the parent. Python does not support traditional method overloading (multiple methods with the same name but different parameters) as seen in Java. Instead, you can achieve similar behaviour using default arguments or variable-length argument lists (*args, **kwargs).

方法覆盖指的是子类提供从父类继承的方法的自身版本。Python 不支持像 Java 中那样的传统方法重载（多个同名但参数不同的方法）。相反，你可以使用默认参数或变长参数列表（*args、**kwargs）来实现类似行为。

class Rectangle:
    def area(self, length=None, breadth=None):
        if length is None and breadth is None:
            return "Unknown"
        return length * breadth

The Edexcel specification does not explicitly require overloading, but understanding the concept helps when comparing OOP languages. You are more likely to be examined on overriding and the principle of polymorphism.

Edexcel 规范并未明确要求重载，但理解这一概念有助于比较面向对象语言。你更可能被考察覆盖和多态原则。

9. Composition and Aggregation | 组合与聚合

Sometimes inheritance is not the best way to model a relationship. Composition (‘has-a’ relationship) involves building complex objects from simpler ones. Aggregation is a weaker form of composition where the contained object can exist independently. In Python, composition is implemented by storing an object of another class as an attribute.

有时继承并不是建模关系的最佳方式。组合（“有一个” 关系）涉及从较简单的对象构建复杂对象。聚合是组合的一种较弱形式，其中被包含的对象可以独立存在。在 Python 中，组合通过将另一个类的对象存储为属性来实现。

class Engine:
    def start(self):
        return "Engine started"

class Car:
    def __init__(self):
        self.engine = Engine()
    def drive(self):
        return self.engine.start()

Exam styling often includes a scenario where you must choose between inheritance and composition. Prefer composition when there is no clear ‘is-a’ hierarchy, as it leads to more flexible code and better adherence to the Single Responsibility Principle.

考试题目中经常包含一个场景，你必须在继承和组合之间做出选择。当没有明确的 “是一个” 层次结构时，优先选择组合，因为它导致更灵活的代码并更好地遵循单一职责原则。

10. Practical Design: Library Management System | 实际设计：图书馆管理系统

Let’s consolidate the concepts by designing a simple Library Management System. You need classes: Book (title, author, ISBN), Member (name, ID, borrowed books), and Library (catalogue, members list). The Library class uses composition of Book and Member objects. Methods include borrow_book() and return_book(), which modify the state of the respective objects.

让我们通过设计一个简单的图书馆管理系统来巩固概念。你需要以下类：Book（书名、作者、ISBN）、Member（姓名、ID、借阅书籍）和 Library（目录、成员列表）。Library 类使用 Book 和 Member 对象的组合。方法包括 borrow_book() 和 return_book()，这些方法会修改相应对象的状态。

class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn
        self.is_borrowed = False

class Member:
    def __init__(self, name, member_id):
        self.name = name
        self.member_id = member_id
        self.borrowed_books = []

class Library:
    def __init__(self):
        self.books = []
        self.members = []

    def add_book(self, book):
        self.books.append(book)

    def borrow(self, member, isbn):
        for book in self.books:
            if book.isbn == isbn and not book.is_borrowed:
                book.is_borrowed = True
                member.borrowed_books.append(book)
                return True
        return False

In an exam, you might be asked to complete missing methods or trace code execution. Such exercises test your understanding of object interaction and state management. Always consider edge cases, like trying to borrow an already borrowed book.

在考试中，可能要求你补全缺失的方法或跟踪代码执行。这类练习测试你对对象交互和状态管理的理解。始终考虑边缘情况，例如尝试借阅已借出的书。

11. Common Exam Traps and How to Avoid Them | 常见考试陷阱及规避方法

Misusing self: Forgetting to include self as the first parameter of a method leads to a TypeError. Always write def method(self, ...). Incorrect indentation: Python relies on indentation; ensure class body, method bodies, and conditionals are correctly indented.

误用 self：忘记将 self 作为方法的第一个参数会导致 TypeError。始终写成 def method(self, ...)。缩进错误：Python 依赖缩进；确保类体、方法体和条件语句正确缩进。

Confusing class and instance variables: Variables declared inside the class but outside methods are class variables (shared by all instances). Those assigned via self inside __init__ are instance variables. The Edexcel mark scheme penalises incorrect use.

混淆类变量与实例变量：在类内部但方法外部声明的变量是类变量（所有实例共享）。通过在 __init__ 内部的 self 赋值的变量是实例变量。Edexcel 评分方案对不当使用会扣分。

Ignoring inheritance details: When overriding a method, if you do not call super(), the parent’s version is not executed, potentially breaking behaviour. Read the question carefully to determine if the original functionality should be preserved.

忽略继承细节：在覆盖方法时，如果不调用 super()，父类的版本就不会执行，可能会破坏行为。仔细阅读题目以确定是否应保留原始功能。

12. Summary and Revision Checklist | 总结与复习清单

Object-oriented programming is a cornerstone of Edexcel A-Level Computer Science. You should be able to define and identify classes and objects, write and use a constructor, apply encapsulation with getters and setters, implement inheritance and polymorphism, and evaluate when to use composition over inheritance. Practical coding experience is crucial for the NEA and Paper 2.

面向对象编程是 Edexcel A-Level 计算机科学的基石。你应该能够定义和识别类与对象，编写和使用构造器，应用带 getters 和 setters 的封装，实现继承和多态，并评估何时使用组合而非继承。实际编码经验对非考试评估和 Paper 2 至关重要。

Topic / 主题	Key Points / 关键点
Classes & Objects	Blueprint and instance; syntax
Constructor	`__init__`, `self` attribute initialisation
Encapsulation	Private attributes, getter/setter
Inheritance	`super()`, base and derived classes
Polymorphism	Method overriding, runtime dispatch
Composition	Has-a relationships, flexible design

Use the checklist above to ensure you have covered each area. Practise writing short programs from scratch, and try tracing code with pen and paper. The more comfortable you are with OOP, the better you will perform in both theory and practical assessments.

使用上面的清单确保你已经覆盖了每个领域。练习从头开始编写小程序，并尝试用纸笔跟踪代码。你对 OOP 越熟悉，在理论和实践评估中就会表现得越好。

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

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

Mastering Object-Oriented Programming for Edexcel A-Level | Edexcel A-Level 面向对象编程精通指南