面向对象程序的设计说明

面向对象程序设计

结构化程序设计的基本容：

1.结构的类型：顺序、分支、循环

2.结构化程序设计思想：利用过程或函数来抽象和模拟客观现实。

3.结构化程序设计方法：

1)重点放在如何实现细节过程方面，将数据与函数分开。

2)形式：主模块+若干个子模块（如Ｃ：main()+子函数）。

4.特点：自顶向下，逐步求精——功能分解。

5.缺点：效率低，是手工作坊式的编程。

6.结构化程序的问题——数据与算法分离，程序数据和操作数据的函数

是分离的。

面向对象程序设计观点：

1.自然界是由各种各样的实体（对象）所组成，每种对象都有自己的部

状态和运动规律，不同对象之间的相互联系和相互作用就构成了各种不同的系统，进而构成整个客观世界。

2.程序设计方法：使用面向对象的观点来描述模仿并处理现实问题。

3.要求：高度概括、分类和抽象。

4.目的：实现软件设计的产业化。

5.基本概念：

1)对象：用来描述客观事物的一个实体，它是构成系统的一个基本单

元。一个对象具有一组属性和行为。

实体对象一台计算机

抽象对象一项计划

2)对象构成要素：

对象标识符：是对象的名称，用来区别于其他对象。

属性：是用来描述对象静态特征的一个数据项。

行为：是用来描述对象动态特征和行为的操作。

3)消息（Message）用于描述事件发生的信息。消息是对象之间发出

的行为请求。多个消息构成一个事件(Event)。对象之间通过传递消

息相互影响。

对象示例：一个“学生”对象的例子

对象名：

学生

属性：

学号：123456

：令狐冲

年龄：18

专业：信管

行为：

修改学号、、专业、年龄等等

对象示例：一个“课程”对象的例子：

对象名：

课程

属性：

课程号：123456

课程名：程序设计

任课教师：莫名

选课要求：学时：48

行为：

获取并修改课程名、课程号、学时数、选课要求、任课教师

等

4)类：是具有相同属性和行为的一组对象的集合，它为属于该类的全

部对象提供统一的抽象描述，是对象集合的再抽象。

5)类和对象的关系：类（抽象定义）对象（实例）

6)类对象举例

学生学生王强

课程C++程序设计

类型变量，如C语言中的int和int x;

7)类的实例——用类定义的类变量，即对象。类是对多个特性相同的

对象实例的抽象，所以同一类的不同实例之间必有：

相同的操作集合

相同的属性集合

不同的对象名，分配有不同的存储空间。

8)类的确定与划分：

类的确定——对所遇到的对象进行分析、归纳，根据共同的特征来

确定一个类。

类的确定的方法：

判断是否有一个以上的实例

判断类的实例中是否有绝对的不同点

9)类的划分不是绝对的，可以根据不同的实际需要确定不同的类。

面向对象程序设计的特点：

1.抽象性：

抽象（abstract）是指有意忽略问题的某些细节和与当前目标无关的方面，以便把问题的本质表达得更清楚。

2.封装性：

1)封装encapsulation——将数据和与这个数据有关的操作集合在一

起，形成一个实体——对象，且尽可能隐藏对象的部细节。

2)特点：

具有一个清楚的边界，对象的所有私有数据、部程序（成员函数）细节都被固定在这个边界。

具有一个接口，描述了对象之间的相互作用、请求和响应——消息。

对象部的实现代码受到封装壳的保护，其它对象不能直接修改本对象所拥有的数据和代码。

封装的单位是对象。

3)封装性：

从外面看只能看到对象的外部特性，即能够受理哪些信息，具有哪些处理能力；对象的部，即处理能力的实行和部状态，

对外是不可见的。

从外面不能直接使用对象的处理能力，也不能直接修改其部状态，对象的部状态只能由其自身改变。

4)封装的优点：

降低部件间的耦合度，提高部件的独立性

具有隐藏性和安全性(如银行的账户)

易于维护(由于数据独立，易于发现问题)

封装将对象的使用者与设计者分开，使用者只需要通过接口访问对象，不必了解对象的部细节，提高了软件复用。

5)封装的缺点：

需要更多的输入输出函数。

6)抽象与封装形成了程序接口与实现的分离。

3.继承性：继承性是指特殊类的对象拥有其一般类的属性和行为的特性。

1)继承：继承是一种联结类与类的层次模型。对象类之间的相交关系，

使得某类对象可以继承另外一类对象的特征和功能。

