C++之对封装、继承、多态的理解

时间：2025-03-14 17:44:03

目录

一、对封装、继承和多态的简单理解：

二、举例：

1、封装的例子：

2、继承的例子：

3、多态的例子：

三、代码实现：

1、封装：（C++或Java实现）

2、继承：（C++或Java实现）

3、多态：（C++或Java实现）

四、以一个简单的实例  剖析“封装”的实现过程：

下面以一个Person类为例，演示如何实现封装。

一、对封装、继承和多态的简单理解：

1、封装：将数据和操作数据的方法放在一起，对外部隐藏实现细节。如：一个类中的私有变量和私有方法就是封装的体现，外部无法直接访问和操作，只能通过公有的接口方法来访问和操作。

2、继承：一个类可以继承另一个类的属性和方法。如：有一个动物类，狗和猫都继承了这个类，它们就可以拥有动物类中的属性和方法，同时也可以添加自己的属性和方法。这样可以避免重复编写相同的代码，提高代码的复用性。

3、多态：同一种行为或方法在不同情况下的不同表现形式。如：一个动物类 有一个“叫”的方法，狗和猫都继承了这个类，但是它们的叫声是不同的，这就是多态的体现。

二、举例：

1、封装的例子：

        假设有一个人类Person，其中有一个私有变量age表示年龄，同时有一个公有方法getAge用于获取年龄。  这样，外部无法直接访问age变量，只能通过getAge方法来获取年龄，实现了封装。

2、继承的例子：

        假设有一个动物类Animal，其中有一个方法叫做“移动”，狗类Dog和猫类Cat都继承了Animal类。这样，狗和猫类就可以拥有Animal类中的“移动”方法，同时也可以添加自己的属性和方法。这样就可以避免重复编写相同的代码，提高代码的复用性，实现了继承。

3、多态的例子：

        假设有一个动物类Animal，其中有一个方法叫做“叫”，这个方法在不同的子类中有不同的实现。比如，狗类Dog的“叫”方法是“汪汪汪”，猫类Cat的“叫”方法是“喵喵喵”。这样在调用“叫”方法时，可以根据实际的对象类型来执行不同的方法，实现多态。

三、代码实现：

1、封装：（C++或Java实现）

#include <iostream>
using namespace std;

class Person {
private:
    int age;
public:
    int getAge() {
        return age;
    }
    void setAge(int a) {
        age = a;
    }
};

int main() {
    Person person;
    (20);
    cout << "Age: " << () << endl;

    return 0;
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        (20);
        ("Age: " + ());
    }
}

class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int a) {
        age = a;
    }
}

2、继承：（C++或Java实现）

#include <iostream>
using namespace std;

class Animal {
public:
    void move() {
        cout << "Animal moves" << endl;
    }
};

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

class Cat : public Animal {
public:
    void meow() {
        cout << "Cat meows" << endl;
    }
};

int main() {
    Dog dog;
    Cat cat;

    ();
    ();

    ();
    ();

    return 0;
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        ();
        ();

        ();
        ();
    }
}

class Animal {
    public void move() {
        ("Animal moves");
    }
}

class Dog extends Animal {
    public void bark() {
        ("Dog barks");
    }
}

class Cat extends Animal {
    public void meow() {
        ("Cat meows");
    }
}

3、多态：（C++或Java实现）

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "Dog barks" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        cout << "Cat meows" << endl;
    }
};

int main() {
    Animal* animal;
    Dog dog;
    Cat cat;

    animal = &dog;
    animal->makeSound();

    animal = &cat;
    animal->makeSound();

    return 0;
}

public class Main {
    public static void main(String[] args) {
        Animal animal;
        Dog dog = new Dog();
        Cat cat = new Cat();

        animal = dog;
        ();

        animal = cat;
        ();
    }
}

class Animal {
    public void makeSound() {
        ("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        ("Dog barks");
    }
}

class Cat extends Animal {
    public void makeSound() {
        ("Cat meows");
    }
}

四、以一个简单的实例  剖析“封装”的实现过程：

        当我们设计一个类时，通常会有一些属性和方法。有些属性和方法可能是需要对外公开的，也就是说其他类可以直接访问这些属性和方法；而有些属性和方法则应该是私有的，不对外公开，只能在类内部使用。

        这种将类的内部实现细节隐藏起来，只对外暴露必要的接口的做法就是封装。

下面以一个Person类为例，演示如何实现封装。

1、首先，我们需要确定person类需要哪些属性和方法。在本例中，我们需要一个age属性和getAge方法。

public class Person {
    private int age;

    public int getAge() {
        return age;
    }
}

2、age属性是私有的，外部无法直接访问，只能通过getAge方法获取。

        因此，我们需要提供一个setAge方法，用于设置age的值。

public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
         = age;
    }
}

3、setAge方法中，我们使用了关键字this。this代表当前对象，即调用该方法的对象。在本例中，表示当前对象的age属性，而age表示方法的参数。

4、现在，我们已经完成了Person类的封装。在其他类中，如果需要使用Person类的age属性，只能通过getAge方法获取，而不能直接访问age属性。

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        (20);
        ("Age: " + ());
    }
}

5、在Main类中，我们创建了一个Person对象，然后使用setAge方法设置age属性的值为20，最后使用getAge方法获取age属性的值，并输出到控制台上。

        这就是封装的基本思路和方法。通过将类的内部实现细节隐藏起来，只对外暴露必要的接口，可以提高代码的安全性和可维护性。

相关文章