📚 Mastering Object-Oriented Programming for Edexcel A-Level Computer Science | Edexcel A-Level 计算机编程：面向对象编程精讲
Object-oriented programming (OOP) is a central topic in the Edexcel A-Level Computer Science specification. It moves beyond writing a simple list of instructions and instead models a system as a collection of interacting objects, each with state and behaviour. Mastering OOP helps you design reusable, maintainable code and is regularly assessed through short-answer questions, trace questions, and extended pseudocode tasks.
面向对象编程（OOP）是 Edexcel A-Level 计算机科学考试的核心主题。它不再只是写一系列简单指令，而是把系统建模为一组相互作用的对象，每个对象都有自己的状态和行为。掌握 OOP 有助于设计可重用、易维护的代码，并且经常在简答题、代码追踪题和扩展伪代码题中考查。
1. Programming Paradigms: Procedural vs OOP | 编程范式：过程式与面向对象
A programming paradigm is a fundamental style of programming. The procedural paradigm organises code into functions or procedures that operate on data, usually passed as parameters. The object-oriented paradigm instead bundles data and the operations that act on that data into a single unit: the object.
编程范式是编程的基本风格。过程式范式将代码组织成对数据进行操作的函数或过程，数据通常以参数形式传递。而面向对象范式则把数据和操作这些数据的方法打包在一个单元中：对象。
In Edexcel exams you may be asked to compare paradigms. A strong answer notes that procedural programs focus on actions and shared data structures, which can lead to unintended side effects when many functions read and write the same global variables. OOP reduces this risk by encapsulating data and allowing access only through defined methods.
在 Edexcel 考试中，可能会要求比较不同范式。优秀答案会指出：过程式程序关注动作和共享数据结构，许多函数读写同一全局变量时容易产生意外的副作用。OOP 通过封装数据、只允许通过规定的方法访问来降低这种风险。
| Aspect | 方面 | Procedural | 过程式 | Object-oriented | 面向对象 |
|---|---|---|
| Core idea | 核心思想 | Functions operate on separate data | Data and methods are combined in objects |
| Data access | 数据访问 | Often shared or global | Controlled through encapsulation |
| Reuse | 复用 | Functions and libraries | Classes, inheritance, composition |
| Modelling | 建模 | Focus on processes | Focus on entities and relationships |
2. Classes and Objects: The Blueprint and the Instance | 类与对象：蓝图与实例
A class is a user-defined blueprint or template that describes the attributes and methods that a group of similar objects will have. For example, a Student class might define attributes such as name, year group, and target grade, together with methods such as enrol() and getGrade().
类是用户定义的蓝图或模板，描述一组相似对象将具有的属性和方法。例如，Student 类可以定义诸如姓名、年级组和目标成绩等属性，以及 enroll() 和 getGrade() 等方法。
An object is a concrete instance of a class, created at runtime and occupying memory. You can create many objects from one class, each with its own distinct attribute values. For instance, student1 and student2 are two separate objects of the Student class, but they may have different names and grades.
对象是类的具体实例，在运行时创建并占用内存。一个类可以创建多个对象，每个对象都有自己独立的属性值。例如，student1 和 student2 是 Student 类的两个不同对象，但它们可能具有不同的姓名和成绩。
Instantiation is the process of creating an object from a class. This usually involves calling a constructor. In pseudocode terms: student1 = new Student("Alice", 11). The class defines the type, while the object represents a real, usable entity in the program.
实例化是从类创建对象的过程，通常需要调用构造函数。在伪代码中可表示为：student1 = new Student("Alice", 11)。类定义类型，而对象表示程序中真实可用的实体。
3. Attributes and Methods: State and Behaviour | 属性与方法：状态与行为
Attributes, also called fields or properties, represent the state of an object. They store data values that may change over time, such as a person’s age, a bank account’s balance, or a game character’s score. In a class, attributes are typically declared at the top and may be marked as private or public depending on the design.
属性（也叫字段或特性）表示对象的状态。它们存储可能随时间变化的数据值，例如人的年龄、银行账户的余额或游戏角色的得分。在类中，属性通常在顶部声明，并根据设计标记为 private 或 public。
Methods represent the behaviour of an object. They are functions defined inside a class that operate on the object’s attributes or perform actions relevant to that object. For example, a BankAccount class might have methods deposit(), withdraw(), and getBalance(); these methods change or read the balance attribute.
方法表示对象的行为。它们是定义在类内部的函数，用于操作对象的属性或执行与该对象相关的动作。例如，BankAccount 类可以有 deposit()、withdraw() 和 getBalance() 方法；这些方法会修改或读取 balance 属性。
In an exam answer, always link state to attributes and behaviour to methods. This shows the examiner that you understand the distinction between what an object knows and what an object can do.
在考试答案中，始终将状态与属性联系起来，将行为与方法联系起来。这可以向考官展示你理解“对象知道什么”和“对象能做什么”之间的区别。
4. Encapsulation: Protecting Data | 封装：保护数据
Encapsulation is the principle of hiding an object’s internal data and only allowing access through a controlled interface of methods. Attributes are usually made private, meaning they can only be changed by the object’s own methods. External code must use public getter and setter methods to read or modify the data.
封装是指隐藏对象的内部数据，只允许通过受控的方法接口进行访问。属性通常设为 private，这意味着它们只能由对象自身的方法修改。外部代码必须使用公共的 getter 和 setter 方法来读取或修改数据。
Encapsulation brings several benefits: it protects data from invalid changes, makes debugging easier, allows internal implementation changes without affecting other code, and improves modularity. For example, if a class stores temperature in Celsius, a setter method could reject values below absolute zero; direct public access would not allow this validation.
封装带来多个好处：保护数据免受无效更改、便于调试、允许在不影响其他代码的情况下改变内部实现，以及提高模块化程度。例如，如果一个类以摄氏度存储温度，setter 方法可以拒绝低于绝对零度的值；而直接公开访问就无法进行这种验证。
In Edexcel questions, look for statements such as “the attribute should be private to prevent external code from assigning an invalid value”. This is a classic encapsulation mark.
在 Edexcel 题目中，留意“属性应设为 private，以防止外部代码赋予无效值”这类表述。这是典型的封装考点。
5. Inheritance: Building Hierarchies | 继承：构建层次结构
Inheritance allows a new class, called a subclass or derived class, to take on the attributes and methods of an existing class, called the superclass or base class. The subclass can then add its own attributes and methods or override inherited methods to provide specialised behaviour.
继承允许新类（称为子类或派生类）继承现有类（称为超类或基类）的属性和方法。子类可以添加自己的属性和方法，也可以覆盖继承的方法以提供专门的行为。
Inheritance represents an “is-a” relationship. For example, a Car is a Vehicle, so Car can inherit from Vehicle. The Vehicle class might define wheels, speed, and move(); the Car class inherits these and adds engineSize or numberOfDoors. This avoids code duplication and supports polymorphism.
继承表示“is-a”关系。例如，Car 是一种 Vehicle，因此 Car 可以继承 Vehicle。Vehicle 类可以定义 wheels、speed 和 move()；Car 类继承这些内容，并添加 engineSize 或 numberOfDoors。这避免了代码重复，并支持多态。
Students often confuse inheritance with composition. Remember: use inheritance when one class is a specialised type of another; use composition when one class has another as part of it. A Car has an Engine, so that is composition or aggregation, not inheritance.
学生经常混淆继承和组合。记住：当一个类是另一个类的特殊类型时使用继承；当一个类包含另一个类作为其一部分时使用组合。Car 有一个 Engine，因此这是组合或聚合，而不是继承。
6. Polymorphism: One Interface, Many Forms | 多态：同一接口，多种形态
Polymorphism means “many forms”. In OOP, it allows a single method name or class reference to behave differently depending on the actual object type. The most common form in A-Level exams is method overriding, where a subclass provides its own implementation of an inherited method.
多态的意思是“多种形态”。在 OOP 中，它允许同一个方法名或类引用根据实际对象类型表现不同的行为。A-Level 考试中最常见的形式是方法重写，即子类为继承的方法提供自己的实现。
For example, a Shape class may define a method computeArea(). Circle and Rectangle subclasses can override computeArea() with their own formulas. A program can hold a list of Shape references and call computeArea() on each one; the correct version runs automatically for each object type.
例如，Shape 类可以定义 computeArea() 方法。Circle 和 Rectangle 子类可以用各自的公式重写 computeArea()。程序可以保存一个 Shape 引用列表，并对每个对象调用 computeArea()；正确的版本会根据对象类型自动运行。
Polymorphism increases flexibility and extensibility. New subclasses can be added without changing existing code that uses the superclass interface. In exam answers, describe this benefit and give a concrete example to earn full marks.
多态提高了灵活性和可扩展性。可以添加新的子类而不需要更改使用超类接口的现有代码。在考试答案中，描述这一优点并给出具体例子，可以拿到满分。
7. Association, Aggregation and Composition | 关联、聚合与组合
These three terms describe different types of relationships between classes. Association is the most general “uses-a” or “knows-a” relationship: one class interacts with another, but both can exist independently. For example, a Student uses a Library, but the Student and Library are not permanently bound.
这三个术语描述类之间的不同类型关系。关联是最一般的“uses-a”或“knows-a”关系：一个类与另一个类交互，但两者可以独立存在。例如，Student 使用 Library，但 Student 和 Library 并不永久绑定。
Aggregation is a stronger “has-a” relationship where a whole is made up of parts, but the parts can still exist independently of the whole. A Department has Teachers, but if the Department is deleted, the Teachers still exist. Composition is a stronger form of aggregation; the parts cannot exist without the whole. A House has Rooms, and if the House is destroyed, the Rooms are destroyed too.
聚合是一种更强的“has-a”关系，整体由部分组成，但部分仍可独立于整体存在。Department 有 Teacher，但即使 Department 被删除，Teacher 仍然存在。组合是聚合的更强形式；部分不能脱离整体存在。House 有 Room，如果 House 被摧毁，Room 也随之摧毁。
In Edexcel diagrams or written questions, you may need to identify whether a relationship is association, aggregation, or composition. Focus on lifespan: if the child object’s lifetime depends on the parent, choose composition; if it can outlive the parent, choose aggregation.
在 Edexcel 图表题或书面题中，可能需要判断关系是关联、聚合还是组合。关键看生命周期：如果子对象的生命周期依赖于父对象，选择组合；如果子对象可以比父对象存活更久，选择聚合。
8. Constructors and Instantiation | 构造函数与实例化
A constructor is a special method that is called automatically when an object is created. It sets up the object’s initial state, often by assigning values to attributes. In many languages the constructor has the same name as the class and no return type, even though it is a method-like block of code.
构造函数是在创建对象时自动调用的特殊方法。它负责设置对象的初始状态，通常为属性赋值。在许多语言中，构造函数与类同名且没有返回类型，尽管它类似于一段方法代码。
A default constructor takes no parameters and may initialise attributes to default values. A parameterised constructor takes arguments and allows each object to be initialised with different values. For example, new Student() uses the default constructor, while new Student("Alice", 11) uses a parameterised constructor.
默认构造函数不带参数，可以将属性初始化为默认值。参数化构造函数带参数，允许每个对象用不同的值进行初始化。例如，new Student() 使用默认构造函数，而 new Student("Alice", 11) 使用参数化构造函数。
You should be able to trace constructor calls in exam questions. When an object is instantiated, the constructor executes in full, assigning each attribute. If a subclass constructor calls a superclass constructor, that superclass constructor runs first to initialise inherited attributes.
在考试题中，你应当能够追踪构造函数的调用。当对象被实例化时，构造函数会完整执行，为每个属性赋值。如果子类构造函数调用超类构造函数，那么超类构造函数会先运行以初始化继承的属性。
9. OOP in Edexcel Exams: Pseudocode and Design | Edexcel 考试中的面向对象：伪代码与设计
Edexcel often accepts a clear, consistent pseudocode style rather than a specific programming language. The examiner is mainly marking your ability to show class structure, private attributes, public methods, inheritance, and correct object creation. You do not need perfect syntax, but you must be unambiguous.
Edexcel 通常接受清晰、一致的伪代码风格，而不是特定的编程语言。考官主要考查你能否展示类结构、私有属性、公共方法、继承和正确的对象创建。你不需要完美的语法，但必须表达明确。
A typical class definition might look like this: CLASS Student; PRIVATE name; PUBLIC PROCEDURE new(initialName); name = initialName; ENDPROCEDURE; FUNCTION getName(); RETURN name; ENDFUNCTION; ENDCLASS. This can be written in any Python-like or Pascal-like form as long as the logic is clear.
一个典型的类定义可能如下所示：CLASS Student；PRIVATE name；PUBLIC PROCEDURE new(initialName)；name = initialName；ENDPROCEDURE；FUNCTION getName()；RETURN name；ENDFUNCTION；ENDCLASS。只要逻辑清晰，可以写成类似 Python 或 Pascal 的形式。
When asked to design a system, always underline or highlight the OOP features: state which classes you will create, what attributes they hold, which relationships connect them, and where inheritance or polymorphism is used. This demonstrates higher-level design thinking.
当被要求设计系统时，始终突出 OOP 特性：说明要创建哪些类、它们持有哪些属性、哪些关系将它们连接起来，以及在哪里使用了继承或多态。这展示出更高层次的设计思维。
10. Common Pitfalls and Exam Tips | 常见错误与应试技巧
One common mistake is confusing a class with an object. Remember that the class is the definition and the object is the actual instance in memory. Saying “the object is the blueprint” loses marks; instead say “the class is the blueprint and the object is an instance of that class”.
一个常见错误是混淆类和对象。记住，类是定义，对象是内存中的实际实例。如果说“对象是蓝图”就会失分；应该说“类是蓝图，对象是该类的实例”。
Another frequent error is breaking encapsulation by making every attribute public. Examiners expect private attributes with public methods for controlled access. If you need to change an attribute, use a setter; if you need to read it, use a getter.
另一个常见错误是通过将所有属性设为 public 来破坏封装。考官期望属性为 private，并通过公共方法进行受控访问。如果需要修改属性，使用 setter；如果需要读取属性，使用 getter。
Students also misuse inheritance. Do not use inheritance merely to save a few lines of code; it should represent a logical “is-a” relationship. If the relationship is “has-a”, use aggregation or composition instead. Also avoid deep inheritance hierarchies that make the system hard to understand.
学生也常常误用继承。不要仅仅为了省几行代码就使用继承；继承应当表示逻辑上的“is-a”关系。如果关系是“has-a”，应使用聚合或组合。此外，避免过深的继承层次，以免系统难以理解。
Finally, when tracing polymorphic calls, always check the actual object type at runtime, not the reference type. If a Shape variable points to a Circle object, the Circle version of an overridden method runs. This dynamic behaviour is a key exam focus.
最后，在追踪多态调用时，始终检查运行时实际对象类型，而不是引用类型。如果 Shape 变量指向 Circle 对象，则运行被重写方法的 Circle 版本。这种动态行为是考试的重点。
11. Practice Questions and Model Thought Process | 练习题与解题思路
Question: A school records students and teachers. Both are people with a name and an ID, but only teachers have a salary and a subject. Explain how you would use inheritance to model this system, and identify one benefit.
问题：一所学校要记录学生和教师。学生和教师都是人，都有姓名和 ID，但只有教师有工资和科目。说明如何使用继承来建模该系统，并指出一个优点。
Model answer: Create a Person superclass with private attributes name and id, and public methods getName() and getId(). Then create Student and Teacher subclasses that inherit from Person. The Teacher subclass adds private attributes salary and subject, with appropriate getters and setters. This reduces code duplication because name and id are defined once in Person, and new Person subclasses can be added later without changing existing code.
参考答案：创建一个 Person 超类，包含私有属性 name 和 id，以及公共方法 getName() 和 getId()。然后创建继承 Person 的 Student 和 Teacher 子类。Teacher 子类添加私有属性 salary 和 subject，并配有相应的 getter 和 setter。这减少了代码重复，因为 name 和 id 只在 Person 中定义一次，以后可以添加新的 Person 子类而无需更改现有代码。
Question: A Car is made up of an Engine, four Wheels, and a Body. Is this best modelled by inheritance or composition? Justify your answer.
问题：一辆 Car 由 Engine、四个 Wheel 和 Body 组成。这个场景最好用继承还是组合来建模？请说明理由。
Model answer: Composition is more appropriate because a Car has these parts; the relationship is “has-a” rather than “is-a”. The Engine and Wheels are components that belong to the Car, and their lifetime is controlled by the Car. Using inheritance would incorrectly suggest that Car is a type of Engine or Wheel, which is not true.
参考答案：组合更合适，因为 Car 拥有这些部件；关系是“has-a”而不是“is-a”。Engine 和 Wheel 是属于 Car 的组件，它们的生命周期由 Car 控制。使用继承会错误地暗示 Car 是 Engine 或 Wheel 的一种，这并不正确。
12. Summary and Revision Checklist | 总结与复习清单
Object-oriented programming is a paradigm that organises software as objects with state and behaviour. The key concepts are classes, objects, attributes, methods, encapsulation, inheritance, polymorphism, and class relationships such as association, aggregation, and composition.
面向对象编程是一种将软件组织为具有状态和行为的对象的编程范式。关键概念包括类、对象、属性、方法、封装、继承、多态以及关联、聚合和组合等类关系。
- Define class and object and explain the difference | 定义类和对象并解释其区别
- Describe attributes and methods | 描述属性与方法
- Explain encapsulation and its benefits | 解释封装及其优点
- Use inheritance to model “is-a” relationships | 使用继承建模“is-a”关系
- Explain polymorphism with an overriding example | 用重写示例解释多态
- Distinguish association, aggregation, and composition | 区分关联、聚合和组合
- Write and trace constructors | 编写并追踪构造函数
- Apply clear pseudo-code
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
屏轩国际教育cambridge primary/secondary checkpoint, cat4, ukiset,ukcat,igcse,alevel,PAT,STEP,MAT, ibdp,ap,ssat,sat,sat2课程辅导，国外大学本科硕士研究生博士课程论文辅导