封装，继承，多态，抽象_继承抽象封装多态-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_54532893/article/details/148928753

面向对象编程（Object-Oriented Programming，简称 OOP） 是一种编程范式，它通过对象和类来组织代码，重点强调数据的封装、继承和多态。这种编程方法通过模拟现实世界的行为和事物，帮助开发者更好地管理复杂的软件系统。

核心概念

OOP 有四大核心原则，它们是：

封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）
抽象（Abstraction）

这四个概念相辅相成，共同构成了面向对象编程的基础。

1. 封装 (Encapsulation)

定义：封装是将数据（属性）和操作数据的代码（方法）捆绑在一起，隐藏对象的内部实现细节，只暴露必要的接口给外部。封装让对象内部的实现细节对外部不可见，并通过接口控制外部对数据的访问。

好处：

数据保护：内部数据无法直接被外部修改，只能通过方法（接口）访问，从而增强了数据的安全性。
简化接口：外部用户无需了解对象的复杂实现，只需通过公开的方法与对象交互。

class BankAccount {
private:
    double balance;  // balance 是私有的，外部无法直接访问

public:
    // 提供公开方法来访问或修改 balance
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    double getBalance() const {
        return balance;
    }
};

在上面的例子中，balance 是私有的，外部无法直接修改它，只有通过 deposit 和 getBalance 方法才能与其交互。

2. 继承 (Inheritance)

定义：继承是面向对象编程的一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。继承让我们能够复用代码并建立层次结构。

好处：

代码复用：子类可以继承父类的功能，不必重新编写相同的代码。
扩展功能：子类可以在继承父类的基础上新增或重写某些方法。

class Animal {
public:
    void eat() {
        std::cout << "This animal eats food." << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "The dog barks." << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat();  // 继承自 Animal
    myDog.bark(); // Dog 类自己定义的方法
}

在上面的例子中，Dog 类继承了 Animal 类，因此它可以调用 Animal 类的 eat() 方法，而 Dog 类自己添加了 bark() 方法。

3. 多态 (Polymorphism)

这个名字反映了多态的特性：同一个方法或操作，在不同类型的对象上，有不同的执行结果或表现形式。在程序设计中，多态允许使用统一的接口来处理不同类型的对象，而不用关心对象的具体类型。

定义：多态允许不同类的对象以统一的接口调用其特定的实现。多态有两种类型：

编译时多态（静态多态）：通过函数重载或运算符重载实现。
运行时多态（动态多态）：通过继承和虚函数实现。

好处：

灵活性：可以通过相同的接口处理不同类型的对象。
可扩展性：不需要修改已有代码即可扩展新功能。

class Animal {
public:
    virtual void sound() {
        std::cout << "Some animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        std::cout << "Bark!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->sound(); // 输出: Bark!
    animal2->sound(); // 输出: Meow!
}

在上面的例子中，通过基类 Animal 的指针调用 sound() 方法时，根据指针指向的对象的实际类型（Dog 或 Cat），调用的是不同的实现。这就是运行时多态。

4. 抽象 (Abstraction)

定义：抽象是指通过提取对象的共同特征来定义类，而忽略掉不相关的细节。抽象使得程序员能够以更高的层次理解问题，只关注重要的概念，忽略实现的细节。

抽象类：包含纯虚函数的类，不能被实例化。必须由派生类实现所有的纯虚函数。

好处：

简化问题：将复杂的系统或功能分解为较简单的模块。
增加灵活性：不同的实现可以通过统一的接口进行交互。

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数，要求派生类实现
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Square" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw();  // 输出: Drawing Circle
    shape2->draw();  // 输出: Drawing Square
}

在上面的例子中，Shape 是一个抽象类，定义了 draw() 作为纯虚函数，而具体的实现由 Circle 和 Square 类来提供。通过这个抽象类，我们能够统一处理所有类型的图形对象。