第一章 面向对象程序设计基础

第二节 类与对象

概述

面向对象程序设计（Object-Oriented Programming，简称OOP）是现代软件开发的核心思想之一。本节主要围绕类与对象这一核心概念展开，详细讲解类的定义、对象的创建与使用，以及两者之间的关系。通过本节的学习，考生将全面理解类和对象的基本特征、设计原则及其在程序设计中的作用，为后续的继承、多态等高级内容打下坚实基础。

学习目标：

• 理解类和对象的概念及区别
• 掌握类的成员变量和成员函数定义方式
• 熟悉对象的创建、访问和生命周期
• 理解封装的基本思想及实现方式
• 通过实例加深理解类与对象的应用

---

核心概念

1. 类（Class）

类是面向对象程序设计的核心，是具有相同属性和行为的对象的抽象描述。类定义了对象的结构和功能，是对象的模板或蓝图。

• 属性（成员变量）：表示对象的状态或特征，如人的姓名、年龄等
• 行为（成员函数）：表示对象可以执行的操作或功能，如人的走路、说话等

2. 对象（Object）

对象是类的实例，是类的具体表现。每个对象都有独立的属性值，通过调用成员函数实现行为。

3. 封装（Encapsulation）

封装是将数据和操作数据的函数绑定在一起，隐藏内部实现细节，只对外提供接口，保护对象的完整性。

4. 成员变量和成员函数

• 成员变量：存储对象的状态信息
• 成员函数：实现对象的具体操作和行为

5. 构造函数与析构函数

• 构造函数：用于初始化对象，自动调用
• 析构函数：用于清理资源，自动调用

---

原理分析

面向对象设计中，类和对象的关系类似于蓝图和建筑物。类定义了数据的结构和行为，像蓝图一样指导对象的创建，而对象是类的具体实例。通过封装，将数据和操作封装在一起，限制外部直接访问，增强程序的安全性和可维护性。

• 数据封装：通过访问权限控制（如public、private）实现，防止外部直接访问内部数据。
• 对象的内存结构：对象在内存中存储成员变量的值，成员函数不占用对象内存空间，函数代码共享。
• 对象的生命周期：从创建到销毁，构造函数和析构函数负责初始化和清理。

---

详细内容

1. 类的定义与语法

类的定义包括类名、成员变量和成员函数。一般语法结构如下（以C++为例）：

class 类名 {
 访问修饰符:
  类型 成员变量;
  返回类型 成员函数(参数列表);
};

• 访问修饰符：控制成员的访问权限，常用的有public（公有）、private（私有）、protected（保护）
• 成员变量：定义数据成员，用于存储对象状态
• 成员函数：定义操作成员变量的行为

示例：

class Person {
public:
 string name;
 int age;
 void sayHello() {
   cout << "Hello, my name is " << name << endl;
 }
};

2. 对象的创建和访问

创建对象的方式包括：

• 栈上创建：直接定义对象变量，生命周期由作用域决定
• 堆上创建：使用new关键字动态分配内存，生命周期由程序员控制

访问对象成员时，使用点操作符（.）或指针访问符（->）：

Person p1; // 栈上创建
p1.name = "Alice";
p1.sayHello();

Person* p2 = new Person(); // 堆上创建
p2->name = "Bob";
p2->sayHello();
delete p2; // 释放内存

3. 构造函数和析构函数

构造函数是与类同名的特殊函数，用于对象创建时初始化数据成员，支持重载。析构函数以~开头，负责对象销毁前的清理工作。

class Person {
public:
 string name;
 int age;
 Person(string n, int a) { // 构造函数
   name = n;
   age = a;
 }
 ~Person() { // 析构函数
   cout << name << " is destroyed." << endl;
 }
};

4. 封装与访问控制

封装不仅是数据和函数的结合，更重要的是通过访问控制保护数据安全。

• private成员：只能被类内部访问
• public成员：可以被外部访问
• protected成员：主要用于继承关系中访问

通过封装，防止外部代码直接修改对象内部状态，保证数据有效性。

5. 类的成员函数实现方式

成员函数可以定义在类内，也可以在类外实现。类外实现时需使用作用域解析符(::)指定所属类。

class Person {
public:
 void sayHello();
};

void Person::sayHello() {
 cout << "Hello!" << endl;
}

---

实例分析

实例1：学生类设计

背景：设计一个学生类，包含学生姓名、学号、成绩等属性，实现显示学生信息和成绩计算功能。

