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

爱喝橙汁儿

已于 2024-01-17 11:30:01 修改

阅读量2.8k

点赞数 6

分类专栏： C++ 文章标签： c++ 开发语言 java

于 2023-05-20 14:37:35 首次发布

本文链接：https://blog.csdn.net/qq_53739553/article/details/130780999

版权

C++ 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

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

下面以一个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;
    person.setAge(20);
    cout << "Age: " << person.getAge() << endl;

    return 0;
}

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

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;

    dog.move();
    dog.bark();

    cat.move();
    cat.meow();

    return 0;
}

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

        dog.move();
        dog.bark();

        cat.move();
        cat.meow();
    }
}

class Animal {
    public void move() {
        System.out.println("Animal moves");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    public void meow() {
        System.out.println("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.makeSound();

        animal = cat;
        animal.makeSound();
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("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) {
        this.age = age;
    }
}

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

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

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

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

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