c++学习:封装继承多态

目录

封装

封装的定义

封装的好处

封装的实例

继承

继承的定义

继承的好处

继承的实例

多态

多态的定义

多态的好处

多态的实例


封装

封装的定义

封装是面向对象编程(OOP)中的一个核心概念,它指的是将数据(属性)和操作这些数据的函数(方法)结合在一起的过程,以此来模拟现实世界中的实体。在C++中,封装主要通过类(class)和结构体(struct)来实现,同时使用访问修饰符(public、protected、private)来控制成员的可见性。

这样可以隐藏类的内部实现细节,只暴露出限定的接口供外界访问。

封装的好处
  • **数据隐藏**:通过隐藏内部实现细节,只暴露必要的接口,提高代码的安全性。
  • **模块化**:将功能划分为独立的模块,有助于降低复杂性,提高代码的可维护性。
  • **接口设计**:设计清晰、简单且一致的接口,使库更容易使用。
  • **代码重用**:封装可以提高代码的可重用性,因为其他开发者可以在不了解具体实现的情况下使用这些类和对象。
封装的实例
cpp 复制代码
#include <iostream>
#include <string>

class Animal {
private:
    std::string name;
    int age;

public:
    // 设置名字的方法
    void setName(const std::string& n) {
        name = n;
    }

    // 设置年龄的方法
    void setAge(int a) {
        age = a;
    }

    // 获取名字的方法
    std::string getName() const {
        return name;
    }

    // 获取年龄的方法
    int getAge() const {
        return age;
    }
};

int main() {
    Animal dog;
    dog.setName("Buddy");
    dog.setAge(3);

    std::cout << "Name: " << dog.getName() << ", Age: " << dog.getAge() << std::endl;

    return 0;
}

在这个示例中,我们定义了一个名为 `Animal` 的类,它具有两个私有成员变量 `name` 和 `age`。我们没有直接访问这些变量,而是通过公共成员函数(`setName`、`setAge`、`getName` 和 `getAge`)来设置和获取它们的值。这就是封装的一个典型应用。

继承

继承的定义

继承是面向对象编程中的一个核心概念,它允许一个类(称为子类或派生类)继承另一个类(称为父类或基类)的属性和方法。通过继承,子类可以重用父类的代码,减少重复代码,提高代码的可维护性和可扩展性。

继承的基本语法

在C++中,继承的基本语法如下:

cpp 复制代码
class ParentClass {
    // 父类的属性和方法
};

class ChildClass : public ParentClass {
    // 子类的属性和方法
};

在这个示例中,`ChildClass` 是 `ParentClass` 的子类,它可以访问 `ParentClass` 中的所有公共方法和属性。

继承的好处
  • **代码重用**:子类可以重用父类的代码,避免重复编写相似的代码。
  • **易于维护**:当父类中的代码需要修改时,只需修改父类,所有子类将自动继承这些更改。
  • **扩展性强**:可以轻松地添加新子类而不需要修改现有代码。
继承的类型

C++支持三种继承类型:

  • **公有继承(Public Inheritance)**:子类可以访问父类的所有公共成员和保护成员。
  • **保护继承(Protected Inheritance)**:子类可以访问父类的所有保护成员,但父类的公共成员对子类不可见。
  • **私有继承(Private Inheritance)**:子类只能访问父类的私有成员,父类的公共和保护成员对子类不可见。
继承的实例
cpp 复制代码
#include <iostream>
#include <string>

// 基类 Animal
class Animal {
protected:
    std::string name;
    int age;

public:
    // 设置名字的方法
    void setName(const std::string& n) {
        name = n;
    }

    // 设置年龄的方法
    void setAge(int a) {
        age = a;
    }

    // 获取名字的方法
    std::string getName() const {
        return name;
    }

    // 获取年龄的方法
    int getAge() const {
        return age;
    }
};

