一个例子告诉你什么是封装，继承和多态

淩亂°似流年 2022-12-19 00:52 159阅读 0赞

面向对象的三大特性：封装，继承和多态；

封装：将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系。

继承：子类可以拥有父类的属性和方法；

多态：以说是“一个接口，多种实现”或者说是父类的引用变量可以指向子类的实例，被引用对象的类型决定调用谁的方法，但这个方法必须在父类中定义

定义五花八门，所以定义不重要，重在理解和应用，接下来我们通过实例来说明这三个特性；

如果面试官给你一个问题，请实现加、减、乘和除四个功能；

第一种最简便的方法，三个特性一个也没有体现……

1.  `//main.cpp`
2.   
3.  `double PlusMethod(double param1,double param2)`
4.  `{`
5.  `   return   param1+param2;`
6.  `}`
7.  `double MinusMethod(double param1,double param2)`
8.  `{`
9.  `   return   param1-param2;`
10. `}`
11. `double MultyMethod(double param1,double param2)`
12. `{`
13. `   return   param1*param2;`
14. `}`
15. `double DividMethod(double param1,double param2)`
16. `{`
17. `if(param2==0)`
18. `{`
19. `return 0;`
20. `}`
21.  
22. `   return   param1/param2;`
23. `}`
24. `main()`
25. `{`
26. `double result ;`
27.  
28. `result =PlusMethod(2,3);`
29.  
30. `result =MinusMethod(2,3);`
31.  
32. `result =MultyMethod(2,3);`
33.  
34. `result =DividMethod(2,3);`
35. `}`

第二种方法，体现封装的特性；封装就是抽象出类，类含有属性和方法

封装的好处就是代码功能分离；代码清晰易读；

我们封装一个MyMath类

1.  `//MyMath.h`
2.  `class MyMath`
3.  `{`
4.  `public:`
5.  `MyMath();`
6.  `~MyMath();`
7.  `public:`
8.  `static double PlusMethod(double param1, double param2);`
9.  `static double MinusMethod(double param1, double param2);`
10. `static double MultyMethod(double param1, double param2);`
11. `static double DividMethod(double param1, double param2);`
12. `};`
13. `//MyMath.cpp`
14. `#include "MyMath.h"`
15.  
16.  
17. `MyMath::MyMath()`
18. `{`
19. `}`
20.  
21.  
22. `MyMath::~MyMath()`
23. `{`
24. `}`
25.  
26. `double MyMath::PlusMethod(double param1, double param2)`
27. `{`
28. `return param1+ param2;`
29. `}`
30.  
31. `double MyMath::MinusMethod(double param1, double param2)`
32. `{`
33. `return param1-param2;`
34. `}`
35.  
36. `double MyMath::MultyMethod(double param1, double param2)`
37. `{`
38. `return param1*param2;`
39. `}`
40.  
41. `double MyMath::DividMethod(double param1, double param2)`
42. `{`
43. `if (param2==0)`
44. `{`
45. `return 0;`
46. `}`
47. `return param1 / param2;`
48. `}`
49.

1.  `//main.cpp`
2.   
3.  `#include "MyMath.h"`
4.   
5.  `int main()`
6.  `{`
7.  `double result;`
8.   
9.  `result = MyMath::PlusMethod(2, 3);`
10.  
11. `result = MyMath::MinusMethod(2, 3);`
12.  
13. `result = MyMath::MultyMethod(2, 3);`
14.  
15. `result = MyMath::DividMethod(2, 3);`
16. `return 0;`
17. `}`

第三种方法：体现封装和继承

继承的优势是 代码复用高；

创建基类或者说父类 Operation  ；

注意：

1，基类的析构函数必须为虚函数

2，成员变量要初始化

1.  `//Operation.h`
2.  `class Operation`
3.  `{`
4.  `public:`
5.  `Operation();`
6.  `virtual ~Operation();`
7.  `virtual void SetFirstNum(double param);`
8.  `virtual void SetSecondNum(double param);`
9.  `protected:`
10. `double m_firstNum;`
11. `double m_SecondNum;`
12. `};`
13.  
14.  
15. `//Operation.cpp`
16. `#include "Operation.h"`
17.  
18. `Operation::Operation():`
19. `m_firstNum(0), m_SecondNum(0)`
20. `{`
21. `}`
22.  
23. `Operation::~Operation()`
24. `{`
25. `}`
26.  
27. `void Operation::SetFirstNum(double param)`
28. `{`
29. `m_firstNum = param;`
30. `}`
31.  
32. `void Operation::SetSecondNum(double param)`
33. `{`
34. `m_SecondNum = param;`
35. `}`

接下来 创加减乘除四个类；这里仅写加和减两个类，其余两个类相似。

加法类

//MyMinusFunc.h

\#include "Operation.h"  
class MyMinusFunc:public Operation  
\{  
public:  
    MyMinusFunc();  
    ~MyMinusFunc();  
    double GetResult();  
\};

//MyMinusFunc.cpp

\#include "MyMinusFunc.h"

MyMinusFunc::MyMinusFunc()  
\{  
\}

MyMinusFunc::~MyMinusFunc()  
\{  
\}

double MyMinusFunc::GetResult()  
\{  
    return m\_firstNum - m\_SecondNum;  
\}  
减法类：

//MyPlusFunc.h

\#include "Operation.h"  
class MyPlusFunc:public Operation  
\{  
public:  
    MyPlusFunc();  
    ~MyPlusFunc();  
    double GetResult();  
\};  
//MyPlusFunc.cpp

\#include "MyPlusFunc.h"

MyPlusFunc::MyPlusFunc()  
\{  
\}

MyPlusFunc::~MyPlusFunc()  
\{  
\}

double MyPlusFunc::GetResult()  
\{  
    return m\_firstNum + m\_SecondNum;  
\}  
//main.cpp

\#include "MyMath.h"  
\#include "MyPlusFunc.h"  
\#include "MyMinusFunc.h"

int main()  
\{  
    double result;

result = MyMath::PlusMethod(2, 3);

result = MyMath::MinusMethod(2, 3);

result = MyMath::MultyMethod(2, 3);

result = MyMath::DividMethod(2, 3);  
    MyMinusFunc minus;  
    minus.SetFirstNum(3);  
    minus.SetSecondNum(2);  
    result=    minus.GetResult();

MyPlusFunc plus;  
    plus.SetFirstNum(3);  
    plus.SetSecondNum(2);  
    result = plus.GetResult();

return 0;  
\}  
这个实例很明白的说明了继承的特性，代码复用也是显而易见地；

这篇太长了  多态的特性在下篇讲，请继续关注……

程序源码 下载  [https://download.csdn.net/download/wangjianbo09/10636627][https_download.csdn.net_download_wangjianbo09_10636627]

[https_download.csdn.net_download_wangjianbo09_10636627]: https://download.csdn.net/download/wangjianbo09/10636627