📚 Object-Oriented Programming for Edexcel A-Level | 面向对象编程（Edexcel A-Level）
Object-oriented programming (OOP) is a programming paradigm that models real-world entities as objects containing both data (attributes) and behaviour (methods). It is a core part of the Edexcel A-Level Computer Science specification, appearing in theory questions and in the practical NEA project.
A class is a blueprint or template that defines the attributes (data) and methods (behaviour) of a type of object. An object is a specific instance of a class created at runtime. For example, the class Student may define attributes such as name, age, and grade; each Student object represents one actual learner with its own values.
In Edexcel exam questions, you often need to identify a suitable class name, list its attributes, and write methods that operate on those attributes. Clear separation between class and object shows understanding of instantiation.
Attributes are the data fields stored inside an object, such as an integer age, a string name, or a boolean enrolled. Methods are the operations that define behaviour, such as calculateAverageMark() or updateAttendance(). Methods often read or modify attributes, so they should be designed to keep the object in a valid state.
属性是存储在对象内部的数据字段，例如整型 age、字符串 name 或布尔型 enrolled。方法是定义行为的操作，如 calculateAverageMark() 或 updateAttendance()。方法通常会读取或修改属性，因此应设计成使对象始终处于有效状态。
When modelling a problem, start by listing the nouns as candidate classes and the verbs as candidate methods. This simple technique aligns with Edexcel mark schemes that reward a clear mapping from problem statement to design.
A constructor is a special method that runs when an object is created. It usually initialises attributes to avoid undefined values. In pseudocode, a constructor often has the same name as the class and no return type. A default constructor takes no arguments, while a parameterised constructor accepts initial values.
For example, a parameterised constructor for Student might accept newName, newAge, and newGrade, then assign them to attributes. In the exam, you must show correct assignment and not confuse the parameter name with the attribute name.
Encapsulation means hiding the internal state of an object and only exposing a controlled interface. Attributes are usually declared private so they cannot be changed directly from outside. Public getter and setter methods allow controlled access and validation.
The table summarises typical access levels. Edexcel questions may ask you to choose the most appropriate modifier for a given attribute, rewarding answers that justify data protection.
Inheritance allows a subclass to derive attributes and methods from a superclass, supporting code reuse and an ‘is-a’ relationship. For example, Dog and Cat can inherit from Animal because a dog is an animal. The subclass may add its own specialised methods or override inherited ones.
In Edexcel pseudocode, you might write class Dog inherits Animal. The exam may ask you to state one advantage of inheritance, such as avoiding duplicate code, and one disadvantage, such as increased coupling between classes.
在 Edexcel 伪代码中，可能会写成 class Dog inherits Animal。考试可能会要求说明继承的一个优点（如避免重复代码）和一个缺点（如增加类之间的耦合）。
6. Polymorphism | 多态
Polymorphism means ‘many forms’ and allows the same method call to behave differently depending on the object’s runtime type. This is typically achieved through method overriding, where a subclass provides its own implementation of a method defined in the superclass.
For instance, an array of Animal objects may contain Dog, Cat, and Bird instances. Calling the makeSound() method on each element invokes the appropriate subclass version, demonstrating dynamic dispatch. Edexcel questions often ask you to identify polymorphic behaviour from a scenario.
7. Association, Aggregation and Composition | 关联、聚合与组合
Association is a general ‘has-a’ relationship between objects, such as a Student having a Tutor. Aggregation is a weaker whole-part relationship where the part can exist independently, such as a Department having Lecturers; if the Department closes, lecturers still exist. Composition is a stronger relationship where the part cannot exist without the whole, such as a House having Rooms; if the house is destroyed, rooms are too.
关联是对象之间一般的“has-a”关系，例如 Student 有 Tutor。聚合是一种较弱的整体-部分关系，其中部分可以独立存在，例如 Department 有 Lecturer；如果系关闭，讲师仍然存在。组合是一种更强的关系，部分不能脱离整体存在，例如 House 有 Room；如果房子被毁，房间也不复存在。
In UML, a hollow diamond represents aggregation and a filled diamond represents composition. Being able to distinguish these helps you design accurate class diagrams in Edexcel papers and NEA documentation.
An abstract class is designed to be a base class that cannot be instantiated directly. It may contain abstract methods (signatures without implementation) and concrete methods. An interface defines a contract of method
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
Object-oriented programming (OOP) is a central topic in the Edexcel A-Level Computer Science specification. It is the basis for designing reusable, maintainable and secure code. This revision guide covers the key OOP concepts you need for both Paper 1 and Paper 2 style questions, including classes, objects, encapsulation, inheritance, polymorphism and object relationships.
面向对象编程（OOP）是 Edexcel A-Level 计算机科学大纲中的核心主题。它是设计可重用、可维护且安全代码的基础。本复习指南涵盖 Paper 1 和 Paper 2 中可能出现的 OOP 关键概念，包括类、对象、封装、继承、多态和对象关系。
1. Programming Paradigms: Procedural vs Object-Oriented | 编程范式：过程式与面向对象
A programming paradigm is a fundamental style or way of programming. Procedural programming structures code as a sequence of instructions and functions that operate on data. Object-oriented programming instead organises code around objects, which combine data and the methods that act on that data.
Procedural: separates data and functions; uses top-down design; examples include C, Pascal and older BASIC. | 过程式：将数据与函数分离；使用自顶向下设计；例如 C、Pascal 和早期 BASIC。
Object-oriented: bundles data and methods; supports abstraction, encapsulation and reuse; examples include Java, C++ and Python. | 面向对象：将数据和方法捆绑；支持抽象、封装和重用；例如 Java、C++ 和 Python。
2. Classes and Objects | 类与对象
A class is a template or blueprint that defines the attributes and methods common to all objects of a certain kind. It does not store actual data itself; rather, it describes what data and behaviour its objects will have.
类是定义某一类对象共有属性和方法的模板或蓝图
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
Operators are the building blocks of any expression in computer science. In the Edexcel A-Level programming units, you are expected to use arithmetic, comparison, Boolean and string operators confidently within pseudocode and trace tables. A solid understanding of operators prevents logic errors and helps you predict the exact output of an algorithm under examination conditions.
An operator is a symbol or keyword that tells the program to perform a specific operation on one or more values called operands. For example, in 3 + 5 the operator is + and the operands are 3 and 5. Operators are classified by the number of operands: unary operators take one operand, such as NOT or unary minus, while binary operators take two operands, such as +, AND and =.
Edexcel pseudocode includes six common arithmetic operators: + for addition, – for subtraction, * for multiplication, / for real division, DIV for integer division, and MOD for the remainder after integer division. The less familiar ones are DIV and MOD because they work only with integers and are frequently tested in trace tables and dry-run questions.
Edexcel 伪代码包含六种常见算术运算符：+ 加法、– 减法、* 乘法、/ 实数除法、DIV 整数除法和 MOD 求余。较不熟悉的是 DIV 和 MOD，因为它们仅适用于整数，并且经常在追踪表与手工运行题中考查。
Operator
Meaning
Example
Result
+
addition
7 + 2
9
–
subtraction
9 – 4
5
*
multiplication
6 * 8
48
/
real division
7 / 2
3.5
DIV
integer division
7 DIV 2
3
MOD
remainder
7 MOD 2
1
3. Integer division and modulus | 整数除法与取模
DIV produces the whole-number quotient after discarding the fractional part. MOD produces the remainder after integer division. For example, 23 DIV 5 = 4 and 23 MOD 5 = 3, because 5 × 4 + 3 = 23. In Edexcel exam questions, the values are usually positive integers, so you do not need to worry about negative-value conventions unless the paper states otherwise.
DIV 产生丢弃小数部分后的整数商。MOD 产生整数除法后的余数。例如，23 DIV 5 = 4 且 23 MOD 5 = 3，因为 5 × 4 + 3 = 23。在 Edexcel 考试中，数值通常为正整数，因此除非试卷另有说明，否则无需担心负值约定。
dividend = divisor × quotient + remainder
4. Comparison operators | 比较运算符
Comparison or relational operators compare two values and return a Boolean result: TRUE or FALSE. Edexcel notation commonly includes =, <>, <, >, <= and >=. Do not confuse = with assignment; in an expression, equality is a question, not a command.
📚 Object-Oriented Programming: Classes, Inheritance and Polymorphism | 面向对象编程：类、继承与多态
Object-oriented programming (OOP) is a central part of Edexcel A-Level Computer Science Topic 6: Problem solving with programming. This article explains OOP concepts in a practical way, using Python-style examples to help you answer exam questions on classes, inheritance, polymorphism and encapsulation.
A programming paradigm is a style or way of thinking about how to structure code. Edexcel expects you to compare paradigms, especially procedural and object-oriented. Procedural programming organises code as a sequence of instructions, functions and data passed between them. OOP organises code around objects that combine data and behaviour. Understanding the difference helps you choose suitable designs and justify choices in exam answers.
Procedural = step-by-step instructions + separate data | 面向过程 = 逐步指令 + 分离的数据
Object-oriented = objects with attributes and methods | 面向对象 = 具有属性和方法的对象
2. Procedural vs Object-Oriented Thinking | 面向过程与面向对象的思维对比
In procedural programming, a banking system might have functions like deposit(account, amount) and withdraw(account, amount), with account stored as a dictionary and passed each time. In OOP, account is an object with attributes (balance, owner) and methods (deposit, withdraw) already attached. This makes OOP more modular for large systems, because related data and functions stay in one place.
3. Classes and Objects: The Blueprint Analogy | 类与对象：蓝图类比
A class is a blueprint or template; an object is a concrete instance created from that class. For example, Dog is a class, while my_dog = Dog(“Rex”) creates one Dog object. Edexcel questions often ask you to identify the class and the object in a scenario. Use the analogy of a cookie cutter (class) and cookies (objects): the cutter defines shape, but each cookie can have different icing or size.
类是一个蓝图或模板；对象是根据该类创建的具体实例。例如，Dog 是一个类，而 my_dog = Dog(“Rex”) 创建了一个 Dog 对象。Edexcel 题目经常要求识别场景中的类和对象。可以用模具（类）和饼干（对象）类比：模具决定形状，但每块饼干可以有不同的糖霜或大小。
class Dog:
def __init__(self, name):
self.name = name
my_dog = Dog("Rex")
Here, Dog is the class and my_dog is one instance of that class. | 这里，Dog 是类，my_dog 是该类的一个实例。
4. Attributes and Methods: Data + Behaviour | 属性和方法：数据 + 行为
Attributes are variables that belong to an object; they store its state. Methods are functions that belong to a class; they define behaviour. In a Car class, attributes include speed, fuel, colour; methods include accelerate(), brake(), refuel(). The constructor (in Python, __init__) sets initial attribute values. Exam answers should use accurate terms: attribute, method, constructor, not just “variable” and “function” when talking about OOP.
属性是属于对象的变量，用于存储状态。方法是属于类的函数，用于定义行为。在 Car 类中，属性包括速度、油量、颜色；方法包括加速、刹车、加油。构造函数（Python 中为 __init__）用于设置属性的初始值。考试答案应使用准确术语：属性、方法、构造函数，而不是在讨论 OOP 时仅仅说“变量”和“函数”。
Constructor: initialises attributes when object is created | 构造函数：创建对象时初始化属性
5. Encapsulation: Protecting Internal State | 封装：保护内部状态
Encapsulation means hiding the internal details of an object and exposing only what is necessary through methods. This prevents invalid changes, such as setting a bank balance to a negative value directly. In Python, a common convention is to prefix an attribute with an underscore (e.g., _balance) and provide getter/setter methods. Edexcel may ask why encapsulation is important: it improves maintainability, security and reduces unintended interference between components.
Data integrity: attributes can be validated before changing | 数据完整性：属性在修改前可进行验证
Loose coupling: objects interact through well-defined methods | 松散耦合：对象通过定义良好的方法进行交互
Easier maintenance: internal representation can change without breaking outside code | 易于维护：内部表示改变不会破坏外部代码
6. Inheritance: Reusing and Extending Classes | 继承：复用与扩展类
Inheritance allows a new class (subclass/derived class) to inherit attributes and methods from an existing class (superclass/base class). For example, Animal is a superclass; Dog and Cat are subclasses that inherit eat() and sleep() but define their own speak(). This avoids code duplication and models “is-a” relationships. In exams, you may be asked to draw a class diagram or identify superclass/subclass from a description.
7. Polymorphism: One Interface, Many Forms | 多态：一个接口，多种形态
Polymorphism means “many forms”: the same method name can behave differently in different classes. If Dog and Cat both have speak(), code can call animal.speak() without knowing which specific type animal is. This is useful when processing lists of objects. Edexcel often combines polymorphism with inheritance: subclasses override methods to provide their own implementation. A method overriding occurs when a subclass defines a method with the same signature as the superclass.
多态意思是“多种形态”：相同的方法名可以在不同类中表现出不同行为。如果 Dog 和 Cat 都有 speak()，代码可以调用 animal.speak()，而无需知道 animal 具体是哪种类型。这在处理对象列表时非常有用。Edexcel 经常将多态与继承结合考查：子类重写（override）方法以提供自己的实现。当子类定义与父类相同签名的方法时，就发生了方法重写。
Example: | 示例：
for animal in animals:
animal.speak()
The same call speak() produces “Woof” for Dog or “Meow” for Cat. | 同样的调用 speak() 对于 Dog 会产生“Woof”，对于 Cat 会产生“Meow”。
8. Abstract Classes and Interfaces | 抽象类与接口
An abstract class is a class that cannot be instantiated directly; it exists to be inherited. Abstract methods are declared with no implementation, forcing subclasses to provide concrete behaviour. For example, an abstract Shape class has method area(), but cannot create a Shape object; Circle and Square must implement area(). Interfaces are similar, specifying method signatures without any data. Edexcel may ask you to explain the purpose: to define a common contract.
Consider a question: “A wildlife simulation needs animals to move, eat and make sound. Design OOP classes.” You would identify a base class Animal with attributes name, energy and methods move(), eat(), make_sound(). Then subclasses Bird, Fish, Mammal override move() and make_sound(). Using polymorphism, the simulation can call move() on every animal in a list without repeated if-statements. Encapsulation ensures energy cannot be set below 0 directly. Inheritance avoids rewriting eat() for each subtype. These are the key marks examiners look for.
Common mistakes: confusing class with object, forgetting the constructor role, saying “encapsulation is only about security”, using inheritance when composition is better, and failing to mention method overriding in polymorphism questions. Exam tips: define terms precisely, use examples, relate each OOP concept to a benefit (reuse, maintainability, data integrity), and when asked to evaluate paradigms, always compare procedural vs OOP with a scenario. Edexcel mark schemes reward “because” statements, not just definitions.
Object-oriented programming (OOP) is one of the core programming paradigms assessed in Edexcel A-Level Computer Science. You will need to explain its key features, compare it with procedural programming, and apply it in your programming project. This revision guide breaks down the core concepts and exam-style pitfalls.
1. Programming Paradigms and Why They Matter | 编程范式及其重要性
A programming paradigm is a fundamental style of writing code. Edexcel expects you to distinguish between procedural, object-oriented, and event-driven paradigms, with a focus on how OOP promotes reuse and maintainability.
In procedural programming, the program is organised around functions that operate on separate data. In OOP, data and the functions that work on that data are bundled into objects, which more closely models real-world systems.
Event-driven programming, by contrast, structures code around responses to events such as mouse clicks or key presses. You may see all three paradigms in a single Edexcel question, so focus on the organisation of code and data in each.
2. Classes and Objects: The Blueprint and the Instance | 类与对象：蓝图与实例
A class is a template or blueprint that defines the attributes and methods for a category of objects. An object is a concrete instance created from that class.
类是定义某一类对象的属性和方法的模板或蓝图。对象是由该类创建的具体实例。
For example, a class Car might have attributes such as registration and engineSize, and methods such as accelerate(). Each actual car in the program is an object of the class.
例如，类 Car 可能具有 registration 和 engineSize 等属性，以及 accelerate() 等方法。程序中的每辆真实汽车都是该类的一个对象。
Class: a static definition; object: a dynamic instance with its own state.
类：静态定义；对象：拥有自身状态的动态实例。
Many objects can be created from one class, each holding different attribute values.
一个类可以创建多个对象，每个对象保存不同的属性值。
3. Attributes and Methods: State and Behaviour | 属性与方法：状态与行为
Attributes store the state of an object, while methods define its behaviour. In exam pseudocode, attributes can be private, protected, or public depending on the access modifier.
Methods often include accessor methods (getters) that return an attribute value and mutator methods (setters) that change it. This supports encapsulation by controlling how state is modified.
When answering exam questions, link attributes to ‘what an object knows’ and methods to ‘what an object can do’. This small distinction earns marks in definition-style questions.
A constructor is a special method that runs automatically when an object is created. It often sets initial values for attributes, ensuring the object starts in a valid state.
构造函数是在创建对象时自动运行的特殊方法。它通常为属性设置初始值，确保对象以有效状态开始。
Instantiation is the process of creating an object from a class, using the keyword new in many languages or NEW in Edexcel-style pseudocode. If a class has no constructor, a default empty one is provided.
实例化是从类创建对象的过程，在许多语言中使用 new 关键字，在爱德思风格伪代码中使用 NEW。如果类没有构造函数，则提供一个默认的空构造函数。
myCar = NEW Car(“AB12 CDE”)
This line calls the constructor and returns an object reference stored in myCar. You should be able to trace how constructor parameters become initial attribute values.
Encapsulation means bundling data and methods together and restricting direct access to an object’s internal state. It is implemented using access modifiers such as private, public, and protected.
By making attributes private, you force external code to use public methods, which can validate data and prevent invalid changes. This increases reliability and makes maintenance easier.
Protected: accessible in the class and its subclasses.
受保护：可在类及其子类中访问。
In Edexcel questions, a common mark is awarded for stating that encapsulation prevents invalid data from being assigned directly. Always mention the state of an object is protected.
Inheritance allows a new class to take on the attributes and methods of an existing base class. The new class is called a derived class or subclass, and it can add or override members.
继承允许新类获得现有基类的属性和方法。新类称为派生类或子类，它可以增加或覆盖成员。
Inheritance expresses an ‘is-a’ relationship. For example, a SportsCar is a Car, so SportsCar can inherit everything common to all cars while adding specific features such as turboMode.
In Edexcel pseudocode, you may show inheritance as SportsCar INHERITS Car or with a class diagram arrow from subclass to superclass. Be prepared to identify attributes and methods available in both classes.
在爱德思伪代码中，你可以用 SportsCar INHERITS Car 表示继承，或者用从子类指向超类的类图箭头来表示。要准备好识别两个类中都可用的属性和方法。
7. Polymorphism and Method Overriding | 多态与方法覆盖
Polymorphism means ‘many forms’. In OOP, it allows a derived class to be treated as its base class, while the correct overridden method is called at runtime based on the actual object type.
Method overriding occurs when a subclass provides a new version of a method with the same signature. This supports dynamic dispatch, enabling code such as vehicle.move() to behave differently for a bike, car, or train.
Edexcel exam questions often ask for an example of polymorphism. A strong answer uses a base class reference holding a subclass object and explains that the subclass method is executed.
A short comparison can help with 4-6 mark exam questions. Procedural programming uses flat functions and shared data, while OOP bundles state and behaviour into objects with encapsulation and inheritance.
Use this table to structure comparison answers. Always link a feature to a concrete consequence, such as easier debugging or reduced code duplication.
使用此表来组织比较类答案。始终将一个特性与具体结果联系起来，例如更容易调试或减少代码重复。
9. Common Edexcel Exam Pitfalls | 爱德思考试常见误区
Students often confuse a class with an object, or write ‘encapsulation’ when they mean ‘inheritance’. Use precise vocabulary: encapsulation is data hiding; inheritance is class reuse; polymorphism is runtime behaviour.
📚 A-Level Edexcel Programming: Operators, Expressions and Control Flow | A-Level Edexcel 编程：运算符、表达式与控制流
In Edexcel A-Level Computer Science, programming questions test your ability to trace, write and correct pseudocode. Operators, expressions and control flow form the foundation of nearly every algorithm you will encounter on Paper 1 and in the practical programming project.
在 Edexcel A-Level 计算机科学考试中，编程题考查跟踪、编写和纠正伪代码的能力。运算符、表达式和控制流是你在 Paper 1 和编程项目中几乎所有算法的基础。
1. Data Types and Variables | 数据类型与变量
Before using any operator, you must know the data type of each operand. Edexcel pseudocode uses five core types: integer, real, Boolean, character and string.
Variables must be declared with a clear data type. A common exam mistake is mixing types, such as trying to add an integer to a string without converting first.
变量必须声明清楚的数据类型。常见考试错误是混合类型，例如未先转换就将整数与字符串相加。
INTEGER: whole numbers, e.g. -3, 0, 42 整数：如 -3、0、42
REAL: numbers with a fractional part, e.g. 3.14 实数：带小数部分的数字，如 3.14
BOOLEAN: TRUE or FALSE 布尔：TRUE 或 FALSE
CHAR: a single character, e.g. ‘A’ 字符：单个字符，如 ‘A’
STRING: a sequence of characters, e.g. “hello” 字符串：字符序列，如 “hello”
2. Arithmetic Operators | 算术运算符
Arithmetic operators allow you to perform calculations on numeric data. Edexcel includes the standard operators plus integer division and modulo.
算术运算符允许你对数值数据执行计算。Edexcel 包括标准运算符以及整数除法和取模运算。
Operator
Meaning
Example
+
Addition
5 + 3 = 8
–
Subtraction
5 – 3 = 2
*
Multiplication
5 * 3 = 15
/
Division (real result)
5 / 2 = 2.5
DIV
Integer division
5 DIV 2 = 2
MOD
Remainder after division
5 MOD 2 = 1
Be careful with DIV and MOD when negative numbers are involved. In Edexcel pseudocode, DIV truncates towards zero, and MOD gives the remainder with the sign of the dividend.
当涉及负数时，使用 DIV 和 MOD 要小心。在 Edexcel 伪代码中，DIV 向零截断，MOD 给出带被除数符号的余数。
3. Relational and Comparison Operators | 关系与比较运算符
Comparison operators return a Boolean result and are essential for building conditions in selection and iteration.
比较运算符返回布尔结果，并且在选择和迭代中构建条件时必不可少。
= equal to 等于
≠ or != not equal to 不等于
< less than 小于
> greater than 大于
<= less than or equal to 小于或等于
>= greater than or equal to 大于或等于
When comparing strings, the comparison is typically based on lexicographic order using the character set’s collating sequence. For example, “apple” < “banana” because ‘a’ comes before ‘b’.
📚 A-Level Edexcel Programming: Core Algorithms and Data Structures | A-Level Edexcel 编程：核心算法与数据结构
This revision guide covers the core programming content required for Edexcel A-Level Computer Science, from computational thinking and pseudocode to recursion, object-oriented programming, and exam technique. Use it alongside past papers and trace tables to build confidence with algorithm design and code interpretation.
1. Computational Thinking and Pseudocode | 计算思维与伪代码
Computational thinking involves decomposition, pattern recognition, abstraction, and algorithm design. In Edexcel exams you will be expected to write pseudocode rather than a specific programming language syntax. Pseudocode should be clear, consistent, and unambiguous.
For example, a loop to sum the first 10 integers can be written as:
例如，计算前 10 个整数之和的循环可写成：
total ← 0 FOR i ← 1 TO 10 total ← total + i ENDFOR OUTPUT total
Always define variables, use meaningful identifiers, and indent control structures.
始终定义变量、使用有意义的标识符并缩进控制结构。
2. Variables, Data Types and Operators | 变量、数据类型与运算符
Common data types in Edexcel pseudocode include INTEGER, REAL, BOOLEAN, CHAR, and STRING. Arithmetic operators are +, −, ×, ÷, and DIV, MOD for integer division and remainder. Comparison operators include =, ≠, <, ≤, >, ≥.
Edexcel 伪代码常见数据类型包括 INTEGER、REAL、BOOLEAN、CHAR 和 STRING。算术运算符为 +、−、×、÷，DIV 和 MOD 用于整除与取余。比较运算符包括 =、≠、<、≤、>、≥。
Use ← for assignment. For example:
赋值使用 ←。例如：
x ← 10 y ← x × 2
Operator precedence follows BIDMAS, and parentheses should be used to make intent explicit.
运算符优先级遵循 BIDMAS，应使用括号明确意图。
3. Sequence, Selection and Iteration | 顺序、选择与迭代
The three building blocks of structured programming are sequence, selection, and iteration. Selection is expressed with IF…THEN…ELSE…ENDIF, and iteration with FOR, WHILE, or REPEAT…UNTIL loops.
A WHILE loop tests the condition before each iteration; a REPEAT loop tests it after, so the body always executes at least once.
WHILE 循环在每次迭代前测试条件；REPEAT 循环在循环体后测试，因此循环体至少执行一次。
In exams, you may be asked to convert one loop type to another or to identify the number of iterations.
考试中可能要求转换循环类型或确定迭代次数。
4. Arrays and Lists | 数组与列表
Arrays store multiple items of the same data type in indexed locations. In Edexcel pseudocode, a 1D array can be declared as ARRAY scores[0:9] OF INTEGER, and accessed with scores[3].
数组在索引位置存储同一数据类型的多个项目。在 Edexcel 伪代码中，一维数组可声明为 ARRAY scores[0:9] OF INTEGER，并通过 scores[3] 访问。
2D arrays are useful for tables and matrices, for example ARRAY grid[0:2][0:2] OF CHAR. Common operations include traversing, searching, inserting, and deleting elements.
二维数组适用于表格和矩阵，例如 ARRAY grid[0:2][0:2] OF CHAR。常见操作包括遍历、查找、插入和删除元素。
Be careful with 0-based indexing: the first element is index 0 in most pseudocode and real languages such as Python.
注意从 0 开始的索引：在大多数伪代码和真实语言（如 Python）中，第一个元素索引为 0。
5. Searching Algorithms: Linear and Binary Search | 查找算法：线性查找与二分查找
Linear search checks each element in order and works on unsorted data. Its worst-case time complexity is O(n).
线性查找按顺序检查每个元素，适用于未排序数据。最坏时间复杂度为 O(n)。
Binary search repeatedly halves a sorted array by comparing the middle element to the target. Its time complexity is O(log₂ n), so it is much faster for large sorted data sets.
You should be able to trace binary search on an array such as [2, 5, 8, 12, 16, 23, 38] and state the number of comparisons.
你应能对数组 [2, 5, 8, 12, 16, 23, 38] 跟踪二分查找过程并说明比较次数。
6. Sorting Algorithms: Bubble, Insertion and Merge Sort | 排序算法：冒泡、插入与归并排序
Bubble sort repeatedly swaps adjacent elements if they are in the wrong order. After each pass, the largest remaining value bubbles to its final position. Worst-case complexity is O(n²).
Insertion sort builds a sorted sublist by inserting each new element into its correct place. It is efficient for small or nearly sorted lists.
插入排序通过将每个新元素插入正确位置来构建有序子列表。对小型或接近有序的列表效率很高。
Merge sort uses divide and conquer: it splits the list into halves, recursively sorts them, then merges the two sorted halves. Its time complexity is O(n log₂ n).
Object-oriented programming (OOP) organises code into classes and objects. A class is a blueprint; an object is an instance with state (attributes) and behaviour (methods).
面向对象编程（OOP）将代码组织为类和对象。类是蓝图；对象是具有状态（属性）和行为（方法）的实例。
Key principles are encapsulation, inheritance, and polymorphism. Encapsulation hides internal data behind public methods; inheritance allows a subclass to reuse and extend a parent class; polymorphism lets objects respond differently to the same method call.
In pseudocode, you may define a class with a constructor, attributes, and methods, then instantiate objects using NEW.
在伪代码中，可定义包含构造函数、属性和方法的类，然后用 NEW 实例化对象。
9. File Handling and Exception Handling | 文件处理与异常处理
Programs often need to read from or write to text files. Typical operations are OPEN, READ, WRITE, and CLOSE, with modes such as READ, WRITE, and APPEND.
Edexcel expects you to identify possible exceptions in a given scenario and suggest appropriate handling.
Edexcel 希望你在给定情景中识别可能的异常并提出适当处理。
10. Programming Paradigms and IDEs | 编程范式与集成开发环境
A programming paradigm is a style of programming. The main paradigms are procedural, object-oriented, and functional. Edexcel focuses mainly on procedural and object-oriented approaches.
An Integrated Development Environment (IDE) provides a code editor, error diagnostics, run-time environment, and debugging tools such as breakpoints, step-through, and watch windows.
集成开发环境（IDE）提供代码编辑器、错误诊断、运行环境和调试工具，如断点、单步执行和监视窗口。
You should know how IDEs differ from simple text editors and how features such as syntax highlighting and auto-completion improve productivity.
你应了解 IDE 与简单文本编辑器的区别，以及语法高亮和自动补全等功能如何提高效率。
11. Trace Tables and Debugging | 跟踪表与调试
Trace tables are used to test an algorithm by recording variable values after each step. They are a common Edexcel assessment tool.
跟踪表通过记录每一步后的变量值来测试算法，是 Edexcel 常用的评估工具。
When completing a trace table, use one column per variable, include loop counters and condition results, and update values in sequence.
填写跟踪表时，为每个变量设一列，包括循环计数器和条件结果，并按顺序更新值。
Debugging involves identifying logic errors, runtime errors, and syntax errors. Logic errors are hardest to detect because the program runs but gives incorrect output.
调试包括识别逻辑错误、运行时错误和语法错误。逻辑错误最难检测，因为程序能运行但输出错误。
Common debugging strategies include dry-running code, inserting temporary OUTPUT statements, and using IDE breakpoints.
常见调试策略包括人工演算代码、插入临时 OUTPUT 语句和使用 IDE 断点。
12. Exam Technique for Edexcel Programming | Edexcel 编程考试技巧
In the exam, read the algorithm question carefully and underline inputs, outputs, and data structures before writing code.
考试时，仔细阅读算法题，并在编写代码前标出输入、输出和数据结构。
Always use the exact pseudocode style shown in the question, keep indentation consistent, and use comments only where they clarify the logic.
始终使用题目所示的伪代码风格，保持缩进一致，仅在能澄清逻辑处使用注释。
Check edge cases such as empty arrays, the first and last elements, and possible divisions by zero. If a question asks for efficiency, quote Big-O notation and justify the dominant term.
检查边界情况，如空数组、首尾元素和可能的除以零。若题目要求效率，请引用大 O 表示法并说明主导项。
Finally, practise coding every algorithm on paper and in Python so that you can move confidently between pseudocode and real code.
最后，在纸上和 Python 中练习每个算法，以便你能在伪代码和真实代码之间自如转换。
Published by TutorHao | Programming Revision Series | aleveler.com
📚 Edexcel A-Level Programming: Concepts, Techniques and Problem Solving | Edexcel A-Level 编程：概念、技巧与问题求解
Programming is at the heart of the Edexcel A-Level Computer Science specification. It involves applying computational thinking to design, write, test and refine code that solves real-world problems. Mastery of programming requires not only syntax but also an understanding of algorithms, data structures and the principles of structured design.
1. Computational Thinking and Problem Decomposition | 计算思维与问题分解
Computational thinking involves abstraction, decomposition and pattern recognition. Decomposition means breaking a large problem into smaller, manageable sub-problems that can be solved individually.
计算思维包括抽象、分解和模式识别。分解是指把一个大问题拆分成更小、更易管理的子问题，逐一解决。
Abstraction is the process of removing unnecessary detail so that only essential features remain. This is essential when modelling real-world systems in code.
抽象是去除不必要细节、只保留关键特征的过程。在用代码对现实系统建模时，这非常重要。
Pattern recognition identifies similarities between problems, allowing reuse of previous solutions. For example, many searching problems can use the same binary search pattern.
2. Variables, Data Types and Constants | 变量、数据类型与常量
Variables store data values that can change during execution; constants store values that remain fixed. Common data types include integer, real, Boolean, character and string.
Type casting is used to convert one data type into another, such as integer to string for concatenation.
类型转换用于把一种数据类型转换为另一种，例如将整型转换为字符串以便拼接。
Edexcel expects knowledge of type systems: strongly typed languages enforce type rules at compile time, while weakly typed languages allow implicit conversion.
3. Control Structures: Sequence, Selection and Iteration | 控制结构：顺序、选择与迭代
All programs are built from three control structures: sequence, selection and iteration. Selection uses IF, ELSE IF and ELSE statements; iteration uses FOR, WHILE and REPEAT UNTIL loops.
所有程序都由三种控制结构组成：顺序、选择和迭代。选择使用 IF、ELSE IF 和 ELSE 语句；迭代使用 FOR、WHILE 和 REPEAT UNTIL 循环。
A nested condition can model complex logic, but it may be replaced by a CASE statement to improve readability.
嵌套条件可以表达复杂逻辑，但可以用 CASE 语句替代以提高可读性。
Count-controlled loops repeat for a fixed number of iterations; condition-controlled loops repeat until a condition changes. A REPEAT UNTIL loop always executes at least once because the condition is tested at the end.
计数控制循环按固定次数重复；条件控制循环一直重复直到条件改变。REPEAT UNTIL 循环至少执行一次，因为条件在末尾测试。
FOR i = 1 TO 10 WHILE condition = TRUE REPEAT … UNTIL condition = TRUE
FOR i = 1 到 10；WHILE 条件为 TRUE；REPEAT … UNTIL 条件为 TRUE
4. Subroutines, Functions and Parameter Passing | 子程序、函数与参数传递
Subroutines are named blocks of code that can be called repeatedly. Functions return a value; procedures do not. Parameters can be passed by value or by reference.
子程序是可重复调用的命名代码块。函数返回值；过程不返回值。参数可以按值传递或按引用传递。
By value passes a copy of the data, so changes inside the subroutine do not affect the original argument. By reference passes the address, allowing the original value to be modified.
按值传递传递数据的副本，因此子程序内部的修改不会影响原始参数。按引用传递传递地址，允许修改原始值。
Local variables exist only inside a subroutine, reducing side effects and improving modularity. Global variables can be accessed from anywhere but increase the risk of unintended changes.
A recursive subroutine calls itself until a base case is reached. Each recursive call is placed on the call stack; if the base case is missing, stack overflow occurs.
Factorial is a classic example: factorial(n) = n × factorial(n − 1) with factorial(1) = 1.
阶乘是经典示例：factorial(n) = n × factorial(n − 1)，且 factorial(1) = 1。
factorial(n) = n × factorial(n − 1), with factorial(1) = 1
Recursion can lead to elegant solutions for tree traversals, sorting algorithms such as merge sort, and divide-and-conquer problems. However, it may be less memory-efficient than iteration because each call adds a stack frame.
6. Data Structures: Arrays, Records, Lists, Stacks and Queues | 数据结构：数组、记录、列表、栈与队列
Arrays store multiple values of the same data type in contiguous memory. Records store values of different types as fields. Lists are dynamic collections that can grow and shrink.
数组将相同数据类型的多个值存储在连续内存中。记录将不同类型的值存储为字段。列表是可动态增删的集合。
A two-dimensional array models a grid or matrix, such as a game board or pixel image. A record groups related fields, for example a student record with name, age and grade.
7. Object-Oriented Programming: Classes, Inheritance and Polymorphism | 面向对象编程：类、继承与多态
Object-oriented programming (OOP) organises code around objects that combine data and behaviour. A class is a blueprint from which objects are instantiated.
面向对象编程（OOP）围绕对象组织代码，对象结合了数据和行为。类是从中实例化对象的蓝图。
Inheritance allows a subclass to reuse and extend the methods and attributes of a superclass. Polymorphism lets the same method call behave differently on different objects.
继承允许子类复用并扩展超类的方法和属性。多态性使同一个方法调用在不同对象上产生不同行为。
Encapsulation hides internal state and requires interaction through public methods, protecting data integrity. Constructors initialise object attributes when an instance is created.
8. File Handling and Exception Handling | 文件处理与异常处理
Programs can read from and write to sequential or random access files. Opening a file requires a mode such as read, write or append. Always close files to release resources.
Sequential files are accessed line by line from the beginning; random access files allow direct movement to any record using a file pointer. Exception types include Input/Output errors, TypeError and ValueError.
9. Debugging, Testing and Trace Tables | 调试、测试与跟踪表
Debugging involves identifying and correcting errors: syntax errors, logic errors and runtime errors. A trace table tracks the values of variables as an algorithm executes, helping to locate logic errors.
Testing should use normal, boundary and erroneous data. For example, for an input range 0–100, boundaries are 0 and 100; erroneous data include −1 and 101.
Modern IDEs provide breakpoints, stepping, and variable watches to observe execution. Unit tests isolate individual subroutines to verify they return expected results for given inputs.
现代 IDE 提供断点、单步执行和变量监视等功能来观察执行过程。单元测试隔离单个子程序，验证其对给定输入返回预期结果。
Input
Expected
Type
50
Valid result
Normal
0
Valid lower bound
Boundary
-1
Rejected
Erroneous
表格示例：输入 50 为正常数据，输入 0 为下边界数据，输入 -1 为错误数据。
Published by TutorHao | Programming Revision Series | aleveler.com
Operators are the essential building blocks of almost every programming expression. They allow a programmer to perform calculations, compare values, combine logical conditions, and manipulate data at a low level. Understanding how operators behave, their precedence, and the differences between languages is a core part of A-Level programming and is tested frequently in Edexcel examinations.
In any programming language, an operator is a symbol or keyword that tells the computer to perform a specific operation on one or more operands. Operands can be variables, constants, literals, or more complex expressions. For example, in the expression a + b, the plus sign is the operator, while a and b are the operands.
在任何编程语言中，运算符都是一个符号或关键字，它告诉计算机对一个或多个操作数执行特定操作。操作数可以是变量、常量、字面量或更复杂的表达式。例如，在表达式 a + b 中，加号是运算符，而 a 和 b 是操作数。
Operators can be classified into several groups: arithmetic, comparison, logical, bitwise, assignment, and string operators. Each group has its own rules, and being able to classify and use operators correctly is a fundamental programming skill.
Arithmetic operators are used to perform mathematical calculations on numeric operands. The most common ones include addition (+), subtraction (−), multiplication (× or *), division (÷ or /), integer division (// or div), modulus (%), and exponentiation (** or ^ depending on the language). In many exam questions, you will need to evaluate expressions such as 7 % 3, which returns the remainder when 7 is divided by 3, so the result is 1. Integer division gives the whole-number part of a division, for example 17 // 5 gives 3.
Different languages may implement division differently, especially when both operands are integers. Python always returns a float for the single slash operator (/), while languages like Java and C return an integer if both operands are integers. This is a key point for Edexcel questions that compare pseudocode with real programming languages.
不同的语言对除法的实现可能不同，尤其是当两个操作数都是整数时。Python 的单斜杠运算符 (/) 总是返回浮点数，而 Java 和 C 等语言在两个操作数都是整数时返回整数。这是 Edexcel 题目中比较伪代码与真实编程语言时的一个关键点。
3. Comparison Operators | 比较运算符
Comparison operators, also called relational operators, compare two values and return a Boolean result: either true or false. Common comparison operators include equal to (= or == depending on language), not equal to (≠ or !=), less than (<), greater than (>), less than or equal to (≤ or <=), and greater than or equal to (≥ or >=). For example, if x = 5 and y = 10, then x < y evaluates to true, while x == y evaluates to false.
比较运算符（也称为关系运算符）比较两个值并返回布尔结果：真或假。常见的比较运算符包括等于 (= 或 ==，取决于语言)、不等于 (≠ 或 !=)、小于 (<)、大于 (>)、小于或等于 (≤ 或 <=) 以及大于或等于 (≥ 或 >=)。例如，如果 x = 5 且 y = 10，那么 x < y 的结果为真，而 x == y 的结果为假。
In programming, a single equals sign often means assignment, whereas a double equals sign (==) is used for comparison. This distinction is a frequent source of errors, especially for beginners and in trace table questions. Always check whether a statement is assigning a value or testing equality.
Logical operators combine Boolean expressions and produce a Boolean result. The three fundamental logical operators are AND, OR, and NOT. In many languages, AND is represented as && or and, OR as || or or, and NOT as ! or not. The AND operator returns true only if both operands are true. The OR operator returns true if at least one operand is true. The NOT operator reverses the Boolean value of its operand, so NOT true is false.
Truth tables are an essential tool for understanding logical operators. For instance, if p is true and q is false, then p AND q is false, p OR q is true, and NOT p is false. In exam questions, you may be asked to construct a truth table for a compound condition.
真值表是理解逻辑运算符的重要工具。例如，如果 p 为真且 q 为假，那么 p AND q 为假，p OR q 为真，而 NOT p 为假。在考试题中，你可能会被要求为一个复合条件构造真值表。
5. Bitwise Operators | 位运算符
Bitwise operators work on the binary representations of integers, treating each bit separately. The most common bitwise operators are AND (&), OR (|), XOR (^), NOT (~), left shift (<<), and right shift (>>). For example, the bitwise AND of 12 (binary 1100) and 10 (binary 1010) is 1000, which is 8 in decimal. Bitwise shifts multiply or divide by powers of two: shifting left by 1 bit doubles an integer, while shifting right by 1 bit halves it using integer division.
These operators are often tested in Edexcel A-Level questions about low-level programming and efficiency. They are also useful for tasks such as setting or clearing specific bits in a binary flag system.
The assignment operator is used to store a value in a variable. In most languages, the assignment operator is a single equals sign (=). For example, the statement total = price + tax calculates the expression on the right-hand side and stores the result in the variable total. It is important to remember that assignment is not an equation: the left-hand side must be a variable, and the process is directional (right to left).
赋值运算符用于将值存储到变量中。在大多数语言中，赋值运算符是一个等号 (=)。例如，语句 total = price + tax 计算右侧的表达式并将结果存储在变量 total 中。重要的是要记住，赋值不是等式：左侧必须是一个变量，而且过程是有方向的（从右到左）。
Some languages also support multiple assignment or chained assignment, such as a = b = c = 0. In pseudocode, the assignment operator is often written as a left arrow (←) to make the direction clearer, but Edexcel papers usually accept an equals sign when using common coding practice.
一些语言还支持多重赋值或链式赋值，例如 a = b = c = 0。在伪代码中，赋值运算符通常写成左箭头 (←) 以使方向更清晰，但 Edexcel 试卷在使用常见编码实践时通常接受等号。
7. Compound Assignment Operators | 复合赋值运算符
Compound assignment operators combine an arithmetic or bitwise operation with assignment, making code shorter and often clearer. Examples include +=, −=, *=, /=, %=, &=, |=, and ^=. The expression x += 5 is equivalent to x = x + 5. Similarly, y *= 2 means y = y * 2.
复合赋值运算符将算术或位运算与赋值结合起来，使代码更简短且通常
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
Edexcel A-Level Computer Science programming components require more than just writing code; they test algorithmic thinking, understanding of theoretical concepts, and the ability to trace and evaluate code under exam conditions. This guide covers the essential content for the Edexcel A-Level programming paper, including programming paradigms, control structures, data structures, algorithms, and exam technique.
1. Understanding the Edexcel Programming Component | 理解 Edexcel 编程部分
In Edexcel A-Level Computer Science, programming is assessed mainly in Paper 1: Principles of Computer Science. The questions often use pseudocode or a high-level language such as Python, Java or C#, and you are expected to read, trace, modify and write code.
在 Edexcel A-Level 计算机科学中，编程主要在 Paper 1：计算机科学原理 中考查。题目通常使用伪代码或 Python、Java、C# 等高级语言，要求考生能够阅读、跟踪、修改和编写代码。
The specification emphasises computational thinking: abstraction, decomposition, pattern recognition and algorithm design. These skills are tested through problem-solving scenarios rather than isolated syntax questions.
You must be familiar with standard notation such as assignment (←), comparison (=, ≠, <, >, ≤, ≥), and logical operators (AND, OR, NOT). Trace tables are a common way to test your ability to follow code step by step.
Edexcel expects you to understand different programming paradigms, especially procedural, object-oriented and declarative. Procedural programming focuses on a sequence of instructions grouped into procedures or functions.
Object-oriented programming (OOP) organises code around objects that combine state (attributes) and behaviour (methods). Key concepts include encapsulation, inheritance, polymorphism and abstraction.
Declarative programming states what the result should be rather than how to compute it. SQL and functional languages like Haskell are examples, but at A-Level you mainly need to recognise the difference.
Procedural: code organised into functions, focusing on sequence.
过程式：代码组织为函数，侧重于顺序执行。
Object-oriented: objects with attributes and methods, promoting reuse.
面向对象：对象具有属性和方法，促进复用。
Declarative: describes the desired result, not step-by-step control flow.
声明式：描述期望结果，而非逐步控制流。
3. Variables, Data Types, and Operators | 变量、数据类型与运算符
Choosing the correct data type is essential. Edexcel questions may ask you to identify appropriate types for given data, such as integer, real/float, Boolean, character and string.
Operators include arithmetic (+, −, ×, ÷, MOD, DIV), relational (=, ≠, <, >, ≤, ≥), and logical (AND, OR, NOT). You should know operator precedence and how to use brackets to clarify expressions.
Constants and literals must be distinguished from variables. A constant is assigned once and cannot change, while a variable can be updated during execution.
常量和字面量必须与变量区分开来。常量只能赋值一次且不可更改，而变量在执行过程中可以更新。
4. Selection and Iteration | 选择与迭代
Selection uses IF…THEN…ELSE statements to choose between paths. Edexcel pseudocode often uses IF…ELSE IF…ELSE and CASE/SWITCH statements.
Iteration includes definite loops (FOR) and indefinite loops (WHILE, REPEAT…UNTIL). You must be able to convert between iterative structures and understand when a loop terminates.
Nested selection and nested iteration often appear in trace table questions. Keep careful track of each variable and the condition being evaluated.
嵌套选择和嵌套迭代经常出现在跟踪表问题中。要仔细跟踪每个变量和正在评估的条件。
FOR i ← 1 TO 10 IF i MOD 2 = 0 THEN OUTPUT i
5. Functions, Procedures, and Recursion | 函数、过程与递归
A procedure is a named block of code that performs a task but does not return a value. A function returns a value and can be used in expressions.
过程是执行任务但不返回值的命名代码块。函数返回一个值，并可用于表达式中。
Parameters can be passed by value or by reference. By value passes a copy, so changes do not affect the original variable. By reference passes the memory address, allowing changes to propagate.
Recursion is a technique where a function calls itself. Each recursive call must have a base case to stop, otherwise it causes stack overflow. Edexcel often asks you to trace recursive functions.
FUNCTION factorial(n) IF n = 0 THEN RETURN 1 ELSE RETURN n × factorial(n − 1)
6. Data Structures: Arrays, Lists, and Records | 数据结构：数组、列表与记录
Arrays store a fixed number of elements of the same data type, accessed by index. In many languages, indexing starts at 0, but Edexcel pseudocode sometimes uses 1-based indexing; always check the question.
Lists (or dynamic arrays) can grow and shrink, allowing insertion and deletion. Understanding the difference between static and dynamic structures is important.
列表（或动态数组）可以增长和缩小，允许插入和删除。理解静态和动态结构之间的区别很重要。
Records (or structs) combine fields of different data types into a single entity, useful for modelling real-world objects like a student record with name, age and grade.
Array: fixed size, same data type, direct access via index.
数组：固定大小，相同数据类型，通过索引直接访问。
List: dynamic size, supports insertion and deletion.
列表：动态大小，支持插入和删除。
Record: heterogeneous fields grouped together.
记录：将不同类型字段组合在一起。
7. File Handling and Exception Handling | 文件处理与异常处理
File handling enables programs to read from and write to external files. Common operations include open, read, write, close, and checking for end-of-file.
文件处理使程序能够从外部文件读取和写入。常见操作包括打开、读取、写入、关闭以及检查文件结束。
Text files store human-readable characters, while binary files store data in machine-readable form. Edexcel questions may ask about the advantages and disadvantages of each.
Exception handling uses TRY…EXCEPT…FINALLY to manage runtime errors such as file not found, division by zero, or invalid input. This makes programs robust and prevents crashes.
Object-oriented programming (OOP) is not just a standalone topic; it underpins the Edexcel A-Level programming project, pseudocode interpretation and many theory questions. A strong grasp of classes, objects, inheritance, encapsulation and polymorphism allows you to model real-world systems and write code that is easier to test, reuse and maintain.
Edexcel examination papers frequently ask candidates to compare procedural and object-oriented approaches. In procedural programming, data and functions are often separate, whereas in OOP a class combines both data and the operations that act on that data.
This shift makes large programs easier to debug, extend and test because each object manages its own state and exposes a controlled interface to the rest of the system.
A class is a blueprint or template that defines the attributes and methods common to a group of objects. An object is a specific instance created from that class, with its own attribute values.
类是定义一组对象共有属性和方法的蓝图或模板。对象是从类创建的具体实例，拥有自己的属性值。
For example, a class Student may define attributes such as name, score and email, while each object represents one particular student with distinct data.
Attributes store an object’s data, while methods define the behaviour that an object can perform. In Python, you normally define them inside a class and use self to refer to the current instance.
You must be able to distinguish instance attributes, which belong to one object, class attributes, which are shared by all objects, and local variables, which exist only inside a method.
A common exam mistake is to write name instead of self.name inside a method, which creates or reads a local variable rather than the object’s attribute.
常见的考试错误是在方法内部使用 name 而不是 self.name，这会创建或读取局部变量，而不是对象的属性。
4. Encapsulation and Access Modifiers | 封装与访问修饰符
Encapsulation means hiding the internal state of an object and only allowing controlled access through methods. This prevents external code from changing attributes in invalid ways.
封装是指隐藏对象的内部状态，只允许通过方法进行受控访问。这可以防止外部代码以无效方式更改属性。
In Python, encapsulation is mostly achieved by convention: a single underscore such as _balance signals protected data, while a double underscore such as __password triggers name mangling to discourage direct access.
Although Python does not strictly enforce private access, Edexcel questions may still expect you to explain the purpose of access modifiers and how they reduce coupling between classes.
A constructor is a special method that is automatically called when an object is created. In Python, the constructor is named __init__ and is used to set up initial attribute values.
You should be able to write constructors with default parameters, validate inputs inside the constructor, and avoid calling methods before the object has been fully initialised.
你应该能够编写带默认参数的构造函数，在构造函数内部验证输入，并避免在对象完全初始化之前调用方法。
For example, def __init__(self, name, score=0) allows a Student object to be created with a default score when no value is supplied.
Inheritance allows a child class to reuse and extend the attributes and methods of a parent class. The child can also override inherited methods by defining a method with the same name.
继承允许子类复用并扩展父类的属性和方法。子类还可以通过定义同名方法来重写继承的方法。
In Edexcel pseudocode, inheritance is often shown with an arrow from the child class to the parent class, or using keywords such as inherits or extends.
A typical exam scenario may ask you to explain why a SavingsAccount class can inherit from BankAccount and override the withdraw method to check a minimum balance.
Polymorphism means “many forms”. In OOP, it allows the same method name to be called on different objects, with each object responding according to its own class definition.
This is often achieved through method overriding. For instance, a Shape parent class may define a calculateArea method, and both Circle and Rectangle can override it with their own formulas.
Edexcel mark schemes reward precise statements such as “the correct method is resolved at runtime based on the object’s class”.
Edexcel 评分标准鼓励精确的表述，例如“正确的方法在运行时根据对象的类来确定”。
8. Aggregation and Composition | 聚合与组合
Aggregation is a “has-a” relationship in which one object holds a reference to another object, but the contained object can exist independently.
聚合是一种“拥有”关系，其中一个对象持有对另一个对象的引用，但被包含的对象可以独立存在。
Composition is a stronger “has-a” relationship where the contained object is created and destroyed as part of the container object.
组合是一种更强的“拥有”关系，被包含的对象作为容器对象的一部分被创建和销毁。
For example, a School object may aggregate many Student objects because students can exist even if the school closes, while a Car object is composed of an Engine object that has no separate purpose.
例如，School 对象可以聚合多个 Student 对象，因为即使学校关闭，学生仍然存在；而 Car 对象由 Engine 对象组成，该发动机没有独立用途。
9. UML Class Diagrams | UML 类图
Unified Modelling Language (UML) class diagrams are a standard way to show class names, attributes, methods and relationships. Edexcel may ask you to interpret or draw a simple class diagram.
Accessible in the class and its subclasses | 可在类及其子类中访问
Solid line with hollow triangle | 带空心三角形的实线
Inheritance | 继承
Solid line with diamond | 带菱形的实线
Composition | 组合
When drawing UML, always separate the class name, attribute list and method list into three clearly labelled compartments.
绘制 UML 时，始终将类名、属性列表和方法列表分成三个清晰标注的区域。
10. Common Exam Pitfalls and Tips | 常见考试失分点与技巧
Many candidates lose marks by confusing a class with an object, or by writing vague definitions such as “OOP makes code nice” instead of using technical terms from the specification.
Always trace code carefully when inheritance and polymorphism are involved. Write down the object’s class, which method is called, and what the output should be before selecting an answer.
在涉及继承和多态时，务必仔细跟踪代码。先写出对象的类、调用了哪个方法以及预期输出，然后再选择答案。
Use the correct spelling and syntax for __init__, self and class names in Python responses.
Distinguish between overriding and overloading; Edexcel focuses mainly on overriding in OOP.
Practise converting real-world descriptions into class diagrams and vice versa.
Programming is the core skill tested across Edexcel A-Level Computer Science, especially in the on-screen examination and the programming project. This guide brings together the fundamental techniques you need, including data representation, control flow, recursion, data structures, searching and sorting, object-oriented design, and algorithm analysis.
1. Computational Thinking and Problem Decomposition | 计算思维与问题分解
Computational thinking means approaching a problem in a way that a computer can execute. It involves abstraction, which removes unnecessary detail; decomposition, which breaks a large problem into manageable parts; pattern recognition, which identifies similarities; and algorithm design, which specifies step-by-step instructions.
计算思维意味着以计算机能够执行的方式来处理问题。它包括抽象（去除不必要的细节）、
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
📚 Object-Oriented Programming for Edexcel A-Level | Edexcel A-Level 面向对象编程精讲
Object-oriented programming (OOP) is a central topic in the Edexcel A-Level Computer Science specification. It shifts the focus from a sequence of instructions to modelling real-world entities as objects that contain both data and behaviour. Understanding OOP is essential for Paper 2 programming questions and for designing maintainable software systems.
面向对象编程（OOP）是爱德思 A-Level 计算机科学考试大纲中的核心主题。它将编程的关注点从指令序列转移到把现实世界的实体建模为同时包含数据与行为的对象。理解 OOP 对于 Paper 2 编程题以及设计可维护的软件系统至关重要。
1. Programming Paradigms | 编程范式
A programming paradigm is a fundamental style of programming. The main paradigms examined by Edexcel are procedural, object-oriented, and event-driven programming. Each paradigm organises code differently and suits different types of problem.
Procedural programming breaks a problem into procedures or functions that manipulate shared data. It is straightforward but can become hard to maintain as a project grows because data and functions are separate.
Object-oriented programming bundles data and the methods that operate on that data into classes. This encapsulation makes large systems easier to model, extend, and debug.
面向对象编程将数据以及操作这些数据的方法捆绑到类中。这种封装使得大型系统更易于建模、扩展和调试。
Event-driven programming responds to user actions such as clicks and key presses. It is often used in graphical user interfaces, where the flow of execution is determined by events rather than a fixed sequence.
A class is a blueprint or template that defines the attributes and methods shared by a group of objects. An object is a specific instance of a class, created from that blueprint with its own state.
类是定义一组对象共同属性和方法的蓝图或模板。对象是类的具体实例，根据该蓝图创建并拥有自己的状态。
For example, a class Car might have attributes such as colour, engineSize, and registration, and methods such as accelerate() and brake(). A particular object myCar could be a red car with a 1.6-litre engine.
In most languages, a class is declared using the keyword class, and an object is created by calling a special method called a constructor. The constructor initialises the object’s attributes.
在大多数语言中，类使用关键字 class 声明，对象通过调用称为构造函数的特殊方法来创建。构造函数负责初始化对象的属性。
3. Encapsulation | 封装
Encapsulation is the practice of hiding the internal state of an object and requiring all interaction to occur through public methods. This protects data from accidental corruption and makes the class easier to change without affecting the rest of the program.
Attributes are typically declared as private, meaning they can only be accessed within the class. Public getter and setter methods allow controlled read and write access. In Python, privacy is indicated by a single underscore convention, whereas Java uses the private keyword.
A bank account class demonstrates encapsulation: the balance is private, and deposits must go through a deposit() method that validates the amount. Directly setting account.balance = -100 would be prevented in a well-encapsulated design.
Inheritance allows a new class to be based on an existing class. The new class, called a subclass or derived class, inherits the attributes and methods of the parent class, known as the superclass or base class. This promotes code reuse.
A subclass can add its own attributes and methods, and it can also override inherited methods to provide specialised behaviour. For example, a SportsCar
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
In Edexcel A-Level Computer Science, operators are symbols that tell a program to perform specific actions on one or more operands. Understanding operators and expression evaluation is essential for writing correct pseudocode, predicting output, and answering Paper 2 programming questions.
在 Edexcel A-Level 计算机科学中，运算符是告诉程序对一个或多个操作数执行特定动作的符号。理解运算符和表达式求值对于写出正确的伪代码、预测输出以及回答 Paper 2 编程题至关重要。
1. Operator Basics | 运算符基础
An operator is a symbol that carries out a calculation or comparison. An operand is the value the operator acts on. An expression combines operators and operands to produce a single value. For example, in 3 + 5, + is the operator and 3, 5 are operands. Edexcel expects you to classify operators by category and apply them in pseudocode and a high-level language such as Python.
There are five main categories of operators you need to know: arithmetic, relational, Boolean, assignment, and string operators. Each category has its own rules, but they all follow the same principle of taking inputs and returning an output value.
Arithmetic operators perform mathematical calculations. The main arithmetic operators are addition (+), subtraction (−), multiplication (*), real division (/), integer division (DIV or //), and modulus (MOD or %). These are used constantly in algorithms for totals, averages, remainders and indexing.
When a question asks for integer division or remainder, do not use real division. In pseudocode, write DIV and MOD clearly. In Python, use // for integer division and % for modulus.
当题目要求整除或求余数时，不要使用实数除法。在伪代码中，清楚地写出 DIV 和 MOD。在 Python 中，使用 // 进行整除，使用 % 取模。
3. Integer Division and Modulus | 整除与取模
DIV gives the whole-number quotient when one integer is divided by another, while MOD gives the remainder. These are especially useful in problems involving groups, cycles, digits, and array indexing. For example, 17 DIV 5 = 3 and 17 MOD 5 = 2 because 17 = 5 × 3 + 2. Many exam questions ask you to trace MOD in loops for even/odd detection or circular buffers.
DIV 给出两个整数相除时的整数商，而 MOD 给出余数。它们在涉及分组、循环、数字和数组索引的问题中特别有用。例如，17 DIV 5 = 3，17 MOD 5 = 2，因为 17 = 5 × 3 + 2。许多考试题要求你在循环中跟踪 MOD，用于判断奇偶或循环缓冲区。
n MOD 2 = 0 → even; n MOD 2 = 1 → odd
A classic exam scenario is extracting the last digit of an integer: lastDigit ← number MOD 10. To remove the last digit, use number ← number DIV 10. This is the basis for digit-sum algorithms and base conversion.
一个经典的考试场景是提取整数的最后一位：lastDigit ← number MOD 10。要移除最后一位，使用 number ← number DIV 10。这是数字求和算法和进制转换的基础。
4. Relational and Comparison Operators | 关系与比较运算符
Relational operators compare two values and return a Boolean result: TRUE or FALSE. The six common operators are =, ≠, <, >, ≤, ≥. In Edexcel pseudocode, you may see =, <>, <, >, <=, >=. These operators are used in conditions for IF statements, WHILE loops, and REPEAT loops.
Remember that a comparison produces a Boolean value, not a number. For example, 5 > 3 evaluates to TRUE, and you can assign that result to a Boolean variable.
Boolean operators combine or invert Boolean values. The three fundamental operators are AND, OR, and NOT. Their truth tables are essential. AND returns TRUE only when both operands are TRUE. OR returns TRUE when at least one operand is TRUE. NOT reverses a single Boolean value.
Compound conditions such as age >= 18 AND passed = TRUE require both parts to be true. In Python, write and, or, not in lowercase. In pseudocode, use AND, OR, NOT.
复合条件如 age >= 18 AND passed = TRUE 要求两个部分都为真。在 Python 中，使用小写的 and、or、not。在伪代码中，使用 AND、OR、NOT。
6. String Concatenation | 字符串连接
Concatenation joins strings end-to-end. In Edexcel pseudocode and Python, the plus sign + is often used. For example, “Hello” + ” ” + “World” produces “Hello World”. However, some pseudocode styles use the & operator or explicit CONCATENATE. You must know that mixing a string and an integer normally causes a type error unless the integer is converted first.
name ← “Alice” age ← 17 output ← name + ” is ” + str(age)
When concatenating numeric variables into strings, use a conversion function such as str() in Python or INT_TO_STRING in pseudocode. Similarly, convert strings to numbers with int() or float() before arithmetic.
The assignment operator stores a value in a variable. Edexcel pseudocode uses the left arrow ←, while Python uses =. Compound assignment combines an arithmetic operation with assignment, such as +=, -=, *=, /=. For example, total ← total + score is equivalent to total += score.
赋值运算符将值存储到变量中。Edexcel 伪代码使用左箭头 ←，而 Python 使用 =。复合赋值将算术运算与赋值结合起来，例如 +=、-=、*=、/=。例如，total ← total + score 等价于 total += score。
count ← 0 count ← count + 1 count += 1
Do not confuse assignment with equality. In Python, = assigns a value, while == tests equality. In pseudocode, ← assigns and = tests equality. This is one
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
📚 A-Level Edexcel Programming: Core Constructs, Data Structures and Algorithms | A-Level Edexcel编程：核心构造、数据结构与算法
This revision guide covers the programming topics examined in Edexcel A-Level Computer Science, including data types, control structures, subprograms, recursion, data structures, searching, sorting, algorithm efficiency, object-oriented programming, error handling and the use of IDEs.
1. Data Types, Variables and Constants | 数据类型、变量与常量
Data types determine how a value is stored and what operations are allowed. Edexcel questions expect candidates to identify integer, real/float, Boolean, character and string types.
A variable can change during program execution, but a constant is assigned once and cannot be modified. Constants make programs easier to understand and maintain.
变量在程序执行期间可以改变，但常量只能在赋值后保持不变。常量使程序更易于理解和维护。
Implicit or explicit type casting may be needed when different data types are combined in calculations or assignments.
当不同数据类型在计算或赋值中组合时，可能需要进行隐式或显式类型转换。
2. Operators and Expressions | 运算符与表达式
Arithmetic operators in Edexcel pseudocode include +, -, *, /, MOD and DIV. The MOD operator gives the remainder, while DIV gives the integer quotient.
Relational operators compare values: =, ≠, <, >, ≤ and ≥. The result of a comparison is always a Boolean value.
关系运算符用于比较值：=、≠、<、>、≤ 和 ≥。比较的结果总是布尔值。
Boolean operators AND, OR and NOT combine logical expressions. AND is true only when both operands are true; OR is true when at least one operand is true; NOT reverses the Boolean value.
布尔运算符 AND、OR 和 NOT 用于组合逻辑表达式。AND 仅在两个操作数都为真时为真；OR 在至少一个操作数为真时为真；NOT 反转布尔值。
Operator precedence matters: NOT is evaluated before AND, and AND before OR. Brackets can be used to force a different order.
运算符优先级很重要：NOT 先于 AND 计算，AND 先于 OR 计算。括号可用来强制改变计算顺序。
String expressions often use concatenation, joining two strings into one, for example “rain” + “bow” produces “rainbow”.
Sequence means statements are executed one after another in the order written. It is the default flow of control.
顺序结构表示语句按书写顺序逐条执行，这是默认的控制流程。
Selection allows the program to choose between branches using IF … THEN … ELSE … ENDIF or a CASE statement for multiple options.
选择结构允许程序使用 IF … THEN … ELSE … ENDIF 或 CASE 语句在多个选项之间进行分支。
An IF condition can be nested inside another IF to model complex decisions. Indentation makes nested logic easier to read.
IF 条件可以嵌套在另一个 IF 中，以建立复杂决策。缩进使嵌套逻辑更易阅读。
Iteration repeats a block of code. A FOR loop is definite because the number of repetitions is known in advance, while a WHILE loop repeats as long as a condition is true.
迭代结构重复执行一段代码。FOR 循环是确定循环，因为重复次数事先已知；而 WHILE 循环在条件为真时反复执行。
A REPEAT … UNTIL loop checks the condition after the loop body, so it always runs at least once.
REPEAT … UNTIL 循环在循环体之后检查条件，因此至少会执行一次。
4. Subprograms: Procedures and Functions | 子程序：过程与函数
A function returns a value and can be used inside an expression, whereas a procedure performs an action but does not return a value.
函数返回一个值，可用于表达式中；而过程执行一个动作但不返回值。
Parameters allow data to be passed into subprograms. Passing by value gives the subprogram a copy, so changes inside do not affect the original variable. Passing by reference uses the original memory location, so changes are visible outside.
Local variables are declared inside a subprogram and are accessible only there, while global variables are available throughout the program. Overuse of global variables can make debugging harder.
Modular programming breaks a problem into small, reusable subprograms. This improves readability, testing and team development.
模块化编程将问题分解为小型、可复用的子程序。这提高了可读性、可测试性和团队开发效率。
5. Recursion and Base Cases | 递归与基准情形
A recursive subprogram calls itself to solve a smaller instance of the same problem. Every recursion must have a base case that stops the chain.
递归子程序调用自身来解决同一问题的较小实例。每个递归必须有一个基准情形来终止调用链。
Without a correct base case, recursion continues until the call stack overflows, causing a runtime error. The base case is usually the simplest possible input.
如果没有正确的基准情形，递归会一直持续到调用栈溢出，导致运行时错误。基准情形通常是最简单的输入。
A classic example is factorial, defined recursively as shown below.
一个经典示例是阶乘，其递归定义如下所示。
n! = n × (n – 1)! for n > 1, 1! = 1
Each recursive call is pushed onto the call stack, and the stack unwinds when the base case returns. Recursion can be elegant, but iterative solutions may use less memory.
每次递归调用都被压入调用栈，当基准情形返回时栈会展开。递归可以很简洁，但迭代解法可能使用更少内存。
6. Arrays, Lists and Records | 数组、列表与记录
An array is a static, indexed collection of elements of the same data type. A one-dimensional array stores a single list, while a two-dimensional array can represent a table or matrix.
数组是静态的、按索引访问且元素类型相同的集合。一维数组存储单个列表，二维数组可以表示表格或矩阵。
Indexing in Edexcel pseudocode may start at 0 or 1 depending on the question, so always read the question carefully before writing algorithms.
Edexcel伪代码中的索引可能从0或1开始，具体取决于题目，因此编写算法前必须仔细读题。
A list is a dynamic data structure that can grow or shrink after creation. Unlike static arrays, lists allow insertion and deletion without re-declaring the whole structure.
A record stores related fields of different data types under one name, similar to a row in a database. For example, a Student record could hold name, age and grade.
Linear search examines each element in turn until the target is found or the end is reached. It works on unsorted data and has worst-case time complexity O(n).
线性查找依次检查每个元素，直到找到目标或到达末尾。它适用于未排序数据，最坏时间复杂度为 O(n)。
Binary search repeatedly halves a sorted list by comparing the target with the middle element, giving average and worst-case complexity O(log n).
二分查找通过将目标与中间元素比较，不断将有序列表对半分，平均和最坏时间复杂度为 O(log n)。
The list must be sorted before a binary search can be used; otherwise the result is unreliable. Binary search is much faster than linear search on large data sets.
使用二分查找前，列表必须已排序；否则结果不可靠。在大型数据集上，二分查找比线性查找快得多。
The table below summarises the two searching methods.
下表总结了两种查找方法。
Algorithm (算法)
Requirement (前提)
Worst-case (最坏情况)
Linear search (线性查找)
None (无需排序)
O(n)
Binary search (二分查找)
Sorted list (有序列表)
O(log n)
8. Sorting Algorithms | 排序算法
Bubble sort compares adjacent pairs and swaps them if they are in the wrong order, repeating passes until no swaps are needed. Its worst-case time complexity is O(n²).
冒泡排序比较相邻元素并在顺序错误时交换，重复多趟直到不再需要交换。其最坏时间复杂度为 O(n²)。
Insertion sort builds a sorted prefix by inserting each new element into its correct position within that prefix. It is efficient for small or nearly sorted data sets.
Merge sort splits the list recursively into halves, sorts each half, and merges the sorted halves. It has O(n log n) time complexity but requires additional memory for merging.
Edexcel questions often ask candidates to trace one pass of a sort or compare the efficiency of two sorting algorithms.
Edexcel题目经常要求考生跟踪排序的一趟过程，或比较两种排序算法的效率。
9. Algorithm Efficiency and Big O Notation | 算法效率与Big O记号
Big O notation describes the upper bound of how time or space grows as the input size n increases. It focuses on the dominant term and ignores constant factors.
Big O记号描述随着输入规模 n 增大，时间或空间增长的上界。它关注主导项并忽略常数因子。
Common complexities and their meanings are shown in the table below.
📚 Edexcel A-Level Programming Essentials: Data Types, Control Flow and OOP | Edexcel A-Level 编程核心精要：数据类型、控制流与面向对象
The Edexcel A-Level Computer Science specification expects you to apply programming techniques in a high-level language such as Python or pseudocode. The assessment rewards clarity, efficiency, and correct use of programming constructs rather than memorising syntax.
1. Programming Paradigms and the Edexcel Syllabus | 编程范式与 Edexcel 考纲
Programming questions often give a scenario and ask you to design, trace, or amend an algorithm. You should be comfortable with variables, control structures, data structures, and object-oriented concepts.
Edexcel uses a pseudocode style that is deliberately close to Python. You are not expected to memorise every command, but you must express algorithms unambiguously and consistently.
Primitive data types include integer, real/float, Boolean, character, and string. Choosing the right type affects memory use and operations; for example, 7/2 gives 3.5 in real division but may differ in integer division.
Constants are identifiers whose value cannot change after assignment. Using named constants improves maintainability and reduces magic numbers in code.
常量是在赋值后值不能改变的标识符。使用命名常量可以提高代码的可维护性，并减少程序中出现的魔法数字。
Integer: whole numbers, e.g. 5, -3, 0 — 整数：如 5、-3、0。
Real/float: decimal numbers, e.g. 3.14 — 实数/浮点数：如 3.14。
Boolean: True or False — 布尔值：True 或 False。
String: sequence of characters, e.g. “A-Level” — 字符串：字符序列，如 “A-Level”。
3. Sequence, Selection and Iteration | 顺序、选择与迭代
Sequence is the default order in which statements execute line by line. Selection uses if, elif, and else to branch based on Boolean conditions. Iteration repeats a block using for loops or while loops.
顺序结构是语句默认按行逐一执行的顺序。选择结构使用 if、elif 和 else 根据布尔条件进行分支。迭代结构使用 for 循环或 while 循环重复执行一个代码块。
A common exam error is treating while loops as if they automatically update the loop counter. You must explicitly modify the condition variable, or the loop may become infinite.
一个常见的考试错误是认为 while 循环会自动更新循环计数器。你必须显式修改条件变量，否则循环可能变成无限循环。
For loops are ideal when the number of iterations is known in advance. While loops are better when repetition depends on a condition that may change during execution.
for 循环适合在迭代次数已知时使用。while 循环更适合循环依赖某个在执行过程中可能改变的条件。
4. Subroutines: Procedures and Functions | 子程序：过程与函数
Subroutines break a program into named blocks of code. A function returns a value, while a procedure performs an action without returning a value. Parameters allow data to be passed in, and local variables keep the subroutine self-contained.
When tracing subroutines, track parameter passing and return values carefully. In Edexcel pseudocode, parameters are usually passed by value, so changes inside the subroutine do not affect the original argument.
Using subroutines makes programs modular, easier to test, and easier to reuse. Exam questions may ask you to complete a subroutine or explain the difference between a procedure and a function.
Recursion is a technique where a subroutine calls itself. A recursive algorithm must have a base case to stop, and a recursive case that reduces the problem towards the base case.
The call stack stores return addresses, parameters, and local variables for each recursive call. Too many recursive calls can cause a stack overflow error.
调用栈存储每次递归调用的返回地址、参数和局部变量。过多的递归调用会导致栈溢出错误。
Common examples include factorial, Fibonacci, binary search, and tree traversal. A-level questions often ask you to trace a recursive function and identify the base case.
Arrays are fixed-size collections of elements of the same data type, indexed from 0 in most languages. Lists are dynamic and can store mixed data types in Python.
Two-dimensional arrays can model grids, matrices, and game boards. Trace carefully using row, column indices and ensure you do not confuse rows and columns.
二维数组可以模拟网格、矩阵和游戏棋盘。跟踪时要仔细使用行、列索引，并确保不会混淆行和列。
Array: fixed length, same data type — 数组：固定长度，相同数据类型。
List: dynamic length, mixed types — 列表：动态长度，混合类型。
2D array: accessed by row and column — 二维数组：通过行和列访问。
7. Stacks and Queues | 栈与队列
A stack is a last-in, first-out (LIFO) structure. Common operations are push (add), pop (remove), and peek (inspect top). Stacks are used for backtracking, undo features, and call stacks.
A queue is a first-in, first-out (FIFO) structure. Operations include enqueue (add to rear) and dequeue (remove from front). Queues are used in scheduling and buffering.
Questions may ask you to show the state of a stack or queue after a sequence of operations. Always draw the contents in the correct order, with the top or front clearly indicated.
题目可能要求你展示经过一系列操作后栈或队列的状态。务必按正确顺序画出内容，并清楚标出栈顶或队首。
8. Searching Algorithms | 查找算法
Linear search checks every element in order and is simple but has O(n) worst-case time complexity. Binary search requires a sorted list and repeatedly halves the search interval, giving O(log n) complexity.
In exams, binary search is commonly traced using low, high, and mid pointers. Always check the terminating condition and what happens when the target is not found.
If the target is greater than the middle value, the search continues in the upper half; if smaller, in the lower half.
如果目标值大于中间值，则在右半部分继续查找；如果小于中间值，则在左半部分继续查找。
9. Sorting Algorithms | 排序算法
Bubble sort repeatedly compares adjacent items and swaps them if out of order. It is easy to understand but has O(n²) worst-case complexity. Insertion sort builds a sorted portion incrementally and also has O(n²) worst-case complexity, but performs well on nearly sorted data.
Merge sort and quicksort are more efficient divide-and-conquer algorithms, with average O(n log n) time. Edexcel mainly expects you to trace and compare sorting methods rather than implement complex versions.
When comparing algorithms, mention time complexity, space complexity, stability, and whether the algorithm is adaptive. For example, bubble sort is stable but inefficient on large datasets.
10. Object-Oriented Programming: Classes and Inheritance | 面向对象编程：类与继承
Object-oriented programming (OOP) organises code using classes and objects. A class is a blueprint that defines attributes (data) and methods (behaviour). An object is an instance of a class.
Inheritance lets a subclass reuse and extend the functionality of a superclass. Polymorphism allows methods with the same name to behave differently depending on the object. Encapsulation hides internal state and exposes only necessary methods.
In Edexcel questions, you may be asked to interpret a UML class diagram or write a simple class definition. Focus on clarity of attributes, constructor, and methods.
Inheritance: reuse code from a superclass — 继承：重用超类的代码。
Polymorphism: same method name, different behaviour — 多态性：同名方法，不同行为。
11. File Handling and Exception Management | 文件处理与异常管理
File handling involves opening, reading, writing, and closing files. A variable is often used to store the file handle, and exceptions such as FileNotFoundError must be handled to avoid crashes.
When writing pseudocode for file operations, ensure you close the file after use. Many exam mark schemes award marks for opening, processing, and closing the file correctly.
12. Testing, Debugging and Exam Technique | 测试、调试与应试技巧
Testing involves normal, boundary, and erroneous data. Boundary values such as minimum, maximum, and just outside the valid range are most likely to expose logic errors.
When debugging, trace variables line by line and compare expected values with actual values. In written exams, always show your working clearly in trace tables.
调试时，逐行跟踪变量并将期望值与实际值进行比较。在笔试中，务必在跟踪表中清楚地展示推理过程。
Exam technique: read the scenario twice, identify the required output, and plan pseudocode before writing. Allocate time to check syntax, indentation, and logic.
应试技巧：将场景阅读两遍，确定所需的输出，并在编写前规划伪代码。留出时间检查语法、缩进和逻辑。
Common pitfalls include off-by-one errors in loops, incorrect initialisation of variables, and missing base cases in recursion. Review these areas before the exam.
常见的错误包括循环中的差一错误、变量初始化错误以及递归中缺少基准情形。考前应重点复习这些方面。
Published by TutorHao | Programming Revision Series | aleveler.com
📚 Programming Constructs, Data Structures and Algorithms for Edexcel A Level | Edexcel A Level 编程构造、数据结构与算法
Programming is the heart of Edexcel A Level Computer Science Topic 6: Problem Solving with Programming. You need to master core constructs, data structures, algorithm design and testing if you want to score well on both the written examination and the non-exam assessment.
编程是 Edexcel A Level 计算机科学主题 6「用编程解决问题」的核心。如果你想在笔试和非考试评估中都取得好成绩，就必须掌握核心构造、数据结构、算法设计和测试。
1. Programming fundamentals and Edexcel expectations | 编程基础与 Edexcel 考试要求
Edexcel does not prescribe a single language, but most centres use Python, Java or C#. Exam questions use a clear pseudocode style so your answers can be written independently of any one syntax. You should be able to read, trace and write algorithms in pseudocode.
Marks are awarded for correct logic, appropriate use of constructs, and clear variable naming, not for memorising a particular API. Keep your pseudocode simple, with indentation to show blocks. The examiner expects a consistent style, so choose one convention and stick to it.
2. Variables, constants and data types | 变量、常量与数据类型
A variable is a named storage location whose value can change at runtime. A constant is similar but its value cannot change after initialisation. Edexcel pseudocode often uses CONSTANT for constants and plain assignment for variables.
Common data types include integer, real/float, Boolean, character and string. Some languages also support date/time and enumeration types. Choosing the correct type prevents logic errors and makes type checking possible before execution.
Always initialise variables before reading them. Uninitialised variables can hold garbage values in some languages, leading to unpredictable behaviour that is hard to debug.
读取变量之前务必初始化。未初始化的变量在某些语言中可能保存垃圾值，导致难以调试的不可预测行为。
3. Operators and expression evaluation | 运算符与表达式求值
Arithmetic operators include +, −, *, /, MOD and DIV. Integer division (DIV) and modulo (MOD) are tested frequently. For example, 17 DIV 5 gives 3 and 17 MOD 5 gives 2.
算术运算符包括 +、−、*、/、MOD 和 DIV。整数除法（DIV）和取模（MOD）经常出现在考试中。例如 17 DIV 5 结果是 3，17 MOD 5 结果是 2。
17 = 5 × 3 + 2 → 17 DIV 5 = 3 and 17 MOD 5 = 2
Comparison operators are =, ≠, <, >, ≤, ≥. Logical operators AND, OR and NOT combine conditions. Use parentheses to make compound expressions clear, especially when mixing AND and OR.
比较运算符有 =、≠、<、>、≤、≥。逻辑运算符 AND、OR 和 NOT 组合条件。使用括号使复合表达式更清晰，尤其是同时使用 AND 和 OR 时。
Operator precedence determines the order of evaluation: parentheses first, then division and multiplication, then addition and subtraction. Comparison operators have lower precedence than arithmetic, and logical operators are evaluated last.
Selection allows a program to take different paths based on a condition. The simplest form is IF…THEN…ELSE…ENDIF. Edexcel accepts ELSE IF or ELIF for multiple branches.
选择结构允许程序根据条件执行不同路径。最简单的形式是 IF…THEN…ELSE…ENDIF。Edexcel 接受使用 ELSE IF 或 ELIF 表示多个分支。
A CASE or SWITCH statement is useful when one variable can take several discrete values. It often produces clearer code than nested IF statements, because each case is separate and the structure is easier to read.
当一个变量可以取多个离散值时，CASE 或 SWITCH 语句很有用。它通常比嵌套 IF 语句更清晰，因为每个分支都是独立的，结构更容易阅读。
Always test boundary conditions: for age ≥ 18, test 17, 18 and 19 to confirm the branch behaves correctly. Off-by-one errors are common and cost marks in exams.
务必测试边界条件：比如 age ≥ 18 时，测试 17、18 和 19，以确认分支行为正确。差一错误非常常见，在考试中会丢分。
5. Definite and indefinite iteration | 确定与不确定迭代
Definite iteration uses a FOR loop, executed a known number of times. In pseudocode: FOR i ← 1 TO 10 … NEXT i. Note the left arrow for assignment is common in Edexcel papers.
确定迭代使用 FOR 循环，执行已知次数。伪代码写法：FOR i ← 1 TO 10 … NEXT i。注意 Edexcel 试卷中常用左箭头表示赋值。
Indefinite iteration uses WHILE or REPEAT…UNTIL. A WHILE loop checks the condition before each pass; a REPEAT loop checks after, so it runs at least once. Choose WHILE when the body may be skipped entirely.
不确定迭代使用 WHILE 或 REPEAT…UNTIL。WHILE 循环在每次执行前检查条件；REPEAT 循环在执行后检查，因此至少运行一次。当循环体可能完全跳过时，选择 WHILE。
Every loop must have a reachable exit. Consider counting variables, sentinel values or flags to avoid infinite loops. In an exam, a missing loop exit is a serious logic error.
6. Subroutines: procedures, functions and parameters | 子程序：过程、函数与参数
Procedures perform a task but do not return a value. Functions return a value. Both can accept parameters by value or by reference. By value copies the data; by reference passes the address, allowing modification.
过程执行任务但不返回值。函数返回一个
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
📚 A-Level Edexcel Programming: Algorithms, Data Structures and Core Techniques | A-Level Edexcel 编程：算法、数据结构与核心技巧
Programming is the heart of Edexcel A-Level Computer Science. This article revisits the essential constructs, data structures, algorithms, and problem-solving habits that appear across both examined and coursework components. Each section pairs a concise English explanation with its Chinese equivalent to support bilingual revision.
1. Computational Thinking and Problem Decomposition | 计算思维与问题分解
Computational thinking underpins all programming tasks in Edexcel A-Level Computer Science. It involves breaking a complex problem into smaller, manageable subproblems through decomposition, spotting patterns, generalising through abstraction, and designing step-by-step algorithms.
An algorithm is a finite sequence of well-defined instructions to solve a problem. It must be unambiguous, have clear inputs and outputs, and terminate for all valid inputs. Edexcel questions often ask you to trace or write algorithms in a pseudocode style.
The three basic programming constructs are sequence, selection, and iteration. Sequence means statements are executed in order; selection uses IF…THEN…ELSE…ENDIF to make decisions; iteration repeats statements using FOR, WHILE, or REPEAT…UNTIL loops.
Selection: IF score >= 90 THEN grade = “A” ELSE grade = “B” ENDIF — 选择：根据条件决定分支。
Iteration: FOR i = 1 TO 10 … ENDFOR — 迭代：固定次数重复。
Understanding how to combine these constructs is fundamental. Nested selection and iteration allow you to solve more realistic problems such as validation checks, menu systems, and searching through data.
Variables must be declared and typed in many languages. Edexcel pseudocode uses INTEGER, REAL, BOOLEAN, CHAR, STRING, and DATE. Choosing the correct data type saves memory and prevents type errors.
Constants are named values that cannot change at runtime. Type casting or conversion is often needed, for example converting a string “123” to integer 123 before arithmetic.
4. Subprograms: Procedures and Functions | 子程序：过程与函数
Procedures and functions allow modular programming. A procedure performs a task and does not return a value, while a function returns a value. Parameters can be passed by value or by reference depending on the language and the effect required.
Using subprograms avoids repeated code, improves readability, and makes testing easier. In Edexcel pseudocode, a function is called within an expression, whereas a procedure is called as a standalone statement.
Arrays are fixed-size or dynamic collections of elements of the same type, accessed by an index, usually starting at 0 or 1. Lists, especially in Python, are dynamic and can hold mixed types.
A two-dimensional array can represent a table or matrix, for example grid[3][4]. Edexcel questions often require populating a 2D array and iterating through rows and columns.
A stack is a Last In, First Out (LIFO) data structure. Common operations are push, pop, and peek/top. A queue is First In, First Out (FIFO), with enqueue, dequeue, and front. These structures are used in recursion, backtracking, scheduling, and buffering.
Linear search checks each element in turn, with O(n) in the worst case. Binary search requires a sorted list and repeatedly halves the search interval, giving O(log n) time. Understanding this trade-off is essential for Edexcel.
Sorting algorithms include bubble sort, insertion sort, and merge sort. Bubble sort is simple but O(n²); merge sort is more efficient at O(n log n) and is stable.
8. Algorithm Efficiency and Big O Notation | 算法效率与大 O 表示法
Big O notation describes the upper bound of an algorithm’s running time or space usage as the input size n grows. Common complexities are O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ).
大 O 表示法描述随着输入规模 n 增长，算法运行时间或空间使用的上限。常见复杂度为 O(1)、O(log n)、O(n)、O(n log n)、O(n²)、O(2ⁿ)。
When choosing an algorithm, consider the worst-case and average-case behaviour. For large data sets, an O(n log n) algorithm is usually much faster than an O(n²) algorithm.
Recursion occurs when a subroutine calls itself. A recursive solution must have a base case to stop and a recursive case that reduces the problem size. Classic examples are factorial, Fibonacci, and tree traversals.
Recursion can be elegant but uses call stack memory; each call creates a stack frame. Infinite recursion leads to stack overflow. Edexcel pupils should be able to trace recursive calls step by step.
Object-oriented programming (OOP) organises code into classes and objects. A class is a blueprint; an object is an instance. Key principles are encapsulation, inheritance, polymorphism, and abstraction.
Edexcel may ask about attributes, methods, constructors, and access modifiers like private and public. Encapsulation protects data by exposing only necessary methods.
11. File Handling and Exception Handling | 文件处理与异常处理
Programs often read from and write to files. Common operations are open, read, write, append, and close. Text files are sequential; binary files can be random access.
Exception handling uses TRY…EXCEPT…FINALLY to manage runtime errors such as file not found or division by zero. It prevents the program from crashing and allows graceful recovery.
Testing ensures that a program meets its specification. Types include unit testing, integration testing, system testing, and acceptance testing. Test data should include normal, boundary, and erroneous cases.
Debugging is the process of finding and fixing defects. Techniques include dry running, trace tables, breakpoints, and print statements. Edexcel questions often provide a faulty algorithm and ask you to identify the error.
📚 Programming Fundamentals: Data Types, Control Structures and Algorithms | 编程基础：数据类型、控制结构与算法
In Edexcel A-Level Computer Science, programming questions require more than writing code that happens to run. You need to understand how data is represented, how control flow is structured, and how algorithms can be traced and evaluated. This revision guide covers the core programming foundations tested across Paper 1 and Paper 2.
在 Edexcel A-Level 计算机科学中，编程题不仅要求代码能运行，更要求你理解数据如何表示、控制流如何组织，以及算法如何被追踪和评估。本复习指南涵盖 Paper 1 和 Paper 2 中考查的编程基础核心内容。
1. Primitive Data Types | 基本数据类型
In Edexcel A-Level Computer Science, understanding primitive data types is essential because selecting the correct type affects storage, precision and the operations available.
Integer: whole numbers such as 0, -7, 42. 中文：整数，例如 0、-7、42。
Real/Float: numbers with fractional parts such as 3.14 or -0.5. 中文：实数/浮点数，例如 3.14 或 -0.5。
Boolean: only TRUE or FALSE. 中文：布尔值，只有 TRUE 或 FALSE。
Character: a single symbol like ‘A’, ‘7’, ‘$’. 中文：字符，单个符号，如 ‘A’、’7’、’$’。
String: a sequence of characters like ‘hello’. 中文：字符串，字符序列，如 ‘hello’。
Edexcel pseudocode often assumes that variables are declared with a type before use, for example DECLARE age AS INTEGER.
Edexcel 伪代码通常假定变量在使用前声明类型，例如 DECLARE age AS INTEGER。
2. Constants and Variables | 常量与变量
A variable is a named storage location whose value can change while the program runs. A constant is given a value once and cannot change, which prevents accidental modification.
变量是命名存储位置，其值在程序运行期间可以改变。常量只赋值一次且不能更改，从而防止意外修改。
Using named constants improves clarity: instead of writing 0.1 repeatedly, write CONSTANT VAT_RATE ← 0.1. This makes code easier to update.
In Edexcel questions, you may be asked to identify whether an identifier should be a variable or constant based on its role in the algorithm.
在 Edexcel 题目中，可能要求你根据标识符在算法中的作用判断它应作为变量还是常量。
3. Operators and Expressions | 运算符与表达式
Expressions combine values, variables and operators to produce a new value. Arithmetic operators are +, -, *, /, MOD (remainder) and DIV (integer division).
Comparison operators produce Boolean results: =, ≠, <, >, ≤, ≥. Logical operators AND, OR and NOT combine Boolean values.
比较运算符产生布尔结果：=、≠、<、>、≤、≥。逻辑运算符 AND、OR 和 NOT 组合布尔值。
Precedence follows BIDMAS: brackets first, then multiplication/division, then addition/subtraction; logical operators are applied after comparisons.
优先级遵循 BIDMAS：括号优先，然后乘除，再加减；逻辑运算符在比较之后应用。
Brackets ( )
Highest priority 最高优先级
* / MOD DIV
Multiplication and division 乘除
+ –
Addition and subtraction 加减
= ≠ < > ≤ ≥
Comparison 比较
NOT
Logical NOT 逻辑非
AND
Logical AND 逻辑与
OR
Lowest priority 最低优先级
4. Selection: IF and CASE | 选择结构：IF 与 CASE
Selection structures allow a program to take different paths depending on a condition. The IF statement evaluates a Boolean expression and executes a block when it is TRUE.
Edexcel pseudocode uses: IF x < 10 THEN … ELSE … ENDIF. The ELSE branch handles the FALSE case; ELSE IF can chain multiple conditions.
Edexcel 伪代码使用：IF x < 10 THEN … ELSE … ENDIF。ELSE 分支处理 FALSE 情况；ELSE IF 可以串联多个条件。
CASE works well when comparing one variable against several discrete values. Each branch represents a constant value or range.
CASE 适用于将一个变量与多个离散值比较。每个分支表示一个常量值或范围。
Avoid unnecessary nested IFs; CASE often makes code clearer and easier to trace in exam papers.
避免不必要的嵌套 IF；CASE 通常使代码更清晰，在试卷中更容易追踪。
5. Iteration: FOR, WHILE, REPEAT | 迭代：FOR、WHILE、REPEAT 循环
Iteration repeats a block of code. A FOR loop is count-controlled: it runs a fixed number of times, often using a loop counter.
迭代重复执行代码块。FOR 循环是计数控制的：它运行固定次数，通常使用循环计数器。
A WHILE loop checks a condition before each iteration. If the condition is FALSE at the start, the loop body never executes.
WHILE 循环在每次迭代前检查条件。如果条件开始为 FALSE，循环体不会执行。
A REPEAT…UNTIL loop checks the condition after the loop body, so the body runs at least once.
REPEAT…UNTIL 循环在循环体之后检查条件，因此循环体至少执行一次。
Matching the correct loop to a scenario shows understanding: use FOR when the number of iterations is known, WHILE when there may be zero iterations, and REPEAT when at least one execution is required.
Arrays store multiple values of the same type under one identifier. Edexcel questions use one-dimensional and two-dimensional arrays, with indices either 0-based or 1-based depending on the context.
Common operations include accessing by index, updating an element, traversing all elements, and searching for a value.
常见操作包括按索引访问、更新元素、遍历所有元素以及搜索值。
Lists are dynamic data structures that can grow and shrink; typical operations are append, insert, remove and length.
列表是动态数据结构，可以增长和收缩；典型操作包括追加、插入、删除和求长度。
When tracing arrays in a trace table, write the entire array state after each statement to avoid losing track of changes.
在追踪表中追踪数组时，在每条语句后写出整个数组状态，以免丢失变化。
7. Subroutines: Procedures and Functions | 子程序：过程与函数
Subroutines break programs into manageable, reusable blocks. A procedure does a job and does not return a value; a function returns a value to the caller.
子程序将程序分解为可管理、可复用的块。过程完成任务且不返回值；函数向调用者返回一个值。
Edexcel pseudocode defines a subroutine with SUBROUTINE name(params) … ENDSUBROUTINE. A function uses RETURN expr to send a result back.
Parameters can be passed by value or by reference. By value copies the data; changes inside do not affect the original. By reference passes the address, so changes are visible outside.
Local variables are declared inside a subroutine and exist only during its execution; global variables are accessible throughout the program. In exams, prefer local variables to reduce side effects.
Strings are sequences of characters. Common Edexcel pseudocode operations include LEN(str), SUBSTRING(str, start, length), and concatenation using + or &.
Type conversion functions such as STR_TO_INT and INT_TO_STR are used when comparing or calculating with mixed data types.
在混合数据类型比较或计算时，使用 STR_TO_INT、INT_TO_STR 等类型转换函数。
Validation should check input before processing. Presence check ensures data is entered; range check accepts values within limits; length check verifies the number of characters; format check confirms a pattern such as a postcode.
Defensive design combines validation with sensible error messages so that invalid data is rejected rather than crashing the program.
防御性设计将验证与合理的错误信息结合，以便拒绝无效数据而不是使程序崩溃。
9. Searching and Sorting Algorithms | 查找与排序算法
Linear search checks each element in order until the target is found or the end is reached. It is simple but has O(n) time complexity on average.
线性查找按顺序检查每个元素，直到找到目标或到达末尾。它简单，但平均时间复杂度为 O(n)。
Binary search repeatedly halves a sorted array. It compares the target with the middle element, then searches the left or right half. Its time complexity is O(log n).
Bubble sort repeatedly swaps adjacent elements that are out of order, sinking the largest remaining value to the end each pass. Insertion sort places each new element into its correct position within the sorted part.
Object-oriented programming (OOP) is a fundamental paradigm in the Edexcel A-Level Computer Science specification. It enables students to design robust, reusable, and maintainable code by modelling real-world entities as objects. This article covers the essential OOP concepts you need to master for the exam, including classes, objects, encapsulation, inheritance, polymorphism, and abstraction.
An object is a self-contained entity that contains both data and the procedures to manipulate that data. A class is a blueprint or template from which objects are created. In Edexcel exams, you must be able to distinguish between a class definition and an object instance.
A class defines attributes (data) and methods (behaviour), but does not allocate memory for data values.
An object is an instance of a class, with its own state stored in memory.
类定义了属性（数据）和方法（行为），但不为数据值分配内存。
对象是类的一个实例，它在内存中存储自己的状态。
2. Attributes and Methods | 属性与方法
Attributes are the variables that hold an object’s state, while methods are functions that define an object’s behaviour. Edexcel questions often ask you to identify suitable attributes and methods for a given class, such as a BankAccount or Student class.
Encapsulation means bundling data and methods within a class and restricting direct access to the internal state. This is typically achieved by making attributes private and providing public getter and setter methods. Encapsulation protects data integrity and hides implementation details.
Use private access modifier for attributes to prevent external modification.
Provide public getters to read data and setters to validate before changing data.
属性使用私有访问修饰符，防止外部修改。
提供公共的 getter 方法读取数据，提供 setter 方法在修改前进行验证。
4. Inheritance | 继承
Inheritance allows a class (child) to acquire the properties and methods of another class (parent). It promotes code reuse and establishes an ‘is-a’ relationship. In Edexcel exams, you may be asked to draw inheritance hierarchies or explain the benefits of inheritance.
For example, a Dog class inherits from an Animal class. Dog automatically has attributes like name and age, and methods like eat() and sleep(), but can also add bark().
例如，Dog 类继承自 Animal 类。Dog 自动拥有 name 和 age 等属性，以及 eat() 和 sleep() 等方法，但还可以添加 bark()。
5. Polymorphism | 多态
Polymorphism means ‘many forms’. It allows objects of different classes to respond to the same method call in different ways. Method overriding is a common form of polymorphism where a child class provides a specific implementation of a method already defined in its parent class.
For instance, both Circle and Square classes inherit from Shape. Each overrides the calculateArea() method to return the correct formula for its shape. The same method call produces different results depending on the object type.
Abstraction focuses on exposing only the essential features of an object while hiding complex implementation details. Abstract classes and interfaces are key tools for achieving abstraction. An abstract class cannot be instantiated and may contain abstract methods that child classes must implement.
A concrete subclass must provide implementations for all inherited abstract methods.
抽象方法只有签名，没有方法体。
具体子类必须为所有继承的抽象方法提供实现。
7. Constructors and Instantiation | 构造方法与实例化
A constructor is a special method that initialises an object when it is created. It often sets initial values for attributes. In Edexcel questions, you may need to write a constructor definition or trace object instantiation.
8. Association, Aggregation and Composition | 关联、聚合与组合
These three relationships describe how classes are connected. Association is a general ‘uses-a’ relationship. Aggregation is a ‘has-a’ relationship where the contained object can exist independently. Composition is a stronger ‘has-a’ relationship where the contained object cannot exist without the container.
Department has Teachers, but Teachers can exist without the Department
Composition
House has Rooms; Rooms cannot exist without the House
9. OOP Design Principles | 面向对象设计原则
Good OOP design follows principles such as cohesion, coupling, and the SOLID principles. High cohesion means a class has a single, well-focused purpose. Low coupling means classes are as independent as possible. These principles reduce complexity and improve maintainability.
Single Responsibility Principle: a class should have only one reason to change.
Open/Closed Principle: classes should be open for extension but closed for modification.
单一职责原则：一个类应该只有一个改变的理由。
开闭原则：类应该对扩展开放，对修改关闭。
10. Exam-Style Application and Common Pitfalls | 考试应用与常见误区
Edexcel A-Level programming questions often present a scenario and ask you to design a class, explain an OOP concept, or trace code. Common mistakes include confusing inheritance with composition, forgetting to use private attributes, and not providing constructors where required.
Always read the question carefully to identify whether it asks for an ‘is-a’ or ‘has-a’ relationship. Use correct terminology such as ‘encapsulation’, not just ‘data hiding’. Practice writing UML class diagrams and short code snippets under timed conditions.