Mastering Object-Oriented Programming: Core Principles Combined | 掌握面向对象编程：核心原理综合应用

📚 Mastering Object-Oriented Programming: Core Principles Combined | 掌握面向对象编程：核心原理综合应用

Object-oriented programming (OOP) is a paradigm that structures software around ‘objects’ rather than functions and logic. Mastery of OOP requires not only understanding individual concepts such as classes, inheritance, and polymorphism, but also knowing how to combine them effectively to build robust, maintainable applications. This article explores the core OOP principles as they appear in the Edexcel A-Level Computer Science specification, demonstrating how encapsulation, abstraction, inheritance, and polymorphism work together in real-world scenarios.

面向对象编程（OOP）是一种围绕“对象”而非函数和逻辑来构建软件的范式。掌握 OOP 不仅需要理解类、继承和多态等单个概念，还需要知道如何将它们有效地组合在一起以构建健壮、可维护的应用程序。本文探讨了 Edexcel A-Level 计算机科学大纲中的核心 OOP 原则，演示了封装、抽象、继承和多态如何在真实场景中协同工作。

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

In OOP, a class serves as a template that defines the attributes (data) and methods (behaviours) common to all objects of a certain kind. An object is a concrete instance of that class, with its own state stored in fields. For example, a Car class might define attributes such as colour and speed, and methods like accelerate() and brake(). Each individual car object would hold its own colour and current speed.

在 OOP 中，类作为一个模板，定义了某一类对象共有的属性（数据）和方法（行为）。对象是该类的一个具体实例，拥有自己的状态，这些状态存储在字段中。例如，一个 Car 类可能定义诸如 colour 和 speed 的属性，以及 accelerate() 和 brake() 之类的方法。每个单独的汽车对象都会有自己独特的颜色和当前速度。

The relationship between class and object is often compared to a blueprint and a house: many houses can be built from the same blueprint, each with different furniture and paint. In code, object instantiation calls a constructor method to initialise the object’s state.

类与对象之间的关系常被比作蓝图与房屋：许多房屋可以从同一张蓝图中建造出来，每栋房子都有不同的家具和油漆。在代码中，对象实例化调用构造方法（constructor）来初始化对象的状态。

2. Encapsulation: Protecting Internal State | 封装：保护内部状态

Encapsulation is the bundling of data with the methods that operate on that data, and restricting direct access to some of an object’s components. This is typically achieved by making attributes private and providing public getter and setter methods to access or modify them. Encapsulation ensures that the internal representation of an object is hidden from the outside, reducing unintended interference and increasing security.

封装是将数据与操作数据的方法捆绑在一起，并限制对对象某些组件的直接访问。通常通过将属性设为私有（private）并提供公共（public）的 getter 和 setter 方法来访问或修改它们。封装确保了对象的内部表示对外部隐藏，减少了意外干扰，提高了安全性。

For example, a BankAccount class might have a private balance attribute. Instead of allowing direct manipulation like account.balance = -100, it exposes a withdraw(amount) method that validates the amount before deducting from the balance. This prevents the balance from becoming invalid.

例如，一个 BankAccount 类可能有一个私有属性 balance。与其允许像 account.balance = -100 这样的直接操作，它公开了一个 withdraw(amount) 方法，该方法在从余额中扣除之前会验证金额，从而防止余额变为无效状态。

Encapsulation also promotes modularity: implementation details can change without affecting code that uses the class, as long as the public interface remains consistent.

封装还促进了模块化：只要公共接口保持一致，实现细节的改变不会影响使用该类的代码。

3. Inheritance: Reusing and Specialising Behaviour | 继承：行为复用与特化

Inheritance allows a new class (subclass) to derive properties and methods from an existing class (superclass). This ‘is-a’ relationship promotes code reuse and establishes hierarchical classification. The subclass can override superclass methods to provide specialised behaviour, or add new attributes and methods.

继承允许新类（子类）从现有类（超类）中派生属性和方法。这种“是一种（is-a）”关系促进了代码复用，并建立了层次分类。子类可以重写超类的方法以提供专门的行为，或者添加新的属性和方法。

Consider a superclass Vehicle with methods startEngine() and move(). A Car subclass inherits these methods but might override move() to specifically move on roads. An ElectricCar class could further extend Car and override startEngine() to silently activate the motor. In Edexcel examinations, you are expected to identify appropriate inheritance hierarchies and write code that demonstrates overriding and the use of super to call the superclass implementation.

考虑一个超类 Vehicle，含有方法 startEngine() 和 move()。子类 Car 继承了这些方法，但可能重写 move() 以特化在道路上行驶。ElectricCar 类可以进一步继承自 Car 并重写 startEngine() 使电机无声启动。在 Edexcel 考试中，要求能够识别合适的继承层次，并编写展示重写以及使用 super 调用超类实现的代码。

4. Polymorphism: One Interface, Multiple Behaviours | 多态：同一接口，多种行为

