GCSE OCR Computer Science: Object-Oriented Programming Essentials | GCSE OCR 计算机：面向对象考点精讲

📚 GCSE OCR Computer Science: Object-Oriented Programming Essentials | GCSE OCR 计算机：面向对象考点精讲

Object-oriented programming (OOP) is a paradigm built around the concept of ‘objects’ that contain both data and methods. In the OCR GCSE specification, you are expected to understand the core principles of encapsulation, inheritance, and polymorphism, and be able to apply them using a suitable high-level language. This guide breaks down every required concept into clear, paired explanations.

面向对象编程（OOP）是一种围绕“对象”构建的编程范式，对象包含数据和方法。在 OCR GCSE 考试大纲中，你需要理解封装、继承和多态的核心原则，并能使用合适的高级语言应用它们。本指南将所有必考概念分解为清晰的双语对照讲解。

1. Understanding Objects and Classes | 理解对象与类

A class is a blueprint or template that defines the attributes (data) and methods (behaviours) that the objects created from it will have. You can think of a class as a recipe, while an object is the actual dish you cook.

类是定义其创建的对象将拥有的属性（数据）和方法（行为）的蓝图或模板。你可以把类比作食谱，而对象则是你实际烹饪出的菜肴。

In code, a class declaration typically includes a name, fields (variables), and methods. Once a class is defined, you can instantiate multiple objects from it, each with its own separate state.

在代码中，类的声明通常包括名称、字段（变量）和方法。一旦定义了类，你可以从中实例化多个对象，每个对象都有自己独立的状态。

Class: defines structure, e.g., class Car. | 类：定义结构，例如类 Car。
Object: an instance of a class, e.g., myCar = new Car(). | 对象：类的实例，例如 myCar = new Car()。
Attribute: a variable belonging to an object, e.g., colour, speed. | 属性：属于对象的变量，例如 colour, speed。
Method: a function belonging to an object, e.g., accelerate(). | 方法：属于对象的函数，例如 accelerate()。

2. Encapsulation: Protecting Data | 封装：保护数据

Encapsulation is the practice of keeping an object’s internal state private and only allowing controlled access through public methods. This prevents unintended interference and misuse of the data.

封装是将对象的内部状态保持为私有，并仅允许通过公共方法进行受控访问的做法。这可以防止数据的意外干扰和误用。

In most programming languages, you mark attributes as private and provide getter and setter methods. This means you can add validation inside setter methods, so an object’s data is always consistent.

在大多数编程语言中，你将属性标记为私有，并提供 getter 和 setter 方法。这意味着你可以在 setter 方法内部添加验证，从而使对象的数据始终保持一致。

Private attributes: accessible only within the class itself. | 私有属性：只能在类内部访问。
Public methods: provide a controlled interface to the outside world. | 公共方法：提供对外界的受控接口。
Getters return the value; setters modify it (often after checks). | Getter 返回值；setter 修改值（通常在检查之后）。

3. Inheritance: Reusing and Extending Classes | 继承：重用与扩展类

Inheritance allows a new class (subclass or derived class) to take on the attributes and methods of an existing class (superclass or base class). This promotes code reuse and establishes a hierarchical relationship.

继承允许新类（子类或派生类）继承现有类（超类或基类）的属性和方法。这促进了代码重用，并建立了层次关系。

The subclass can also add its own specialised attributes and methods, or override inherited methods to provide different behaviour. In OCR GCSE, you need to recognise and write simple class hierarchies.

子类还可以添加自己专用的属性和方法，或重写继承的方法以提供不同的行为。在 OCR GCSE 中，你需要识别并编写简单的类层次结构。

