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` 方法,实现了多态。

相关推荐
一只小小汤圆1 分钟前
opencascade源码学习之BRepOffsetAPI包 -BRepOffsetAPI_DraftAngle
c++·学习·opencascade
虾球xz9 分钟前
游戏引擎学习第20天
前端·学习·游戏引擎
LateBloomer77718 分钟前
FreeRTOS——信号量
笔记·stm32·学习·freertos
legend_jz21 分钟前
【Linux】线程控制
linux·服务器·开发语言·c++·笔记·学习·学习方法
Komorebi.py22 分钟前
【Linux】-学习笔记04
linux·笔记·学习
嘿BRE31 分钟前
【C++】几个基本容器的模拟实现(string,vector,list,stack,queue,priority_queue)
c++
tangliang_cn42 分钟前
java入门 自定义springboot starter
java·开发语言·spring boot
程序猿阿伟43 分钟前
《智能指针频繁创建销毁:程序性能的“隐形杀手”》
java·开发语言·前端
新知图书1 小时前
Rust编程与项目实战-模块std::thread(之一)
开发语言·后端·rust
威威猫的栗子1 小时前
Python Turtle召唤童年:喜羊羊与灰太狼之懒羊羊绘画
开发语言·python