目录
一、对封装、继承和多态的简单理解：
二、举例：
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;
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属性的值，并输出到控制台上。
这就是封装的基本思路和方法。通过将类的内部实现细节隐藏起来，只对外暴露必要的接口，可以提高代码的安全性和可维护性。