// 派生类 Dog,继承自 Animal
class Dog : public Animal {
public:
    // Dog 类特有的方法
    void bark() const {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.setName("Buddy");
    myDog.setAge(3);
    myDog.bark();

    std::cout << "Name: " << myDog.getName() << ", Age: " + std::to_string(myDog.getAge()) << std::endl;

    return 0;
}

在这个示例中,我们定义了一个名为 `Animal` 的基类,它具有两个受保护的成员变量 `name` 和 `age`,以及一些公共成员函数(`setName`、`setAge`、`getName` 和 `getAge`)。然后,我们定义了一个名为 `Dog` 的派生类,它继承自 `Animal` 类。`Dog` 类具有一个特有的方法 `bark`。在 `main` 函数中,我们创建了一个 `Dog` 类的对象,并调用了它的方法。

多态

多态的定义

多态 (Polymorphism):多态是指允许不同的类具有相同的接口,但具体实现方式可能不同。这使得我们可以使用相同的接口来操作不同的对象,而具体的行为由对象的实际类型决定。

C++ 中实现多态主要通过虚函数(virtual function)和纯虚函数(pure virtual function)来实现。

多态的好处
  • **代码灵活性**:多态允许我们使用相同的接口来操作不同的对象,而具体的行为由对象的实际类型决定。
  • **易于扩展**:当需要添加新的派生类时,只需实现相应的接口,而不需要修改现有代码。
  • **代码解耦**:多态有助于降低代码间的耦合度,提高代码的可维护性。
多态的实例
cpp 复制代码
#include <iostream>
#include <string>

// 基类 Animal
class Animal {
public:
    // 虚函数 makeSound,实现多态
    virtual void makeSound() const {
        std::cout << "The animal makes a sound." << std::endl;
    }
};

// 派生类 Dog,继承自 Animal
class Dog : public Animal {
public:
    // 重写基类的 makeSound 方法
    void makeSound() const override {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

// 派生类 Cat,继承自 Animal
class Cat : public Animal {
public:
    // 重写基类的 makeSound 方法
    void makeSound() const override {
        std::cout << "Meow! Meow!" << std::endl;
    }
};

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

    animal1->makeSound(); // 输出 "Woof! Woof!"
    animal2->makeSound(); // 输出 "Meow! Meow!"

    delete animal1;
    delete animal2;

    return 0;
}

在这个示例中,我们定义了一个名为 `Animal` 的基类,它具有一个虚函数 `makeSound`。然后,我们定义了两个派生类 `Dog` 和 `Cat`,它们分别重写了 `makeSound` 方法。在 `main` 函数中,我们创建了两个 `Animal` 类型的指针,分别指向 `Dog` 和 `Cat` 类的对象,并调用了它们的 `makeSound` 方法。由于 `makeSound` 是虚函数,因此实际调用的是派生类的 `makeSound` 方法,实现了多态。

相关推荐
孤邑10 分钟前
【Linux】网络编程3
linux·服务器·网络·笔记·学习
夏天匆匆2过13 分钟前
linux性能提升之sendmmsg和recvmmsg
linux·c++·单片机·网络协议·udp·tcp
kali-Myon13 分钟前
ctfshow-web入门-反序列化(web260-web264)
前端·学习·web安全·php·web
羊小猪~~15 分钟前
前端入门一之ES6--面向对象、够着函数和原型、继承、ES5新增方法、函数进阶、严格模式、高阶函数、闭包
开发语言·前端·javascript·css·vscode·html·es6
Diamond技术流16 分钟前
从0开始学习Linux——文件管理
linux·运维·学习·安全·文件·权限·极限编程
Jack黄从零学c++22 分钟前
设计模式——策略模式(c++)
c++·设计模式·策略模式
极客代码36 分钟前
【Python TensorFlow】进阶指南(续篇一)
开发语言·人工智能·python·深度学习·ai·tensorflow
love_and_hope36 分钟前
Pytorch学习--神经网络--完整的模型验证套路
人工智能·pytorch·python·神经网络·学习·1024程序员节
南城花随雪。44 分钟前
Spring框架之模板方法模式 (Template Method Pattern)
java·开发语言·模板方法模式