2)类间具有继承关系的特性：

类间具有共享特征(包括数据和程序代码的共享)：遗传

类间具有细微差别或新增部分(包括非共享的程序代码和数据)：变异

类间具有层次结构（如同人类通过继承构成了家族关系一样）

3)继承分类：

从继承源上划分：单继承（一个派生类只有一个基类）、多继承（一个派生类有多个基类）

从继承容上划分：取代继承、包含继承、受限继承、特化继承。

4)继承的作用：

实现软件的可重用性

实现软件的独立性

增加软件的可维护性

2)继承与封装的关系：

封装是指对象的封装，在对象中数据和操作总是包裹在一起

的，继承不会影响对象的这种封装性，但无限制的派生继承会

在一定程度上损害对象中数据的隐蔽性。

封装使类定义中实现的代码可以用于该类的各个实例（对象）中，实现了动态共享代码；继承使得派生类能与基类共享基类

中实现的代码，实现了静态共享代码。

3)类的层次：

由一个类可以派生出任意多个派生类，这样就形成了类的层次关系，这是现实世界中事物的分类问题在计算机中的解形式。

4)继承的优势：

能清晰体现相关类间的层次结构关系。

有效地址提高了程序的可重用性，减小了程序代码的冗余度。

增强了程序的一致性，减少了程序模块间的接口和界面，使程序更易维护。

继承是自动传播程序代码的有力工具。

继承是新类构造、建立和扩充的有效手段。

继承具有传递性。如果类C继承类B，类B继承类A，则类C 继承类A。

“站在巨人的肩头上”。用户在开发新系统时不必从零开始，可以继承原有相似功能或者从类库中选取需要的类，再派生新

类。

5)例：人类按职业划分的一种继承关系

4.多态性：

1)多态polymorphism：多态是指类中同一函数名对应多个具有相似

功能的不同函数。对象根据所接受的消息而做出动作，同样的消息

为不同的对象接受时可导致完全不同的行动，该现象称为多态性。

简单地说：单接口，多实现。

举例：

sqrt_i (int i)，sqrt_f (float f)

sqrt (int i)，sqrt (float f)

2)多态性：指可以使用相同的调用方式来调用这些具有不同功能的同

名函数的特性。

3)作用：

减轻程序员负担

降低程序员出错机率

4)多态性的实现：

运行时多态性：虚函数

编译时多态性：重载

重载

函数重载：是指在同一作用域的若干个参数特征不同的函数可以

使用相同的函数名字。

运算符重载：是指同一个运算符可以施加于不同类型的操作数上

面。

优点：重载进一步提高了面向对象系统的灵活性和可读性。

5)例：下图中同名函数person( )作用在Student、Teacher等不同

类上时，将执行不同的操作，这就是多态。

面向对象与面向过程程序设计比较：

1.面向过程程序设计的基本特点：

1)按层次组织模块。

2)每一模块只有一个入口，一个出口。

3)代码和数据分离，即程序=数据结构+算法。

4)方法：自顶向下，逐步求精，模块化

2.面向对象程序设计：

1)它将数据和操作数据的过程（函数）绑在一起，形成一个相互依存、

不可分离的整体（即对象），从同类对象中抽象出共性，形成类。

2)同类对象中的数据原则上只能用本类提供的方法（成员函数）进行

处理。类通过封装将接口与实现分离开来，通过接口与外界联系。

对象之间通过消息进行通信。

3.两种程序方法的对比：

面向对象程序设计将数据和操作数据的程序代码绑在一起构成对象，具有更好的可维护性，因某类对象数据的改变只会引起该类对象操作代码的改变，而与其他类型的对象无关，这就把程序代码的修改维护局限在一个很小的围。

4.面向对象程序设计的优点：

1)符合人们习惯的思维方法，便于分解大型的复杂多变的问题。由于

对象对应于现实世界中的实体，因而可以很自然地按照现实世界中

处理实体的方法来处理对象，软件开发者可以很方便地与问题提出

者进行沟通和交流。

2)易于软件的维护和功能的增减。对象的封装性及对象之间的松散组

合，都给软件的修改和维护带来了方便。采用面向对象思想设计的

结构，可读性高，由于继承的存在，即使改变需求，那么维护也只

是在局部模块，所以维护起来是非常方便和较低成本的。

3)可重用性好。重复使用一个类（类是对象的定义，对象是类的实例

化），可以比较方便地构造出软件系统，加上继承的方式，极提高了