Superclass: the parent class, e.g., Vehicle. | 超类：父类，例如 Vehicle。
Subclass: the child class, e.g., Car inherits from Vehicle. | 子类：子类，例如 Car 继承自 Vehicle。
Keyword often used: extends (Java), (className : ParentClass) (C#/VB), or brackets in Python. | 常用关键字：extends（Java），(className : ParentClass)（C#/VB），或 Python 中的括号。

4. Polymorphism: Many Forms, One Interface | 多态：多形式，一接口

Polymorphism lets objects of different classes be treated as objects of a common superclass. The most common form in GCSE is method overriding, where a subclass provides its own version of a method already defined in the parent class.

多态允许不同类的对象被视为共同超类的对象。GCSE 中最常见的形式是方法重写，即子类提供自己对父类已定义方法的版本。

For example, a Shape superclass might have a draw() method. Both Circle and Rectangle subclasses can override draw() to display themselves differently, yet you can call draw() on any shape object without knowing its exact type.

例如，一个 Shape 超类可能有一个 draw() 方法。Circle 和 Rectangle 子类都可以重写 draw() 以不同的方式显示自己，但你可以在任何形状对象上调用 draw()，而无需知道其确切类型。

Overriding: redefining a method in a subclass with the same signature. | 重写：在子类中用相同的签名重新定义方法。
Overloading (not a core GCSE focus): same method name, different parameters. | 重载（非 GCSE 核心）：方法名相同，参数不同。

5. Constructors: Building Objects Correctly | 构造函数：正确地构建对象

A constructor is a special method automatically called when an object is instantiated. It usually initialises attributes and ensures the object starts in a valid state. In OCR GCSE pseudocode, you might see a procedure called new that acts as a constructor.

构造函数是在实例化对象时自动调用的特殊方法。它通常初始化属性，并确保对象以有效状态启动。在 OCR GCSE 伪代码中，你可能会看到一个名为 new 的过程，充当构造函数。

Constructors often accept parameters to set initial values. For instance, a Car constructor might receive the registration number and mileage.

构造函数通常接受参数来设置初始值。例如，一个 Car 构造函数可能接收注册号和里程数。

Language \| 语言	Constructor Example \| 构造函数示例
Pseudocode	public new(regNum, initialMileage)
Python	def __init__(self, regNum, mileage):
Java / C#	public Car(string regNum, int mileage) { … }

6. Access Modifiers: Public, Private, Protected | 访问修饰符：公共、私有、受保护

Access modifiers control the visibility of class members. OCR GCSE mostly focuses on public and private. Public members are accessible from anywhere; private members are only accessible within the defining class.

访问修饰符控制类成员的可见性。OCR GCSE 主要关注 public 和 private。公共成员可从任何地方访问；私有成员只能在定义类内部访问。

In pseudocode, we use keywords public and private before attributes or methods. This allows encapsulation to be explicitly shown.

在伪代码中，我们在属性或方法前使用关键字 public 和 private。这使得封装可以明确地表示出来。

public: accessible globally. | public：全局可访问。
private: accessible only within the same class. | private：仅在同一类内可访问。
protected: accessible in class and subclasses (mentioned briefly). | protected：可在类及其子类中访问（简要提及）。

7. UML Class Diagrams: Drawing the Design | UML 类图：绘制设计

In OCR exams, you may be asked to interpret or draw a simple class diagram showing the class name, attributes, and methods. The standard format is a rectangle split into three sections.

在 OCR 考试中，你可能会被要求解释或绘制一个简单的类图，显示类名、属性和方法。标准格式是分为三个部分的矩形。

Attributes are written with their type, e.g., + name: String (public) or – balance: Integer (private). Methods include the return type, e.g., + getBalance(): Integer.

属性与其类型一起写，例如 + name: String（公共）或 – balance: Integer（私有）。方法包括返回类型，例如 + getBalance(): Integer。

BankAccount
-------------------------
- accountNumber: String
- balance: Real
-------------------------
+ new(an: String, bal: Real)
+ getBalance(): Real
+ deposit(amount: Real)

8. Bringing It Together: A Worked Example | 综合运用：一个完整示例

Let’s consider a library system. A LibraryItem superclass has attributes title and location. Subclasses Book and DVD inherit these and add their own attributes, like author or duration. All items share a checkOut() method, but DVD might override it to log a rental fee.

我们考虑一个图书馆系统。一个 LibraryItem 超类具有属性 title 和 location。子类 Book 和 DVD 继承这些属性，并添加自己的属性，如 author 或 duration。所有项目共享一个 checkOut() 方法，但 DVD 可能会重写它以记录租赁费用。

Using encapsulation, the location attribute is private, with a public getLocation() method. This ensures location changes only happen through a dedicated moveItem() method, which validates the new shelf.

通过封装，location 属性是私有的，带有一个公共的 getLocation() 方法。这确保了位置更改只能通过专用的 moveItem() 方法进行，该方法会验证新书架。

This single example demonstrates all four key principles: abstraction (via classes), encapsulation, inheritance, and polymorphism.

这个单一示例演示了所有四个关键原则：抽象（通过类）、封装、继承和多态。

9. Advantages of OOP for Large Projects | 面向对象编程在大型项目中的优势

OOP makes large-scale programming more manageable. Because code is organised into self-contained classes, teams can develop different modules independently. Reusability through inheritance reduces duplication and bugs.

OOP 使大规模编程更易于管理。由于代码被组织成自包含的类，团队可以独立开发不同的模块。通过继承实现的重用性减少了重复和错误。

Encapsulation protects data integrity, so changes to one part of the code are less likely to break other parts. Polymorphism allows systems to be extended with new subclasses without modifying existing logic.

封装保护了数据完整性，因此代码某部分的更改不太可能破坏其他部分。多态允许通过新的子类扩展系统，而无需修改现有逻辑。

Modularity: classes can be tested in isolation. | 模块化：类可以单独测试。
Extensibility: new features can be added as subclasses. | 可扩展性：新功能可以作为子类添加。
Maintainability: private members reduce unintended dependencies. | 可维护性：私有成员减少了意外的依赖。

10. Common Pitfalls and Exam Tips | 常见陷阱与考试技巧

Students often confuse a class with an object; remember that a class is the definition, and an object is an instance. When explaining encapsulation, avoid saying ‘it hides the code’ — be precise: it restricts direct access to data and allows access only through safe methods.

学生经常混淆类和对象；记住，类是定义，对象是实例。在解释封装时，避免说“它隐藏了代码”——要精确：它限制对数据的直接访问，只允许通过安全的方法访问。

In inheritance questions, always identify the ‘is-a’ relationship. If the relationship is not ‘is-a’, inheritance is likely unsuitable. For polymorphism, always connect it to method overriding and treating derived objects through a parent reference.

在继承问题中，始终识别“is-a”关系。如果关系不是“is-a”，继承可能不合适。对于多态，始终将其与方法重写和通过父引用处理派生对象联系起来。

Be prepared to write small pseudocode snippets showing a superclass, a subclass with overriding, and a line of code that demonstrates polymorphism. Use the correct OCR pseudocode style for constructors and access modifiers.

准备好编写小的伪代码片段，展示超类、带有重写的子类，以及一行演示多态的代码。对构造函数和访问修饰符使用正确的 OCR 伪代码风格。

11. OCR Exam-Style Quick Questions | OCR 考试风格快速问答

Q1: What is the difference between a class and an object? A class is a template defining attributes and methods; an object is a specific instance of a class with its own data.

问1：类和对象有什么区别？类是定义属性和方法的模板；对象是类的具体实例，拥有自己的数据。

Q2: State two benefits of encapsulation. It prevents accidental data corruption and allows internal changes without affecting other code.

问2：说明封装的两个好处。它可以防止意外的数据损坏，并允许在不影响其他代码的情况下进行内部更改。

Q3: Explain how polymorphism could be used in a game with different types of enemies. A base class Enemy could define a takeDamage() method. Subclasses like Orc and Dragon override it to implement different damage responses, but the game engine can call takeDamage() on any enemy reference without knowing the type.

问3：解释多态如何在具有不同类型敌人的游戏中使用。基类 Enemy 可以定义一个 takeDamage() 方法。像 Orc 和 Dragon 这样的子类重写它以实现不同的伤害响应，但游戏引擎可以在任何敌人引用上调用 takeDamage()，而无需知道其类型。

12. The ‘Big Picture’ for GCSE OCR | GCSE OCR 的整体图景

OOP is not just a set of keywords — it is a way of thinking about programs as collections of interacting objects. The OCR specification evaluates your understanding through design questions, pseudocode tracing, and short explanations. Mastering these concepts will also give you a strong foundation for A Level Computer Science.

面向对象编程不仅仅是一组关键字——它是一种将程序视为相互作用的对象集合的思维方式。OCR 考纲通过设计题、伪代码跟踪和简短解释来评估你的理解。掌握这些概念还将为你的 A Level 计算机科学打下坚实的基础。

Remember the four pillars: abstraction (simplifying complex reality by modelling classes), encapsulation, inheritance, and polymorphism. Every real-world system you design in your exam can be broken down using these principles.

记住四大支柱：抽象（通过建模类来简化复杂现实）、封装、继承和多态。你在考试中设计的每一个现实世界系统都可以使用这些原则进行分解。

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

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

GCSE OCR Computer Science: Object-Oriented Programming Essentials | GCSE OCR 计算机：面向对象 考点精讲