Polymorphism means ‘many forms’ and allows objects of different classes to be treated as objects of a common superclass. The most powerful form is dynamic polymorphism, where a method call is resolved at runtime based on the actual object type, not the reference type. This enables writing flexible and extensible code.

多态意为“多种形态”，允许将不同类的对象视为公共超类的对象来处理。最强大的形式是动态多态，方法调用在运行时根据实际对象类型而非引用类型进行解析。这使得编写灵活且可扩展的代码成为可能。

For instance, an array of Shape references can hold Circle, Rectangle, and Triangle objects. Calling draw() on each element invokes the overridden version appropriate for each shape, without the client code needing to know the exact subclass. This is fundamental to the Open/Closed principle.

例如，一个 Shape 引用的数组可以持有 Circle、Rectangle 和 Triangle 对象。对每个元素调用 draw() 会触发适合该形状的重写版本，客户端代码无需知道确切的子类。这是开闭原则的基础。

Edexcel A-Level often tests the difference between compile-time (overloading) and run-time (overriding) polymorphism, and the use of abstract classes or interfaces to achieve polymorphic behaviour.

Edexcel A-Level 经常考察编译时多态（重载）与运行时多态（重写）的区别，以及使用抽象类或接口实现多态行为。

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

An abstract class cannot be instantiated and is designed to be subclassed. It may contain abstract methods (with no body) that subclasses must implement, as well as concrete methods with default behaviour. Abstract classes define a common protocol while allowing shared state via instance variables.

抽象类不能被实例化，其设计的目的是被继承。它可以包含抽象方法（没有方法体），子类必须实现这些方法，也可以包含带有默认行为的具体方法。抽象类定义了一个通用协议，同时通过实例变量允许共享状态。

An interface, on the other hand, is a fully abstract type that specifies a set of method signatures without any implementation. A class can implement multiple interfaces, providing a form of multiple inheritance of behaviour. In pseudocode and Python, abstract base classes serve a similar purpose, though interfaces are more explicit in Java.

另一方面，接口是一种完全抽象的类型，指定了一组方法签名而不包含任何实现。一个类可以实现多个接口，从而提供行为上的多重继承。在伪代码和 Python 中，抽象基类起到类似作用，但接口在 Java 中更为明确。

Choosing between abstract class and interface depends on whether common state or constructor logic is needed. In many Edexcel scenarios, interfaces are used to define a capability (e.g., Comparable, Serializable) that unrelated classes can adopt.

在选择使用抽象类还是接口时，取决于是否需要公共状态或构造逻辑。在许多 Edexcel 场景中，接口用于定义一种能力（如 Comparable、Serializable），不相干的类都可以采用。

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

Objects rarely exist in isolation; they relate to one another. Association is a general binary relationship between classes. Aggregation is a specialised form representing a ‘has-a’ relationship where the contained object can exist independently of the container. Composition is a stronger ‘part-of’ relationship where the part cannot exist without the whole.

对象很少孤立存在，它们彼此关联。关联（Association）是类之间的一般二元关系。聚合（Aggregation）是一种特殊形式，表示“有一个（has-a）”关系，其中被包含的对象可以独立于容器存在。组合（Composition）是一种更强的“部分属于整体（part-of）”关系，其中部分不能脱离整体而存在。

For example, a Library aggregates Book objects: books can be removed and still exist. A House is composed of Room objects: if the house is destroyed, the rooms cease to exist conceptually. These relationships are crucial in modelling real-world systems and appear in class diagrams.

例如，Library 聚合了 Book 对象：书籍可以被移除且仍然存在。House 由 Room 对象组成：如果房屋被摧毁，房间在概念上也不复存在。这些关系对于现实系统建模至关重要，并出现在类图中。

In Edexcel examinations, candidates should be able to distinguish between these relationships and represent them using UML-style notation, specifying multiplicities such as 1..* or 0..1.

在 Edexcel 考试中，考生应能区分这些关系，并使用 UML 风格记号表示它们，指定多重度如 1..* 或 0..1。

7. Overriding versus Overloading | 方法重写与方法重载

Overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The method signature must be identical, and the annotation (e.g., @Override in Java) indicates it is overriding. This is runtime polymorphism.

方法重写发生在子类为超类中已定义的方法提供特定实现时。方法签名必须完全相同，注解（如 Java 中的 @Override）表明这是一次重写。这是一种运行时多态。

Overloading happens when two or more methods in the same class share the same name but have different parameter lists (different type, number, or both). The correct version is selected at compile time based on the arguments. Overloading is not directly related to inheritance and is sometimes called ad-hoc polymorphism.

方法重载发生在同一类中两个或多个方法共享相同名称但拥有不同参数列表（类型、数量或两者不同）时。正确版本在编译时根据实参选择。重载与继承没有直接关系，有时被称为特设多态。

A common exam error is confusing the two. Remember: overriding requires a superclass-subclass relationship; overloading does not. Constructors are frequently overloaded to provide different initialisation options.