class Student {
private:
 string name;
 int id;
 float score;
public:
 Student(string n, int i, float s) {
   name = n;
   id = i;
   score = s;
 }
 void display() {
   cout << "Name: " << name << ", ID: " << id << ", Score: " << score << endl;
 }
 float getScore() {
   return score;
 }
};

int main() {
 Student s1("Tom", 1001, 88.5);
 s1.display();
 return 0;
}

分析：

• 通过private修饰成员变量，实现封装
• 构造函数初始化对象属性
• 通过公有函数访问数据，实现安全访问

结论：良好的封装设计保证数据的安全和程序的可维护性。

实例2：图书管理类

背景：设计图书类，包括书名、作者、价格，支持修改价格和显示图书信息。

class Book {
private:
 string title;
 string author;
 double price;
public:
 Book(string t, string a, double p) : title(t), author(a), price(p) {}
 void setPrice(double p) {
   if(p > 0) price = p;
 }
 void show() {
   cout << "Title: " << title << ", Author: " << author << ", Price: " << price << endl;
 }
};

int main() {
 Book b("C++ Primer", "Lippman", 79.5);
 b.show();
 b.setPrice(85.0);
 b.show();
 return 0;
}

分析：

• 通过构造函数初始化
• 价格修改通过成员函数控制，避免非法赋值

结论：封装保证了数据的合理性和安全性。

实例3：计算器类

背景：实现一个简单计算器类，支持加、减、乘、除运算。

class Calculator {
public:
 double add(double a, double b) {
   return a + b;
 }
 double subtract(double a, double b) {
   return a - b;
 }
 double multiply(double a, double b) {
   return a * b;
 }
 double divide(double a, double b) {
   if (b != 0) return a / b;
   else {
     cout << "Error: Division by zero" << endl;
     return 0;
   }
 }
};

int main() {
 Calculator calc;
 cout << calc.add(5, 3) << endl;
 cout << calc.divide(10, 0) << endl;
 return 0;
}

分析：

• 功能明确，操作封装在成员函数中
• 对除零情况进行判断，保证程序稳定

结论：通过类的设计实现功能模块化，易于维护和扩展。

---

常见误区

1. 混淆类和对象的概念

   • 错误：将类当作对象使用
   • 正确：类是模板，对象是实例，必须先定义类再创建对象

2. 成员变量访问权限设置不当

   • 错误：成员变量设置为public，导致外部直接修改，破坏封装
   • 正确：成员变量一般设为private，通过公有成员函数访问

3. 未定义构造函数导致对象成员未初始化

   • 错误：不初始化成员变量，造成程序异常
   • 正确：定义构造函数，保证成员变量初始化

4. 忘记释放动态分配的对象内存

   • 错误：new创建对象后不delete，导致内存泄漏
   • 正确：使用完动态对象后及时释放内存

5. 成员函数定义错误

   • 错误：成员函数实现时未使用作用域解析符而导致编译错误
   • 正确：类外实现成员函数时需加类名::前缀

---

应用场景

1. 软件开发中的数据模型设计
   使用类来抽象现实中的实体，如用户、商品、订单，实现数据和行为的统一管理。

2. 图形界面程序设计
   利用类封装窗口、按钮、事件处理等元素，提高程序模块化和复用性。

3. 游戏开发中的角色和物体管理
   各种游戏角色和物体通过类实例化，方便管理属性和行为。

4. 数据库操作封装
   利用类封装数据库连接和操作，隐藏具体实现细节，提供简洁接口。

5. 嵌入式系统和驱动开发
   类封装硬件设备的控制逻辑，使程序结构清晰，便于维护。

---

知识拓展

• 类的静态成员
  类中可以定义静态成员变量和函数，静态成员属于类本身，而非某个对象，适合存储类级别的属性。

• 友元函数与友元类
  友元允许非成员函数或其他类访问类的私有成员，增加灵活性，但要谨慎使用以保持封装性。

• 深拷贝与浅拷贝
  对象复制时可能涉及指针成员，需明确深拷贝和浅拷贝的区别及实现方式。

• 内联函数
  将小函数定义为内联函数，可以减少函数调用开销，提高效率。

---

总结回顾

本节详细讲解了面向对象程序设计中最基础且最重要的内容——类与对象。通过对类的定义、成员变量和成员函数的介绍，理解了对象的创建与访问方法，明确了封装及其作用。构造函数和析构函数的作用强化了对象的生命周期管理。通过丰富的实例，巩固了理论知识，避免了常见误区，并结合实际应用场景展示了类与对象的广泛应用。掌握本节内容，是顺利学习面向对象程序设计后续章节，提升编程能力的关键一步。

---