C++封装、继承、多态、重载

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 一、封装
• 二、继承
• 三、多态
• 四、重载
• 总结

---

前言

提示：这里可以添加本文要记录的大概内容：

面向对象编程（OOP）的三大特性是封装、继承和多态。重载（Overloading）是OOP中的一种技术，下面分别对这些概念进行详细解释。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、封装

封装就是将数据和方法包装到一起，仅保留必要的接口给外部调用，并且使用修饰符public，protected，private进行对数据和方法的权限进行限制的做法。

• 目的：

  • 提高代码的安全性和可维护性。
  • 隐藏对象的内部实现细节，防止外部直接访问和修改对象的状态。

• 实现方式：

  • 使用访问修饰符（如private、protected、public）来控制属性和方法的访问权限。
  • 提供公共的getter和setter方法来访问和修改属性。

  • public class Person {
        private String name;
        private int age;
        
        // Getter方法
        public String getName() {
            return name;
        }
        
        // Setter方法
        public void setName(String name) {
            this.name = name;
        }
        
        // Getter方法
        public int getAge() {
            return age;
        }
        
        // Setter方法
        public void setAge(int age) {
            this.age = age;
        }
    }
    

二、继承

继承是指一个类（子类）从另一个类（父类）继承属性和方法，子类可以重用父类的代码，也可以添加新的属性和方法或重写父类的方法。

• 目的：

  • 代码重用，提高开发效率。
  • 建立类之间的层次结构，反映现实世界的继承关系。

• 实现方式：

  • 使用public、protected或private继承指定继承方式。
  • 子类可以重用父类的成员，也可以覆盖父类的方法。

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;
    }

    // 重写父类的方法
    void eat() {
        std::cout << "The dog eats dog food." << std::endl;
    }
};

三、多态

3. 多态（Polymorphism）

多态是指同一个方法在不同对象上有不同的表现形式。多态包括编译时多态（重载）和运行时多态（重写）。比如不同子类重写父类的方法，通过父类指针，可以调用不同的函数，实现不同的功能；

• 目的：

  • 增强程序的灵活性和可扩展性。
  • 通过同一接口实现不同的功能。

• 实现方式：

  • 方法重载（编译时多态）：同一个类中多个方法同名但参数不同。
  • 方法重写（运行时多态）：子类重写父类的方法，并通过父类引用调用子类对象的方法。

• class Animal {
  public:
      virtual void makeSound() {
          std::cout << "This animal makes a sound." << std::endl;
      }
  };
  
  class Dog : public Animal {
  public:
      void makeSound() override {
          std::cout << "The dog barks." << std::endl;
      }
  };
  
  class Cat : public Animal {
  public:
      void makeSound() override {
          std::cout << "The cat meows." << std::endl;
      }
  };
  
  void testPolymorphism(Animal &animal) {
      animal.makeSound();  // 根据具体对象类型调用相应的makeSound()方法
  }
  
  int main() {
      Dog dog;
      Cat cat;
      testPolymorphism(dog);  // 输出: The dog barks.
      testPolymorphism(cat);  // 输出: The cat meows.
      return 0;
  }
  

  四、重载

  重载是指在同一个作用域中定义多个同名的函数，但它们的参数列表（参数类型或数量）不同。重载可以提高代码的灵活性和可读性。

  • 目的：

    • 提高代码的灵活性和可读性。
    • 允许同一个函数名在不同情况下有不同的实现。

  • 实现方式：

    • 在同一个类中定义多个同名但参数列表不同的函数。

    • class MathUtils {
      public:
          // 两个参数的add方法
          int add(int a, int b) {
              return a + b;
          }
      
          // 三个参数的add方法
          int add(int a, int b, int c) {
              return a + b + c;
          }
      
          // 不同参数类型的add方法
          double add(double a, double b) {
              return a + b;
          }
      };
      
      int main() {
          MathUtils math;
          std::cout << math.add(1, 2) << std::endl;       // 输出: 3
          std::cout << math.add(1, 2, 3) << std::endl;    // 输出: 6
          std::cout << math.add(1.0, 2.0) << std::endl;   // 输出: 3.0
          return 0;
      }
      

---

总结

• 封装：通过隐藏对象的内部实现细节，只暴露公共接口，提高代码的安全性和可维护性。
• 继承：通过继承父类的属性和方法，实现代码重用和扩展。
• 多态：通过同一接口实现不同的功能，提高代码的灵活性和可扩展性。
• 重载：在同一个类中定义多个同名但参数列表不同的函数，增强函数的灵活性和可读性。