在 C++ 语言中,面向对象编程(OOP)的核心概念包括 封装 、继承 、重写 、重载 和 多态性。
这些是最基础的知识,现在回顾下。以下是这些概念的详细描述和代码示例:
1. 封装(Encapsulation)
定义 :封装是将数据和操作数据的方法(函数)捆绑在一起,形成一个独立的单元(即类)。通过访问控制(如 private
、protected
、public
),封装隐藏了对象的内部实现细节,只暴露必要的接口供外部使用。
示例:
#include <iostream>
#include <string>
class Person
{
private:
std::string name; // 私有属性
int age; // 私有属性
public:
// 公有方法:设置姓名
void setName(const std::string& name)
{
this->name = name;
}
// 公有方法:获取姓名
std::string getName() const
{
return name;
}
// 公有方法:设置年龄
void setAge(int age)
{
if (age > 0)
{ // 数据校验
this->age = age;
}
}
// 公有方法:获取年龄
int getAge() const
{
return age;
}
};
int main()
{
Person person;
person.setName("Alice");
person.setAge(30);
std::cout << "Name: " << person.getName() << std::endl; // 输出: Name: Alice
std::cout << "Age: " << person.getAge() << std::endl; // 输出: Age: 30
return 0;
}
2. 继承(Inheritance)
定义:继承允许一个类(子类)基于另一个类(父类)来创建,子类继承父类的属性和方法,并可以扩展或修改它们。
示例:
#include <iostream>
#include <string>
// 父类
class Animal
{
protected:
std::string name;
public:
Animal(const std::string& name) : name(name) {}
void speak() const
{
std::cout << name << " makes a sound." << std::endl;
}
};
// 子类
class Dog : public Animal
{
public:
Dog(const std::string& name) : Animal(name) {}
// 重写父类方法
void speak() const
{
std::cout << name << " says Woof!" << std::endl;
}
};
int main()
{
Dog dog("Buddy");
dog.speak(); // 输出: Buddy says Woof!
return 0;
}
3. 重写(Override)
定义:重写是指子类重新定义父类中的方法,以改变或扩展其行为。子类的方法名、参数列表必须与父类方法一致。
示例:
#include <iostream>
#include <string>
// 父类
class Animal
{
public:
virtual void speak() const
{
std::cout << "Animal makes a sound." << std::endl;
}
};
// 子类
class Cat : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Cat says Meow!" << std::endl;
}
};
int main()
{
Cat cat;
cat.speak(); // 输出: Cat says Meow!
return 0;
}
4. 重载(Overloading)
定义:重载是指在同一个类中定义多个同名方法,但这些方法的参数列表不同(参数类型、数量或顺序)。
示例:
#include <iostream>
class Math
{
public:
int add(int a, int b) const
{
return a + b;
}
double add(double a, double b) const
{ // 重载方法
return a + b;
}
int add(int a, int b, int c) const
{ // 重载方法
return a + b + c;
}
};
int main()
{
Math math;
std::cout << math.add(1, 2) << std::endl; // 输出: 3
std::cout << math.add(1.5, 2.5) << std::endl; // 输出: 4.0
std::cout << math.add(1, 2, 3) << std::endl; // 输出: 6
return 0;
}
5. 多态性(Polymorphism)
定义:多态性是指同一个方法在不同对象中具有不同的行为。多态性通常通过继承和重写实现,允许父类引用指向子类对象,并调用子类重写的方法。
示例:
#include <iostream>
#include <memory>
// 父类
class Animal
{
public:
virtual void speak() const
{ // 虚函数
std::cout << "Animal makes a sound." << std::endl;
}
};
// 子类
class Dog : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Dog says Woof!" << std::endl;
}
};
// 子类
class Cat : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Cat says Meow!" << std::endl;
}
};
int main()
{
std::unique_ptr<Animal> animal1 = std::make_unique<Dog>();
std::unique_ptr<Animal> animal2 = std::make_unique<Cat>();
animal1->speak(); // 输出: Dog says Woof!
animal2->speak(); // 输出: Cat says Meow!
return 0;
}
总结
概念 | 描述 | 示例 |
---|---|---|
封装 | 隐藏内部实现,暴露必要接口。 | 使用 private 和 public 控制访问权限。 |
继承 | 子类复用父类的属性和方法。 | class Dog : public Animal |
重写 | 子类重新定义父类方法。 | 使用 override 关键字重写虚函数。 |
重载 | 同名方法根据参数列表不同实现不同功能。 | 定义多个同名方法,参数列表不同。 |
多态性 | 同一方法在不同对象中有不同行为。 | 通过虚函数和父类指针实现。 |
这些概念是 C++ 面向对象编程的核心,掌握它们可以帮助你编写更模块化、可复用和易于维护的代码。