一、核心概念

1. 对象

• 本质：对象 = 属性（数据） + 方法（行为），是两者封装成的独立整体。

• 组成：对象名、属性、方法三部分。

• 核心思想：以对象为中心，而非以步骤为中心（区别于面向过程）。

• 面向对象程序设计语言C++、Java中，用 this.属性 和 属性 区分同名的成员变量和局部变量。

class Student {
private:
    string name;  // 成员变量
public:
    void setName(string name) {  // 局部变量（参数）
        // this->name 指的是成员变量；右边的 name 是参数
        this->name = name;
    }
};

2. 消息

• 定义：对象间通信的载体。

• 机制：发送消息 → 对象解释 → 执行操作 → 消息传递。

3. 类

• 定义：对一组具有共同特征的对象的抽象描述，刻画这组对象的共同属性与行为。

• 核心关系：类是对象的抽象，对象是类的实例（一个类可创建多个不同实例对象）。

• 类的分类：

  

#include <iostream>
using namespace std;

// 类：人类
class Person {
public:
    string name;
    int age;
    void sayHello() {
        cout << "我是" << name << endl;
    }
};

int main() {
    Person p1;           // 对象
    p1.name = "张三";
    p1.sayHello();       // 输出：我是张三
    return 0;
}

4. 继承

• 定义：基于已有的类（父类 / 基类）创建新类（子类 / 派生类），复用父类的属性与方法。

• 特点：子类可直接继承父类的内容，也可扩展定义自身的属性与方法，实现功能复用与扩展。

class Animal {
public:
    void eat() {
        cout << "吃东西" << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "汪汪叫" << endl;
    }
};

// 使用
Dog dog;
dog.eat();   // 继承自Animal：吃东西
dog.bark();  // 自己的方法：汪汪叫

        继承的类型：

5. 多态

• 定义：同一消息（方法）发送给不同对象时，对象会产生不同的响应结果。

• 实现方式

• 多态的形式：

  

强制多态（类型转换）

int a = 5;
double b = 2.5;
double result = a + b;   // a自动转换为double，变成5.0+2.5

过载多态（函数重载）

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

包含多态（虚函数覆盖）

class Animal {
public:
    virtual void sound() {      // virtual关键字实现动态绑定
        cout << "动物叫" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {      // override可选，表示覆盖
        cout << "汪汪" << endl;
    }
};

// 使用
Animal* a = new Dog();
a->sound();   // 输出：汪汪（运行时决定）
delete a;

参数多态（函数模板/类模板）

// 函数模板
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 类模板
template <typename T>
class Box {
private:
    T item;
public:
    void set(T t) { item = t; }
    T get() { return item; }
};

// 使用
cout << max(3, 5) << endl;        // 输出5
cout << max(3.14, 2.71) << endl;  // 输出3.14

Box<string> box1;
box1.set("hello");

Box<int> box2;
box2.set(123);

6. 绑定

• 定义：将 “过程调用” 与 “执行代码” 关联的过程。

• 分类：

  

class Animal {
public:
    void sound() { cout << "动物叫" << endl; }  // 非虚函数
};

class Dog : public Animal {
public:
    void sound() { cout << "汪汪" << endl; }
};

Animal* a = new Dog();
a->sound();   // 输出：动物叫（静态绑定，按指针类型决定）

        动态绑定需要将方法声明为virtual，否则是静态绑定（编译时决定）。

二、面向对象分析（OOA）

• 核心目标：将数据与功能结合为综合对象，梳理系统中对象的行为与交互关系。

• 核心活动（固定顺序）：

  • 认定对象：从业务场景中提取核心 “名词” 作为对象，明确研究实体。

  • 组织对象：分析对象间的关联关系，将共性对象抽象为类，简化关联模型。

  • 描述对象间的相互作用：梳理对象间的依赖、包含等关系（如对象的组成关系）。

  • 确定对象的操作：定义对象可执行的行为方法。

  • 定义对象的内部信息：明确对象的属性与状态。

• 举例：在线书店系统

  用户可以在线浏览图书、将图书加入购物车、下单购买。

三、面向对象设计（OOD）

• 核心目标：将 OOA 的分析模型转化为可实现的设计模型，定义系统的实现蓝图。

• 核心活动（固定顺序）： 识别类及对象 → 定义属性 → 定义服务（方法） → 识别关系 → 识别包

• 举例：在线书店系统

• 面向对象设计的核心原则

1. 单一职责原则：一个类只负责一个职责。

2. 开放-封闭原则：对扩展开放，对修改封闭。

3. 里氏替换原则：子类型必须能替换父类型。

4. 依赖倒置原则：依赖抽象，不依赖具体实现。

5. 接口分离原则：最小化接口依赖。

6. 迪米特法则（最少知识）：减少类之间的交互。

7. 组合重用原则：优先使用组合而非继承。

        包的设计原则：

        重用发布等价原则：重用粒度 = 发布粒度

        共同封闭原则：包内类应对同一类变化共同封闭

        共同重用原则：重用包中一类即重用所有类

        无环依赖原则：包依赖图中不允许有环

        稳定依赖原则：依赖方向应朝向稳定

        稳定抽象原则：抽象程度与稳定程度一致

四、面向对象测试