OOP Combined: Core Object-Oriented Programming Skills | 面向对象编程综合：核心面向对象编程技能

📚 OOP Combined: Core Object-Oriented Programming Skills | 面向对象编程综合：核心面向对象编程技能

In Pearson Edexcel A-Level Programming, the section ‘OPS combined 158’ on ActiveLearn lays a critical foundation in object-oriented programming (OOP). This article unpacks the core OOP concepts every student must master: classes, objects, encapsulation, inheritance, polymorphism, abstraction, and more. We explore how these principles enable modular, reusable, and secure code, using practical examples, pseudocode, and Python snippets aligned with the Edexcel specification.

在皮尔森爱德思A-Level编程课程中，ActiveLearn上的“OPS combined 158”部分为面向对象编程（OOP）奠定了关键基础。本文解析每位学生必须掌握的核心OOP概念：类、对象、封装、继承、多态、抽象等。我们探讨这些原则如何借助实用示例、伪代码以及符合爱德思考纲的Python代码片段，助你编写模块化、可重用且安全的代码。

1. Introduction to OOP | 面向对象编程简介

Object-oriented programming models real-world entities as objects that contain attributes (data) and methods (behaviour). Unlike procedural programming that separates data and logic, OOP bundles them together, promoting code that is easier to maintain, extend, and debug. This paradigm is central to modern software development and forms a significant part of the Edexcel A-Level programming syllabus.

面向对象编程将现实世界的实体建模为包含属性（数据）和方法（行为）的对象。与将数据和逻辑分离的过程式编程不同，OOP将它们捆绑在一起，使代码更易于维护、扩展和调试。这种范式是现代软件开发的核心，也是爱德思A-Level编程大纲的重要组成部分。

• Key benefits: modularity, reusability, security, and ease of collaboration.
• 主要优势：模块化、可重用性、安全性和易于协作。
• Core building block: the class – a blueprint for creating objects.
• 核心构建块：类——用于创建对象的蓝图。

---

2. Classes and Objects | 类与对象

A class defines a template with attributes and methods; an object is a specific instance of that class. For example, a Car class might have attributes like make and model, and a method start_engine(). Each real-world car (e.g., a red Toyota) is an object instantiated from the class. In Edexcel pseudocode and Python, instantiation uses the constructor.

类定义了一个包含属性和方法的模板；对象则是该类的具体实例。例如，一个Car类可能拥有make和model属性，以及一个start_engine()方法。每辆现实中的汽车（如红色的丰田）都是从该类实例化的对象。在爱德思伪代码和Python中，实例化通过构造函数完成。

• Class definition (Python): class Car: def __init__(self, make, model): self.make = make; self.model = model
• 对象创建：my_car = Car(‘Toyota’, ‘Corolla’)
• Edexcel pseudocode often uses DECLARE myCar : Car or myCar ← NEW Car(‘Toyota’, ‘Corolla’)

---

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

Encapsulation bundles data and the methods that operate on that data within a single unit, restricting direct access to an object’s internal state. This is achieved through access modifiers and getter/setter methods. It prevents accidental interference and ensures that data can only be changed in controlled, valid ways – a cornerstone of robust software design.

封装将数据和操作数据的方法捆绑在一个单元内，限制对对象内部状态的直接访问。这通过访问修饰符以及getter/setter方法实现。它能防止意外干扰，并确保数据只能以受控、有效的方式更改——这是稳健软件设计的基石。

• In Python, a leading underscore _ conventionally indicates a protected member; double underscore __ triggers name mangling for private-like behaviour.
• 在Python中，前导下划线_通常表示受保护成员；双下划线__会触发名称改写以实现类似私有的行为。
• Getters and setters: def get_speed(self): return self.__speed and def set_speed(self, s): if s >= 0: self.__speed = s

---

4. Inheritance and Code Reusability | 继承与代码重用

