Object-Oriented Programming Fundamentals | 面向对象编程基础

📚 Object-Oriented Programming Fundamentals | 面向对象编程基础

Object-oriented programming (OOP) is a paradigm that structures software design around data, or objects, rather than functions and logic. For Edexcel A-Level Computer Science, mastering OOP concepts—classes, objects, inheritance, polymorphism, encapsulation—is essential for both the written exam and practical programming projects. This article breaks down each core principle with clear examples, comparisons, and examiner-friendly explanations.

面向对象编程（OOP）是一种围绕数据（即对象）而非函数和逻辑来组织软件设计的范式。对于 Edexcel A-Level 计算机科学而言，掌握类、对象、继承、多态、封装等 OOP 概念，对笔试和实践编程项目都至关重要。本文将通过清晰的示例、对比和考官友好的解释，逐一剖析每个核心原则。

1. Introduction to Programming Paradigms | 编程范式简介

A programming paradigm is a fundamental style of computer programming. The main paradigms you will encounter at A-Level are procedural (e.g., C, early Python), object-oriented (e.g., Java, C#, modern Python), and event-driven (e.g., JavaScript in the browser). OOP models the real world by representing entities as objects that contain both data and behaviour.

编程范式是计算机编程的基本风格。A-Level 阶段你会遇到的主要范式包括过程式（如 C、早期 Python）、面向对象（如 Java、C#、现代 Python）和事件驱动（如浏览器中的 JavaScript）。OOP 通过将实体表示为既包含数据又包含行为的对象来模拟现实世界。

In OOP, programs are built from classes that serve as blueprints. This contrasts with procedural programming where functions act on separate data structures. The shift in thinking helps manage complexity in larger systems.

在 OOP 中，程序由充当蓝图的类构建。这与过程式编程中函数作用于独立数据结构的方式形成对比。这种思维转变有助于管理大型系统的复杂性。

2. Core Concepts of OOP: Classes and Objects | 核心概念：类与对象

A class is a template that defines the properties (attributes) and behaviours (methods) common to all objects of a certain kind. For instance, a Car class might have attributes like colour and speed, and methods like accelerate().

类是一个模板，定义了某一类所有对象共有的属性（数据成员）和行为（方法）。例如，一个 Car 类可能拥有 colour 和 speed 属性，以及 accelerate() 方法。

An object is an instance of a class. Each object holds its own state (specific attribute values) but shares the same methods. In pseudocode: myCar = new Car("red", 0) creates an object with colour red and speed 0.

对象是类的实例。每个对象都拥有自己的状态（具体的属性值），但共享相同的方法。用伪代码表示：myCar = new Car("red", 0) 创建了一个颜色为红、速度为 0 的对象。

Understanding the class–object distinction is the first step in OOP. Many exam questions ask you to identify classes and objects from a scenario or to write simple class definitions.

理解类与对象的区别是 OOP 的第一步。许多考题要求从场景中识别类与对象，或编写简单的类定义。

3. Encapsulation and Data Hiding | 封装与数据隐藏

Encapsulation bundles data and the methods that operate on that data within a single unit (the class). It prevents external code from directly accessing an object’s internal state, which is achieved through access modifiers.

封装将数据与操作这些数据的方法捆绑在一个单元（类）中。它通过访问修饰符阻止外部代码直接访问对象的内部状态。

Data hiding is a key mechanism: attributes are typically declared private so they can only be changed via public methods (getters and setters). This protects the integrity of an object’s data and allows you to change internal implementation without affecting the rest of the program.

数据隐藏是关键机制：属性通常被声明为 private，只能通过公共方法（getter 和 setter）更改。这保护了对象数据的完整性，并允许在不影响程序其他部分的情况下更改内部实现。

For example, a BankAccount class should not expose its balance field directly. Instead, methods like deposit(amount) and withdraw(amount) enforce rules (e.g., no overdraft) before modifying balance.

例如，一个 BankAccount 类不应直接暴露 balance 字段。相反，通过 deposit(amount) 和 withdraw(amount) 等方法在修改余额之前执行规则（如不允许透支）。

4. Inheritance: Building Hierarchies | 继承：构建层次结构

Inheritance allows a new class (subclass or derived class) to acquire the properties and methods of an existing class (superclass or base class). It promotes code reuse and establishes a hierarchical relationship.

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

Consider a superclass Vehicle with attributes make and model, and method startEngine(). A subclass ElectricCar can inherit these and add its own attribute batteryCapacity while overriding startEngine() to silently activate.

考虑超类 Vehicle，它包含 make 和 model 属性以及 startEngine() 方法。子类 ElectricCar 可以继承这些内容，并添加自己的属性 batteryCapacity，同时重写 startEngine() 以静默方式启动。

In Edexcel exams, you may be asked to draw inheritance diagrams or explain how ‘is-a’ relationships work. Remember: a subclass should always be a more specialised version of the superclass.

在 Edexcel 考试中，你可能需要绘制继承图或解释“是一个（is-a）”关系如何运作。记住：子类应是超类的一个更特化的版本。

5. Polymorphism: One Interface, Multiple Forms | 多态：一个接口，多种形态

Polymorphism means ‘many forms’. It enables a single interface to represent different underlying data types. The most common type is inclusion polymorphism (subtype polymorphism) where a method call behaves differently depending on the object’s actual runtime class.

多态意为“多种形态”。它允许用单一接口表示不同的底层数据类型。最常见的类型是包含多态（子类型多态），即方法调用会根据对象的实际运行时类型表现出不同行为。

For instance, a superclass Shape might have a method draw(). Subclasses Circle, Rectangle and Triangle each provide their own implementation. A list of Shape objects can be iterated, and calling draw() on each will invoke the appropriate overridden method.

例如，超类 Shape 可以包含 draw() 方法。子类 Circle、Rectangle 和 Triangle 各自提供自己的实现。迭代一个 Shape 对象列表，并对每个对象调用 draw() 将调用相应的重写方法。

Polymorphism reduces conditional logic and makes systems more extensible. You can add a new Shape subclass without altering the code that uses polymorphic calls.

多态减少了条件逻辑，使系统更易扩展。你可以添加新的 Shape 子类，而无需更改使用多态调用的代码。

6. Overriding vs Overloading | 重写与重载

These two concepts are frequently tested together. Method overriding occurs when a subclass provides a specific implementation of a method already defined in its superclass. The signature (name and parameters) must be identical. It supports runtime polymorphism.

这两个概念常被一起考查。方法重写发生在子类提供其超类中已定义方法的特定实现时。签名（名称和参数）必须相同。它支持运行时多态。

Method overloading happens when two or more methods in the same class share the same name but have different parameter lists (number, type, or order). It is resolved at compile time and is a form of ad-hoc polymorphism.

方法重载发生在同一个类中的多个方法共享相同名称但具有不同参数列表（数量、类型或顺序）时。它在编译时解析，是特设多态的一种形式。

Feature / 特性	Overriding / 重写	Overloading / 重载
Resolved / 解析	Runtime (dynamic) / 运行时	Compile time (static) / 编译时
Signature / 签名	Must match exactly / 必须完全匹配	Must differ / 必须不同
Inheritance / 继承	Required / 需要	Not required / 不需要

Exam questions often provide code snippets and ask you to identify whether it demonstrates overriding or overloading, so understanding the distinction is crucial.

考试题目经常提供代码片段，要求你判断它是重写还是重载，因此理解区别至关重要。

7. Constructors and Destructors | 构造函数与析构函数

A constructor is a special method invoked automatically when an object is created. It usually initialises attributes and allocates resources. Constructors have the same name as the class and no return type.

构造函数是在创建对象时自动调用的特殊方法。它通常用于初始化属性并分配资源。构造函数与类同名，且无返回类型。

Many languages support constructor overloading: a default constructor (no parameters) and parameterised constructors. A destructor (or finalizer) is called when an object is destroyed, releasing resources such as file handles.

许多语言支持构造函数重载：默认构造函数（无参数）和带参数的构造函数。析构函数（或终结器）在对象销毁时调用，用于释放文件句柄等资源。

In Python, __init__ acts as the constructor, while __del__ is the destructor (though rarely needed due to garbage collection). In Java, constructors are defined with the class name, and finalization is handled by finalize().

在 Python 中，__init__ 充当构造函数，__del__ 是析构函数（尽管由于垃圾回收很少需要）。在 Java 中，构造函数与类名相同，终结由 finalize() 处理。

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

Access modifiers control the visibility of class members. The three main levels are:

访问修饰符控制类成员的可见性。三个主要级别如下：

Public (+): Accessible from anywhere. / 公共（+）：可从任何地方访问。
Private (-): Accessible only within the same class. / 私有（-）：仅可在同一个类中访问。
Protected (#): Accessible within the same class and subclasses (and often the same package). / 保护（#）：可在同一个类及其子类（以及通常同一个包）中访问。

Using these modifiers enforces encapsulation. In UML class diagrams, a plus sign (+) denotes public, a minus (–) denotes private, and a hash (#) denotes protected. Exam scenarios may ask you to assign appropriate modifiers based on security requirements.

使用这些修饰符可以实现封装。在 UML 类图中，加号（+）表示公共，减号（-）表示私有，井号（#）表示保护。考试场景可能要求你根据安全需求分配合适的修饰符。

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

Objects often interact with one another. Association is a general ‘uses-a’ relationship. Aggregation represents 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.

对象经常相互交互。关联是一种普遍的“使用（uses-a）”关系。聚合表示“拥有（has-a）”关系，其中被包含的对象可以独立存在。组合是一种更强的“has-a”关系，被包含的对象不能独立于容器存在。

Example: A Library aggregates Books—if the library closes, books still exist. But a House is composed of Rooms—destroy the house, and the rooms are gone. Recognising these relationships helps in designing accurate class diagrams.

示例：一个 Library 聚合了 Books——如果图书馆关闭，书本仍然存在。但一所 House 由 Rooms 组成——拆除房子，房间就不复存在。识别这些关系有助于设计准确的类图。

10. OOP in Practice: UML Class Diagrams | OOP 实践：UML 类图

Unified Modeling Language (UML) class diagrams are the standard way to visually represent classes, their attributes, methods, and relationships. Each class is shown as a rectangle divided into three compartments: name, attributes, and methods.

统一建模语言（UML）类图是可视化表示类、其属性、方法和关系的标准方式。每个类显示为一个矩形，分为三个部分：名称、属性和方法。

Attributes and methods are prefixed with visibility markers (- for private, + for public, # for protected). Inheritance is shown with a hollow triangle arrow pointing to the superclass. Aggregation uses a hollow diamond, while composition uses a filled diamond.

属性和方法前面带有可见性标记（- 表示私有，+ 表示公共，# 表示保护）。继承用指向超类的空心三角箭头表示。聚合使用空心菱形，组合使用实心菱形。

In the exam, you might be asked to sketch a UML diagram from a textual scenario. Practise translating descriptions into correct notations, including multiplicities (e.g., 1, 0..*, 1..*).

考试中，你可能会被要求根据文本场景绘制 UML 图。请练习将描述转化为正确的符号，包括多重性（如 1、0..*、1..*）。

11. Benefits and Drawbacks of OOP | OOP 的优缺点

OOP brings clear advantages: modularity (encapsulated objects), code reusability (inheritance), flexibility (polymorphism), and a natural mapping to real-world entities. These make large-scale software easier to design, maintain, and extend.

OOP 具有明显优势：模块化（封装的对象）、代码可重用性（继承）、灵活性（多态），以及与其实世界实体的自然映射。这些使得大规模软件更易于设计、维护和扩展。

However, OOP is not without criticism. It can introduce unnecessary complexity for simple programs. Deep inheritance hierarchies become hard to manage. Objects can lead to larger memory overhead compared to simple data structures. Some problems are better suited to functional or procedural approaches.

然而，OOP 并非没有缺点。对于简单程序，它可能带来不必要的复杂性。过深的继承层次难以管理。与简单的数据结构相比，对象可能带来更大的内存开销。有些问题更适合函数式或过程式方法。

Examiners appreciate balanced arguments. When evaluating a paradigm, mention both sides and relate them to the given scenario.

考官欣赏平衡的论述。在评估某种范式时，请提及两方面并联系具体场景。

12. Exam Tips and Common Pitfalls | 考试技巧与常见误区

Many students lose marks by confusing ‘class’ and ‘object’. Remember: the class is the blueprint; the object is the instance. Another common error is stating that private members are not inherited—they are inherited but remain inaccessible directly, thus subclasses must use inherited public/protected methods to manipulate them.

许多学生因混淆“类”与“对象”而丢分。记住：类是蓝图；对象是实例。另一个常见错误是声称私有成员不能被继承——事实上它们会被继承，但无法直接访问，因此子类必须使用继承来的公共/保护方法操作它们。

When explaining polymorphism, always mention dynamic binding and method overriding. If you name overloading, clarify that it is compile-time polymorphism. Use correct terminology consistently.

在解释多态时，务必提及动态绑定和方法重写。如果提到重载，请说明它是编译时多态。始终使用正确的术语。

Finally, practise writing code snippets and drawing UML diagrams by hand. Past papers often include questions with a scenario and ask you to define classes, show inheritance, or explain how a change would be easier in OOP compared to procedural code.

最后，请练习手写代码片段和绘制 UML 图。历年真题经常给出一个场景，要求你定义类、展示继承，或解释 OOP 相比过程式代码如何更容易实现某个更改。

Published by TutorHao | Programming Revision Series | aleveler.com

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

Object-Oriented Programming Fundamentals | 面向对象编程基础