软件开发的效率。

4)与可视化技术相结合，改善了工作界面。随着基于图形界面操作系

统的流行，面向对象的程序设计方法也将深入人心。它与可视化技

术相结合，使人机界面进入GUI时代。

5)质量高。在设计时，可重用现有的，在以前的项目的领域中已被测

试过的类使系统满足业务需求并具有较高的质量。

6)扩展方便。由于继承、封装、多态的特性，自然设计出高聚、低耦

合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。

三种常用面向对象程序设计语言简介：

1.混合型面向对象程序设计语言C++

2.纯面向对象程序设计语言Java

3.可视化程序设计语言Visual Basic

//四人中有一人中了奖，小问这四人时，回答如下：

//A：不是我

//B：是C

//C：是D

//D：C胡说

//已知其中三人说的是真话，一人说假话，试根据这些信息找出中奖者

#include

void main()

{

int k=0,count=0,sum=0;

char thisman;

for(k=0;k<=3;k++)

{

thisman='A'+k;

sum=(thisman!='A')+(thisman=='C')+(thisman=='D')+(thisman!='D');

if(sum==3)

{

printf("中奖者为：%c\n",thisman);

count++;

}

}

if(count==0)

printf("无解！\n");

else

printf("共有：%d种符合条件的情况！\n",count);

}

//四人中有一人中了奖，小问这四人时，回答如下：

//A：不是我

//B：是C

//C：是D

//D：C胡说

//已知其中三人说的是真话，一人说假话，试根据这些信息找出中奖者

#include

class Find

{

public:

void answer()

{

int k=0,count=0,sum=0;

char thisman;

for(k=0;k<=3;k++)

{

thisman='A'+k;

sum=(thisman!='A')+(thisman=='C')+(thisman=='D')+(thisman!='D');

if(sum==3)

{

printf("中奖者为：%c\n",thisman);

count++;

}

}

if(count==0)

printf("无解！\n");

else

printf("共有：%d种符合条件的情况！\n",count);

}

};

void main()

{

Find it;

it.answer();

}

//四人中有一人中了奖，小问这四人时，回答如下：

//A：不是我

//B：是C

//C：是D

//D：C胡说

//已知其中三人说的是真话，一人说假话，试根据这些信息找出中奖者

#include

class Find

{

public:

void answer()

{

int k=0,count=0,sum=0;

char thisman;

for(k=0;k<=3;k++)

{

thisman='A'+k;

sum=(thisman!='A')+(thisman=='C')+(thisman=='D')+(thisman!='D');

if(sum==3)

{

printf("中奖者为：%c\n",thisman);

count++;

}

}

if(count==0)

printf("无解！\n");

else

printf("共有：%d种符合条件的情况！\n",count);

}

Find()

{

printf("--------------欢迎使用--------------\n");

}

};

void main()

{

Find it;

it.answer();

}

Ｃ＋＋6.0教学资料

1.//C++程序的基本结构

#include

#define PI 3.1415926

void main()

{

double r,area;

cout<<"输入圆半径：";

cin>>r;

area=PI*r*r;

cout<<"圆面积为："<

}

2.//结构体示例

#include

struct stu_score

{

char name[12];

char NO[9];

float score[3];

} stuone={"明","21020501",{80,85,85}};

void main()

{

double aver;

aver=(stuone.score[0]+stuone.score[1]+stuone.score[2])/3;

cout<<"平均成绩为："<

}

3.算术运算符：加（+）、减（-）、乘（*）、除（/）、模运算符（%）

4.赋值运算符：

简单赋值：=

复合算术赋值：+=、-=、*=、/=、%=

5.关系运算符：>、<、=、>=、<=、!=

6.自增（++）自减（--）运算符

7.逻辑运算符：与（&&）、或（||）、非（!）

按位与（&）

按位或（|）

按位异或（^）

取反（~）

左移（<<）

右移（>>）

8.符合位运算符赋值：&=、|=、^=、>>=、<<=

9.sizeof运算符

10.逗号运算符

11.存管理运算符：

new：

double *p;

p=new double;

int *p;

p=new int(40);//开辟60个int型存单元

delete：

delete p;

12.//带默认参数值的函数

#include

void display(int a,int b=2,int c=3)

{

cout<<"a="<

}

void main()

{

display(1);

display(1,5);

display(1,5,7);

}

13.//函数重载

#include

int sum(int a,int b)

{

return a+b;

}