Inheritance allows a new class (subclass) to derive properties and behaviour from an existing class (superclass). This promotes the DRY (Don’t Repeat Yourself) principle: common functionality is written once in the superclass and inherited by subclasses. In Edexcel, you are expected to demonstrate inheritance using pseudocode or Python, showing how a subclass extends a superclass.

继承允许新类（子类）从已有类（超类）派生属性和行为。这促进了DRY（不要重复自己）原则：公共功能在超类中编写一次，并由子类继承。在爱德思考纲中，考生需使用伪代码或Python展示继承，演示子类如何扩展超类。

• Python syntax: class ElectricCar(Car): – inherits from Car.
• Pseudocode often uses keyword INHERITS: CLASS ElectricCar INHERITS Car
• A subclass can add new attributes/methods and override inherited ones.

---

5. Polymorphism: Method Overloading & Overriding | 多态：方法重载与重写

Polymorphism means ‘many forms’. It allows objects of different classes to be treated uniformly through a common interface. The two key mechanisms are method overriding (a subclass provides its own implementation of a superclass method) and method overloading (multiple methods with the same name but different parameters – less common in Python but significant in pseudocode). Polymorphism enhances flexibility and reduces coupling.

多态意为“多种形态”。它允许通过通用接口统一处理不同类的对象。两种关键机制是方法重写（子类提供自己对超类方法的实现）和方法重载（多个同名但参数不同的方法——在Python中较少见，但在伪代码中很重要）。多态增强了灵活性并减少了耦合。

• Overriding: a Bird subclass might override move() from Animal to fly instead of walk.
• Overloading (pseudocode): FUNCTION add(a,b) RETURNS a+b and FUNCTION add(a,b,c) RETURNS a+b+c
• Python achieves polymorphism through duck typing – any object with the required method can be used interchangeably.

---

6. Abstraction and Interfaces | 抽象与接口

Abstraction hides complex implementation details and exposes only the essential features. In OOP, abstract classes and interfaces define a contract for subclasses without providing a full implementation. Abstract methods have no body; concrete subclasses must implement them. This forces a consistent design and is vital for large systems.

抽象隐藏复杂的实现细节，仅暴露基本特性。在OOP中，抽象类和接口为子类定义了契约，而不提供完整实现。抽象方法没有方法体；具体子类必须实现它们。这强制了一致的设计，对大型系统至关重要。

• Python’s ABC module: from abc import ABC, abstractmethod
• Edexcel pseudocode may use ABSTRACT CLASS and ABSTRACT METHOD keywords.
• Abstract class Shape with abstract method area(); Circle and Rectangle provide concrete implementations.

---

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

A constructor is a special method invoked automatically when an object is created; it initialises the object’s state. In Python, the constructor is __init__. Some languages also have destructors (e.g., __del__) to clean up resources when an object is destroyed. Edexcel expects you to recognise and write constructors to set initial attribute values.

构造函数是在创建对象时自动调用的特殊方法；它初始化对象的状态。在Python中，构造函数是__init__。某些语言还有析构函数（例如__del__），用于在对象销毁时清理资源。爱德思考纲要求考生识别并编写构造函数来设置初始属性值。

• Constructor example: def __init__(self, name, age): self.name = name; self.age = age
• Default constructor (no parameters) can also be defined: def __init__(self): self.data = []
• Destructor syntax: def __del__(self): print(‘Object deleted’)

---

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

Access modifiers control the visibility of class members. Public members are accessible from anywhere; private members are only visible within the class; protected members are accessible within the class and its subclasses. These levels enforce encapsulation and protect data integrity. Python uses naming conventions rather than strict keywords.

访问修饰符控制类成员的可见性。公共成员可从任何地方访问；私有成员仅在类内部可见；受保护成员可在类及其子类中访问。这些级别强制执行封装并保护数据完整性。Python使用命名约定而非严格的关键字。

Modifier	Python Convention	Access Level
Public	name	Anywhere
Protected	_name	Class and subclasses
Private	__name	Only the class

• In pseudocode, Edexcel may use keywords PRIVATE, PUBLIC.
• Use getters/setters to safely expose private data when required.

---

