面向对象程序设计

面向对象程序设计

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

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.doczj.com/doc/241260237.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)