使用VS2012建立MFC工程, 名为OOPMFC.
对象是一个自包含的实体, 用一组可识别的特性和行为来标识. 首先, 实现一个”猫叫”功能:
void COOPMFCDlg::OnBnClickedButtonCat() { AfxMessageBox(_T("喵"),MB_ICONINFORMATION); }将猫叫内容做成一个函数, 放在OOPMFCDlg.cpp里:
LPCTSTR Shout() { return LPCTSTR(L"喵"); } void COOPMFCDlg::OnBnClickedButtonCat() { AfxMessageBox(Shout(),MB_ICONINFORMATION); }效果同上.
公用的函数应该放在公用的地方. 类就是具有相同的属性和功能的对象的抽象的集合.
为此, 建立一个Cat类, 放在Cat.h中.
class Cat { public: LPCTSTR Shout() { return LPCTSTR(L"喵"); } protected: private: };调用时, 改为:
#include "Cat.h" ... void COOPMFCDlg::OnBnClickedButtonCat() { Cat cat; AfxMessageBox(cat.Shout().c_str(),MB_ICONINFORMATION); }给猫取一个名字, 需要设置Name变量, 所以需要自己定义构造函数.
#include <string> class Cat { public: Cat(){Name=L"无名";} Cat(std::wstring name){Name=name;} std::wstring Shout() { return std::wstring(L"我的名字叫")+Name+std::wstring(L" 喵~"); } protected: private: std::wstring Name; };方法重载可以在不改变原方法的基础上新增功能. 例如自己定义的无参数构造函数:
Cat(){Name=L"无名";}属性是一个方法或一对方法, 但在调用他的代码看来,它只是一个字段,即属性适合于以字段的方式使用方法调用的场合. 字段是存储类要满足其设计所需要的数据,字段是与类相关的变量. C#内容, C++没有发现这样的语法. 设置猫叫几声.
class Cat { public: Cat(){Name=L"无名";shoutNum=3;} Cat(std::wstring name){Name=name;} std::wstring Shout() { std::wstring result; for (int i=0;i<shoutNum;i++) { result+=L" 喵 "; } return std::wstring(L"我的名字叫")+Name+result; } int get() { return shoutNum; } void set(int value) { shoutNum=value; } protected: private: std::wstring Name; int shoutNum; };每个对象都包含它能进行操作所需要的所有信息, 这个特性称为封装. 封装的好处: 1. 减少耦合. 2. 类内部的实现可以自由地修改. 3. 类具有清晰的对外接口. 建立的Cat类, 就是封装. 但是共性的东西都在不同的类里面封装起来, 造成代码重复, 容易出错, 而且难以维护. 例如建立一个Dog类, 可以发现几乎所有代码都是一样的. 所以要使用”继承”来把共性的东西放到父类中, 由子类继承这些共性即可.
对象的继承是”is-a”的关系. 子类是父类的特殊化, 有父类的特征, 也有自己的特征. 继承的作用: 1. 子类有父类非private的属性和功能; 2. 子类可以扩展父类没有的属性和功能; 3. 子类可以重写父类已有的功能. protected类成员对子类公开, 但是不对其他类公开.
继承的优点: 1. 公共的部分都放在了父类,使得代码得到了共享,避免了重复. 2. 继承使得修改或者扩展继承而来的实现都较为容易. 继承的缺点: 1. 父类变, 子类不得不变. 继承是类之间的一种强耦合关系 2. 继承会破坏包装, 使得父类实现细节暴露给子类.
新建一个父类Animal类:
#ifndef ANIMAL_H #define ANIMAL_H #include <string> class Animal{ public: Animal() { Name=L"无名"; } Animal(std::wstring name) { Name=name; } int get() { return shoutNum; } void set(int value) { shoutNum=value; } protected: std::wstring Name; int shoutNum; }; #endif重写Cat类:
#include <string> #include "animal.h" class Cat:public Animal { public: Cat(std::wstring name=L"无名",int snum=3): Animal(name) { shoutNum=snum; } std::wstring Shout() { std::wstring result; for (int i=0;i<shoutNum;i++) { result+=L" 喵 "; } return std::wstring(L"我的名字叫")+Name+result; } int get() { return shoutNum; } void set(int value) { shoutNum=value; } //注意继承了shoutNum和Name, 不用再定义了. };重写Dog类:
#include <string> #include "animal.h" class Dog:public Animal { public: Dog(std::wstring name=L"无名",int snum=3): Animal(name) { shoutNum=snum; } std::wstring Shout() { std::wstring result; for (int i=0;i<shoutNum;i++) { result+=L" 汪 "; } return std::wstring(L"我的名字叫")+Name+result; } int get() { return shoutNum; } void set(int value) { shoutNum=value; } //注意继承了shoutNum和Name, 不用再定义了. };客户端调用:
void COOPTestDlg::OnBnClickedButtonCat() { Cat cat(L"咪咪"); AfxMessageBox(cat.Shout().c_str(),MB_ICONINFORMATION); } void COOPTestDlg::OnBnClickedButtonDog() { Dog dog(L"旺财"); AfxMessageBox(dog.Shout().c_str(),MB_ICONINFORMATION); }效果:
多态表示不同的对象可以执行相同的动作, 但是要通过它们自己的实现代码来执行. 多态特点有: 1. 子类以父类的身份出现; 2. 子类在工作时以自己的方式来实现; 3. 子类以父类的身份出现时, 子类特有的属性和方法不可以使用. 多态的实现: 1. 父类成员声明为virtual; 2. 子类重写父类的virtual成员. 3. 注意基类要定义虚析构函数. 否则子类的析构函数不会被调用.(参考: C++继承中的虚析构函数)
“动物叫声比赛”实现: 父类指针指向子类对象, 完成相同的动作Shout. 但是子类对象使用自己的Shout函数. 增加两个button和事件函数:
Animal** arrayAnimal=new Animal*[5]; void COOPTestDlg::OnBnClickedButtonSignin() { arrayAnimal[0]=new Cat(L"小花"); arrayAnimal[1]=new Dog(L"阿毛"); arrayAnimal[2]=new Dog(L"小黑"); arrayAnimal[3]=new Cat(L"娇娇"); arrayAnimal[4]=new Cat(L"咪咪"); GetDlgItem(IDC_BUTTON_Shout)->EnableWindow(TRUE);//使能"叫声比赛"按钮 } void COOPTestDlg::OnBnClickedButtonShout() { for (int i=0;i<5;i++) { AfxMessageBox(arrayAnimal[i]->Shout().c_str(),MB_ICONINFORMATION); } }显示效果:
父类又有新的子类添加进来, 有些类成员函数又需要重写, 造成了大量的代码重复. 把成员函数中的特异部分拿出来写成父类的虚函数, 通过多态方法实现子类需要的不同功能. 重写父类Shout方法, 并新增getShoutSound方法:
std::wstring Shout() { std::wstring result; for (int i=0;i<shoutNum;i++) { result+=getShoutSound(); } return std::wstring(L"我的名字叫")+Name+result; } //protected方法 virtual std::wstring getShoutSound() { return L""; }给Animal类加入Cattle类和Sheep类. 以Cattle类为例:
std::wstring getShoutSound() { return L"哞"; }效果:
把实例化没有任何意义的父类, 改成抽象类. 让抽象类拥有尽可能多的共同代码, 拥有尽可能少的数据. 实现上要注意: 1. 抽象类不能实例化. 所以抽象类是继承的起点. 被继承就是抽象类的唯一用途. 2. 抽象方法必须被子类重写; 3. 抽象类中只要有一个抽象方法, 就是抽象类, 即使还有其他方法存在. C++抽象类定义: http://www.cnblogs.com/dongsheng/p/3343939.html 一、纯虚函数定义. 纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
二、引入原因： 1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。 2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数:
virtual ReturnType Function()= 0;则编译器要求在派生类中必须予以重载以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。 在示例程序中, 将基类的getShoutSound函数改为:
virtual std::wstring getShoutSound()=0;如果定义一个抽象基类的对象, 编译时会报错:
1>------ 已启动生成: 项目: OOPTest, 配置: Debug Win32 ------ 1>正在编译... 1>OOPTestDlg.cpp 1>e:\cppprojects\ooptest\ooptest\ooptestdlg.cpp(113) : error C2259: “Animal”: 不能实例化抽象类 1> 由于下列成员: 1> “std::wstring Animal::getShoutSound(void)”: 是抽象的 1> e:\cppprojects\ooptest\ooptest\animal.h(33) : 参见“Animal::getShoutSound”的声明 1>生成日志保存在“file://e:\CppProjects\OOPTest\OOPTest\Debug\BuildLog.htm” 1>OOPTest - 1 个错误，0 个警告 ========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========如果有子类没有重写抽象方法, 也会报错:
1>------ 已启动生成: 项目: OOPTest, 配置: Debug Win32 ------ 1>正在编译... 1>OOPTestDlg.cpp 1>e:\cppprojects\ooptest\ooptest\ooptestdlg.cpp(115) : error C2259: “Cattle”: 不能实例化抽象类 1> 由于下列成员: 1> “std::wstring Animal::getShoutSound(void)”: 是抽象的 1> e:\cppprojects\ooptest\ooptest\animal.h(33) : 参见“Animal::getShoutSound”的声明 1>生成日志保存在“file://e:\CppProjects\OOPTest\OOPTest\Debug\BuildLog.htm” 1>OOPTest - 1 个错误，0 个警告 ========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========程序效果图如A.9.
某些子类有特殊的成员函数完成特有的功能, 为了实现多态但又不能让父类拥有这种功能. 这时, 可以使用接口类定义一个抽象类, 将接口以纯虚函数的形式封装起来. 让有特殊需求的子类去继承并实现相应的功能. 在应用中, 以接口类的指针指向子类去调用接口类中的这些方法, 就可以实现多态了. 相当于子类同时继承了父类和接口类.
接口是把隐式公共方法和属性组合起来, 以封装特定功能的一个集合. 一旦类实现了接口, 类就可以支持接口所指定的所有属性和成员.声明接口在语法上与声明抽象类完全相同, 但不允许提供接口中任何成员的执行方式.
C#中由interface关键字, C++没有. 要实现相似的功能, 可以使用抽象类代替. 抽象类的所有成员函数都是纯虚函数. (语法参考: http://blog.csdn.net/qq1987924/article/details/7776787)
示例程序中, 加入接口类IChange, 再加入Monkey类, 加入叮当猫MachineCat和孙悟空StongMonkey类:
#ifndef I_CHANGE_H #define I_CHANGE_H #include <string> class IChange { public: virtual std::wstring ChangeThings(std::wstring things)=0; }; #endif #include <string> #include "animal.h" class Monkey:public Animal { public: Monkey(std::wstring name=L"无名",int snum=3): Animal(name) { shoutNum=snum; } std::wstring getShoutSound() { return L"吱"; } int get() { return shoutNum; } void set(int value) { shoutNum=value; } //注意继承了shoutNum和Name, 不用再定义了. }; #ifndef STONE_MONKEY_H #define STONE_MONKEY_H #include "monkey.h" #include "i_change.h" class StoneMonkey: public Monkey,public IChange{ public: StoneMonkey(std::wstring name=L"无名",int snum=3) :Monkey(name,snum){} std::wstring ChangeThings(std::wstring things) { return Monkey::Shout()+L"我会七十二变, 可以变出: "+things; } }; #endif #ifndef MACHINE_CAT_H #define MACHINE_CAT_H #include "cat.h" #include "i_change.h" class MachineCat: public Cat,public IChange { public: MachineCat(std::wstring name=L"无名",int snum=3) :Cat(name,snum){} std::wstring ChangeThings(std::wstring things) { return Shout()+L"我有万能口袋, 我可以变出: "+things; } }; #endif为”变东西”按钮添加事件处理函数:
void COOPTestDlg::OnBnClickedButtonChangethings() { IChange** arrayIChange=new IChange*[2]; arrayIChange[0]=new MachineCat(L"叮当"); arrayIChange[1]=new StoneMonkey(L"孙悟空"); for (int i=0;i<2;i++) { AfxMessageBox(arrayIChange[i]->ChangeThings(L"各种各样的东西").c_str(),MB_ICONINFORMATION); } //IChange* pIChange= new MachineCat(L"叮当"); //AfxMessageBox(pIChange->ChangeThings(L"各种各样的东西").c_str(),MB_ICONINFORMATION); }总结一下:
类是对象的抽象; 抽象类是类的抽象; 接口是对行为的抽象. 如果行为跨越不同类的对象, 可以使用接口; 对于一些相似的类, 可以使用抽象类作为基类 从设计角度讲, 抽象类是从子类中发现了公共的东西, 泛化出父类, 然后让子类继承, 是从下向上,从小到大的设计; 接口是根本不知道子类的存在, 方法如何实现还不确认, 预先定义,是从上往下,从大到小的设计.