9. Static Members and Class Variables | 静态成员与类变量

Static members belong to the class itself rather than any instance. They are shared across all objects. In Python, class variables are defined directly inside the class (not within __init__), and static methods are declared with the @staticmethod decorator. They are useful for utility functions and tracking shared counters.

静态成员属于类本身，而非任何实例。它们被所有对象共享。在Python中，类变量直接在类内部定义（不在__init__中），静态方法使用@staticmethod装饰器声明。它们对于实用函数和共享计数非常有用。

• Class variable: class Student: count = 0 – accessed as Student.count
• Increment in constructor: Student.count += 1
• Static method: @staticmethod def is_adult(age): return age >= 18

---

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

Relationships between classes go beyond inheritance. Composition represents a ‘part-of’ relationship with strong ownership (e.g., a House contains Rooms; if the House is destroyed, the Rooms are too). Aggregation is a weaker ‘has-a’ relationship (e.g., a Library has Books but Books can exist independently). Association is a generic relationship where objects are aware of each other. Edexcel assesses your ability to choose appropriate relationships.

类之间的关系不仅限于继承。组合表示具有强所有权的“部分-整体”关系（例如，房子包含房间；如果房子被毁，房间也不复存在）。聚合是较弱的“拥有”关系（例如，图书馆拥有书籍，但书籍可以独立存在）。关联是对象相互感知的通用关系。爱德思考纲评估考生选择合适关系的能力。

• Composition in Python: create Room objects inside the House constructor.
• Aggregation: pass Book objects to Library via an add method.
• UML notation often uses filled diamond for composition, hollow diamond for aggregation.

---

11. OOP Design Principles (SOLID basics) | 面向对象设计原则（SOLID基础）

While the full SOLID principles may be beyond the core A-Level, fundamental concepts like Single Responsibility (a class should have only one reason to change) and Open/Closed (open for extension, closed for modification) underpin good OOP practice. Understanding these helps you design maintainable, scalable code – a skill rewarded in high-mark exam questions.

虽然完整的SOLID原则可能超出A-Level核心范围，但像单一职责（一个类应该只有一个引起变化的原因）和开闭原则（对扩展开放，对修改关闭）这样的基本概念支撑着良好的OOP实践。理解这些有助于设计可维护、可扩展的代码——这在高分考题中会得到回报。

• Single Responsibility: separate ReportGenerator from ReportPrinter.
• Open/Closed: use inheritance or composition to add new behaviour without modifying existing code.
• Dependency Inversion: depend on abstractions, not concretions – favour interfaces.

---

12. OOP in Practice: Pseudocode & Python Examples | 实践中的面向对象编程：伪代码与Python示例

Exam questions often require tracing or writing OOP code. Familiarity with both Python and the Edexcel pseudocode style is essential. Below is a consolidated example covering classes, inheritance, polymorphism, and encapsulation. Use such patterns to reinforce your understanding and prepare for the practical programming paper.

考试题目通常要求跟踪或编写OOP代码。熟悉Python和爱德思伪代码风格至关重要。下面是一个涵盖类、继承、多态和封装的综合示例。使用此类模式来巩固理解，并为实践编程试卷做好准备。

• Python example:

  
  class Vehicle:
      def __init__(self, brand):
          self.__brand = brand  # private
      def move(self):
          return 'moving'
  
  class Car(Vehicle):
      def __init__(self, brand, model):
          super().__init__(brand)
          self.model = model
      def move(self):
          return 'driving on road'
  
  class Boat(Vehicle):
      def move(self):
          return 'sailing on water'
  
  def travel(vehicle):
      print(vehicle.move())
  
  c = Car('Toyota', 'Yaris')
  b = Boat('Yamaha')
  travel(c)  # driving on road
  travel(b)  # sailing on water
  

• Edexcel-style pseudocode equivalent would use CLASS Vehicle … ENDCLASS and INHERITS.
• Always note the use of polymorphism with the travel() function handling different objects through a common interface.

---

Published by TutorHao | Programming Revision Series | aleveler.com

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