一个常见的考试错误是混淆两者。请记住：重写需要有超类-子类关系；重载则不需要。构造方法经常被重载以提供不同的初始化选项。

8. Design Principles: SOLID Basics | 设计原则：SOLID 基础

SOLID is an acronym for five design principles that help make software designs more understandable, flexible, and maintainable. While not all principles are examined in depth at A-Level, Single Responsibility and Open/Closed are particularly relevant.

SOLID 是五个设计原则的首字母缩略词，这些原则有助于使软件设计更易于理解、更灵活、更易维护。虽然并非所有原则都在 A-Level 中被深入考察，但是单一职责原则和开闭原则特别相关。

• Single Responsibility Principle: A class should have only one reason to change, meaning it should only have one job. For example, a Report class that both generates content and prints it violates this; separate into Report and ReportPrinter.
• 单一职责原则：一个类应该只有一个引起它变化的原因，即它应该只有一项职责。例如，一个 Report 类既生成内容又打印它，这违反了该原则；应拆分为 Report 和 ReportPrinter。
• Open/Closed Principle: Software entities should be open for extension but closed for modification. Using abstract classes or interfaces allows new subclasses to be added without altering existing code.
• 开闭原则：软件实体应对扩展开放，对修改封闭。使用抽象类或接口允许添加新的子类而无需修改现有代码。

Applying these principles early leads to code that is easier to test and adapt, a skill emphasised in the NEA (non-exam assessment) component.

尽早应用这些原则能产生更容易测试和调整的代码，这是在 NEA（非考试评估）部分所强调的技能。

9. Practical OOP: Modelling a Library System | 实践：为图书馆系统建模

Let us combine these concepts by modelling a simple library management system. We can define an abstract class LibraryItem with attributes title, id, and abstract methods getLoanPeriod() and getFinePerDay(). Concrete subclasses Book, DVD, and Journal implement these differently. A Member class encapsulates personal data and provides a method borrow(LibraryItem item) that checks membership status and item availability.

让我们通过为一个简单的图书馆管理系统建模来综合这些概念。我们可以定义一个抽象类 LibraryItem，具有属性 title、id，以及抽象方法 getLoanPeriod() 和 getFinePerDay()。具体子类 Book、DVD 和 Journal 以不同方式实现这些方法。一个 Member 类封装个人数据，并提供方法 borrow(LibraryItem item)，该方法检查会员状态和文献可用性。

The relationship between Library and LibraryItem is aggregation: items exist independently. The Library holds a collection of items and can search by title. Polymorphism allows treating all item types uniformly when calculating total fines or generating a catalogue.

Library 与 LibraryItem 之间的关系是聚合关系：文献可以独立存在。Library 持有一个文献集合并可以按标题搜索。多态性允许在计算总罚款或生成目录时统一处理所有文献类型。

Here is a pseudocode snippet demonstrating polymorphism:

for each item in library.items
    output item.title + " loan period: " + item.getLoanPeriod() + " days"
next

这段伪代码片段演示了多态：遍历 library.items，输出每个 item 的标题和借阅期限，无需区分具体类型。

10. Common Exam Mistakes and Key Takeaways | 常见考试错误与要点总结

Mistake 1: Confusing class and object. A class is the definition; an object is a specific instance in memory. Ensure you can write correct instantiation syntax, such as myCar = new Car("red") in Java-like pseudocode.

错误 1：混淆类和对象。类是定义；对象是内存中的具体实例。确保能写出正确的实例化语法，例如类 Java 伪代码中的 myCar = new Car("red")。

Mistake 2: Overlooking access modifiers. Stating that a private method can be accessed by subclasses loses marks. Private members are only visible within the class itself. Use ‘protected’ for subclass access.

错误 2：忽视访问修饰符。声称私有方法可以被子类访问会失分。私有成员仅在其类内部可见。若要子类访问请使用“protected”。

Mistake 3: Failing to recognise polymorphism. When a superclass reference points to a subclass object, the overridden method of the actual object runs, not the superclass version. Trace tables can help demonstrate this.

错误 3：无法识别多态。当超类引用指向子类对象时，运行的是实际对象的重写方法，而非超类版本。跟踪表示（trace table）可帮助演示这一点。

Mistake 4: Incorrect UML multiplicity. An aggregation with multiplicity 1 on the whole side means the part must belong to exactly one whole at any time. Read the scenario carefully.

错误 4：错误的 UML 多重度。若整体端多重度为 1 的聚合，意味着部分在任何时刻必须恰好属于一个整体。需仔细阅读场景描述。

To succeed in the OOP sections of the Edexcel A-Level, practice writing classes from descriptions, drawing inheritance diagrams, and justifying design choices using principles like encapsulation and the Open/Closed principle.

要在 Edexcel A-Level 的 OOP 部分取得成功，请练习根据描述编写类，绘制继承图，并使用封装和开闭原则等原则来论证设计选择。

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

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