int sum(int a,int b,int c)

{

return a+b+c;

}

double sum(double a,double b)

{

return a+b;

}

double sum(double a,double b,double c) {

return a+b+c;

}

void main()

{

cout<

cout<

cout<

cout<

}

14.//函数参数的指针传递

#include

void swap(int *x,int *y)

{

int temp;

temp=*x;

*x=*y;

*y=temp;

}

void main()

{

int a(10),b(100);

cout<<"交换前："<

swap(&a,&b);

cout<<"交换后："<

}

15.//函数参数的引用传递（引用实质是已定义变量的别名）

#include

void swap(int &x,int &y)

{

int temp;

temp=x;

x=y;

y=temp;

}

void main()

{

int a(10),b(100);

cout<<"交换前："<

swap(a,b);

cout<<"交换后："<

}

16.变量作用域

1)程序级：包含组成该程序的所有文件。属于程序级作用域的有外部函数和外部变

量

2)文件级：仅在定义它的文件有效。属于文件级作用域的有部函数和外部静态变量

3)函数级：仅在定义它的函数体有效。属于函数级作用域的有函数的形参和函数定

义的自动类变量

4)块级：属于块级的有定义在分程序、if语句、switch语句及循环语句中的自动

变量、寄存器类变量和部静态变量

其中作用域属于前两类的变量习惯上称为全局变量，属于后两类的称为局部变量。

另外有以下说明：

1)部函数的定义用关键字static实现，外部函数的定义用关键字extern实现，静

态变量（包括部的及外部的）用关键字static实现，函数的默认类型为外部函数

2)外部变量、外部静态变量、部静态变量定义时有默认值：int型的为0；浮点型的

为0.0；char型的为空

17.//用类计算平均分

#include

#include

class CStuScore

{

public:

char name[7];

char no[9];

CStuScore(float s0,float s1,float s2)

{

fScore[0]=s0;

fScore[1]=s1;

fScore[2]=s2;

}

void SetScore(float s0,float s1,float s2)

{

fScore[0]=s0;

fScore[1]=s1;

fScore[2]=s2;

}

~CStuScore()

{

cout<<"-----------------------------------\n";

}

float GetAverage();

void ShowScore()

{

cout<

}

private:

float fScore[3];

};

float CStuScore::GetAverage()

{

return (float)((fScore[0]+fScore[1]+fScore[2])/3);

}

void main()

