面向对象的三个基本特征和概念

面向对象的三个基本特征（讲解）

面向对象的三个基本特征是：封装、继承、多态。

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

➢

实现继承是指使用基类的属性和方法而无需额外编码的能力；

➢

接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

➢

可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg

类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface

而不是 Class。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function

func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

概念讲解

泛化（Generalization）

图表 1 泛化

在上图中，空心的三角表示继承关系（类继承），在UML的术语中，这种关系被称为泛化（Generalization）。Person(人)是基类，Teacher(教师)、Student(学生)、Guest(来宾)是子类。

若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。

例如，教师是人，Teacher 是Person的“一种”（a kind of ）。那么类Teacher可以从类Person派生（继承）。

如果A是基类，B是A的派生类，那么B将继承A的数据和函数。

如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。

若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能和属性。

聚合（组合）

图表 2 组合

若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。

例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。

聚合的类型分为无、共享(聚合)、复合(组合)三类。

聚合（aggregation）

图表 3 共享

上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。

组合（composition）

图表 4 复合

这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系——组合（composition）（聚合类型为复合）。组合表示的关系也是has-a，不过在这里，A的生命期受B控制。即A会随着B的创建而创建，随B的消亡而消亡。

依赖(Dependency)

图表 5 依赖

这里B与A的关系只是一种依赖(Dependency)关系，这种关系表明，如果类被修改，那么类B会受到影响。

什么是面向对象，和面向过程的区别是什么

最佳答案

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。

而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

功能上的统一保证了面向对象设计的可扩展性。比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。

再比如我要把这个五子棋游戏改为围棋游戏，如果你是面向过程设计，那么五子棋的规则就分布在了你的程序的每一个角落，要改动还不如重写。但是如果你当初就是面向对象的设计，那么你只用改动规则对象就可以了，五子棋和围棋的区别不就是规则吗？（当然棋盘大小好像也不一样，但是你会觉得这是一个难题

吗？直接在棋盘对象中进行一番小改动就可以了。）而下棋的大致步骤从面向对象的角度来看没有任何变化。

当然，要达到改动只是局部的需要设计的人有足够的经验，使用对象不能保证你的程序就是面向对象，初学者或者很蹩脚的程序员很可能以面向对象之虚而行面向过程之实，这样设计出来的所谓面向对象的程序很难有良好的可移植性和可扩展性。

1

一、什么是递归很多数据结构的定义都是根据递归性质来进行定义的，是因为这些结构固有的性质。

递归是指某个函数直接或间接的调用自身。问题的求解过程就是划分成许多相同性质

的子问题的求解，而小问题的求解过程可以很容易的求出，这些子问题的解就构成里原

问题的解了。

二、递归的几个特点

1.递归式，就是如何将原问题划分成子问题。

2.递归出口，递归终止的条件，即最小子问题的求解，可以允许多个出口。

3.界函数，问题规模变化的函数，它保证递归的规模向出口条件靠拢

三、递归的运做机制

很明显，很多问题本身固有的性质就决定此类问题是递归定义，所以递归程序很直接

算法程序结构清晰、思路明了。但是递归的执行过程却很让人费解，这也是让很多人

难理解递归的原因之一。由于递归调用是对函数自身的调用，在一次调用没有结束之前

又开始了另外一次调用，按照作用域的规定，函数在执行终止之前是不能收回所占用的

空间，必须保存下来，这也就意味着每一次的调用都要把分配的相应空间保存起来。为

了更好管理这些空间，系统内部设置一个栈，用于存放每次函数调用与返回所需的各种

数据，其中主要包括函数的调用结束的返回地址，返回值，参数和局部变量等。

其过程大致如下：

1.计算当前函数的实参的值

2.分配空间，并将首地址压栈，保护现场

3.转到函数体，执行各语句，此前部分会重复发生（递归调用）

4.直到出口，从栈顶取出相应数据，包括，返回地址，返回值等等，收回空间，恢复现场，转到上一

层的调用位置继续执行本次调用未完成的语句。

四、引入非递归

从用户使用角度来说，递归真的很简便，对程序宏观上容易理解。递归程序的时间复杂度虽然可以根据

T(n)=T(n-1)*f(n)递归求出，其中f(n)是递归式的执行时间复杂度，一般来说，时间复杂度和对应的非

递归差不多，但是递归的效率是相当低的它主要发费在反复的进栈出栈，各种中断等机制上（具体的可

以参考操作系统）更有甚者，在递归求解过程中，某些解会重复的求好几次，这是不能容忍的，这些也

是引入非递归机制的原因之一。

五、递归转非递归的两种方法

1.一般根据是否需要回朔可以把递归分成简单递归和复杂递归，简单递归一般就是根据递归式来找出递

推公式（这也就引申出分治思想和动态规划）。而复杂递归一般就是模拟系统处理递归的机制，使用栈

或队列等数据结构保存回朔点来求解。

六、几个简单的例子

1.求解阶乘

阶乘的定义就是 n!=n*(n-1)! 0!=1 1!=1

根据定义我们很容易就想到递归方法,做法如下

int Fact(int n)

{

if(n==0) return 1; //递归出口

return n*Fact(n-1) //n*Fact(n-1)就是递归式，其中n-1就是界函数

}

2.再看Fibonacci的例子

定义：某项的值等于前两项的和，其中第一和第二项为1。

根据定义我们很容易写出程序，这里就不写出来了，当我们用笔划几下的时候我们是否会发现有很多解

是重复求出的。举个例子要求F(5)

F(5)=F(4)+F(3);

F(4)=F(3)+F(2);

F(3)=F(2)+F(1);

其中F(3)求解2次。这显然就是时间的浪费。下面我们用递推技术来转化成非递归

从例子可以发现我们可以倒过来求解，即从底到顶把F(n)之前要计算的东西保存下来。

程序就是：

int Fibona(int n)

{

int p1=1,p2=1;

//int a[100]={0};

//a[1]=1,a[2]=1;

for(int i=3;i<=n;i++) //从三开始就可以了，后面的return包括1，2两种情况

{

int r=p1; //递推，可以使用数组全部保存

p1=p2;

p2+=r;

//a=a[i-1]+a[i-2]

}

return p2;

//return a[n];

}

3.带回朔的复杂递归：具体例子参照二叉树的遍历程序。

[url=][/url]

举个简单点的：求解按照中点优先的顺序遍历线形表

按照定义，当然是想到先输出求解的线形表中点值，再输出左部分，然后右部分。

部分代码如下：

void Mid_Order(int a[],int left,int right)

{

int mid;

if(left

{

mid=(left+rigth)/2;

printf("%d ",a[mid]); //输出中点

Mid_Order(a,left,mid-1); //递归调用左部

Mid_Order(a,mid+1,right); //递归调用右部

}

}

显然，在非递归中必须在打印中点之后即将要要访问左部时，要把右部的信息保存起来，结合访问顺序

的特点，知道这里要使用栈。具体做法在这就不实现了。^_^

时间关系，就写这么多了，有什么不对地方，望大家斧正。谢谢^_^