{

CStuScore one(60,70,74);

strcpy(https://www.360docs.net/doc/da1278883.html,,"明");

strcpy(one.no,"21010101");

one.ShowScore();

one.SetScore(60,88,64);

one.ShowScore();

}

18.//对象成员的初始化

#include

class CPoint

{

public:

CPoint(int x,int y)

{

nPosX=x;

nPosY=y;

}

void ShowPos()

{

cout<<"当前位置：x="<

}

private:

int nPosX,nPosY;

};

class CSize

{

public:

CSize(int l,int w)

{

nLength=l;

nWidth=w;

}

void ShowSize()

{

cout<<"当前大小：l="<

}

private:

int nLength,nWidth;

};

class CRect

{

public:

CRect(int left,int top,int right,int bottom);

void Show()

{

ptCenter.ShowPos();

size.ShowSize();

}

private:

CPoint ptCenter;

CSize size;

};

CRect::CRect(int left,int top,int right,int

bottom):size(right-left,bottom-top),ptCenter((right+left)/2,(bottom+top)/2) {

}

void main()

{

CRect rc(10,100,80,250);

rc.Show();

}

19.//通过友元实现对类中私有成员及保护成员的访问

#include

class CPoint

{

public:

CPoint()

{

m_x=m_y=0;

}

CPoint(unsigned x,unsigned y)

{

m_x=x;

m_y=y;

}

void print()

{

cout<<"X="<

}

friend CPoint Inflate(CPoint &pt,int nOffset);//声明友元函数private:

unsigned m_x,m_y;

};

CPoint Inflate(CPoint &pt,int nOffset)//定义友元函数

{

CPoint ptTemp=pt;

ptTemp.m_x+=nOffset;

ptTemp.m_y+=nOffset;

return ptTemp;

}

void main()

{

CPoint pt(10,20);

pt.print();

pt=Inflate(pt,3);//调用友元函数

pt.print();

}

20.//继承

#include

#define PI 3.1415926

class graph

{

public:

graph()

{

circumference=0;

area=0;

}

void show()

{

cout<<"周长为："<

double circumference,area;

};

class circle:public graph

{

public:

circle(double x=0)

{

r=x;

}

void setr(double x)

{

r=x;

}

void calculate()

{

circumference=2*PI*r;

area=PI*r*r;

}

private:

double r;

};

class rectangle:public graph

{

public:

rectangle(double x=0,double y=0)

{

a=x;

b=y;

}

void setab(double x,double y)

{

a=x;

b=y;

}

void calculate()

{

circumference=2*(a+b);

area=a*b;

}

private:

double a,b;

};

void main()

{

graph g;

circle c(10);

rectangle rec(2,5);

g.show();

c.show();

c.setr(100);

c.calculate();

c.show();

rec.show();

rec.calculate();

rec.show();

rec.setab(20,50);

rec.calculate();

rec.show();

}

21.//虚函数，实现“运行时多态性”的方式

#include

#define PI 3.1415926

class CShape

{

public:

virtual float area()//定义虚函数

{

return 0;

}

};

class CTriangle:public CShape

{

public:

CTriangle(float h,float w)

{

H=h;

W=w;

}

float area()

{

return(float)(H*W*0.5);

}

private:

float H,W;

};

class CCircle:public CShape

{

public:

CCircle(float r)

{

R=r;

}

float area()

{

return(float)(PI*R*R);

}

private:

float R;

};

void main()

{

CShape *s[2];

s[0]=new CTriangle(3,4);

cout<area()<

s[1]=new CCircle(5);

cout<area()<

}

//说明：

//１、虚函数在重新定义时参数的个数、类型必须和基类中的虚函数安全匹配//２、虚函数的上述功能，只有通过基类指针才能实现

22.//纯虚函数：无法预先确定基类中虚函数的具体实现时采用纯虚函数

#include

#define PI 3.1415926

class CShape

{

public:

virtual float area()=0;//定义纯虚函数，此时没有具体的代码实现

};

class CTriangle:public CShape

{

public:

CTriangle(float h,float w)

H=h;

W=w;

}

float area()//纯虚函数在派生类中的具体实现代码 {

return(float)(H*W*0.5);

}

private:

float H,W;

};

class CCircle:public CShape

{

public:

CCircle(float r)

{

R=r;

}

float area()//纯虚函数在派生类中的具体实现代码 {

return(float)(PI*R*R);

}

private:

float R;

};

void main()

{

CShape *s[2];

s[0]=new CTriangle(3,4);

cout<area()<

s[1]=new CCircle(5);

cout<area()<

}

23.//运算符重载：是实现“编译时多态性”的一种手段

#include

class CComplex

{

public:

CComplex(double r=0,double i=0)

{

realPart=r;

imagePart=i;

}

void print()

cout<<"该复数为："<

if(imagePart>=0)

cout<<"+"<

else

cout<<"-"<

}

CComplex operator+(CComplex &c);//重载运算符+

CComplex operator+(double r); //重载运算符+

private:

double realPart;

double imagePart;

};

CComplex CComplex::operator+(CComplex &c)//参数是CComplex的引用对象

{

CComplex temp;

temp.realPart=realPart+c.realPart;

temp.imagePart=imagePart+c.imagePart;

return temp;

}

CComplex CComplex::operator+(double r)//参数是double类型变量

{

CComplex temp;

temp.realPart=realPart+r;

temp.imagePart=imagePart;

return temp;

}

void main()

{

CComplex c1(12,20),c2(50,70),c;

c=c1+c2;

c.print();

c=c1+20;

c.print();

}

24.//赋值运算符重载：错误使用开会运算符的情况

//相同类型或匹配类型可以直接赋值，但当对的的成员中有数组或动态数据类型时就不能直接赋值，如下：

#include

#include

class CDemo

{

public:

CDemo(char *s)

{

ps=new char[strlen(s)+1];

strcpy(ps,s);

}

~CDemo()

{

if(ps)

delete[]ps;

}

void print()

{

cout<

}

private:

char *ps;

};

void main()

{

CDemo d1("key"),d2("Mouse");

d1=d2;

d1.print();

d2.print();

}

//在运行到“d1=d2”时出错。

25.//赋值运算符重载

#include

#include

class CDemo

{

public:

CDemo(char *s)

{

ps=new char[strlen(s)+1];

strcpy(ps,s);

}

CDemo & operator =(CDemo &a)

{

if(ps)

delete[]ps;

if(a.ps)

{

ps=new char[strlen(a.ps)+1];