【转帖】【原创】sw二次开发中的术语

yang686526

【原创】sw二次开发中的术语
www.dimcax.com
一 面向对象的程序设计  
3 ~; t& t6 i. u- b( w3 s8 h9 t  8 t; j6 a- w  d4 v9 m/ d' u
   面向对象程序设计方法是通过增加软件的可扩充性和可重用性来提高程序员的编程能力的。  
9 q7 j: g" t# b) s% m# p    在软件设计和实现中，传统的被人们广泛使用的方法是面向过程的程序设计方法。面向过程的程序设计思想的核心是功能的分解。当程序员试图用c或pascal语言来设计程序以解决一个实际问题时，第一步要做的工作就是将问题分解成若干个称为模块的功能块，然后根据模块功能来设计一系列用于存储数据的数据结构，最后编写一些过程(或函数)对这些数据进行操作。最终的程序就是由这些过程构成的，显然，这种方法将数据结构和过程作为两个实体来对待，其着重点在过程，设计人员首先考虑如何将功能分解，在每一个过程中又要着重安排程序的操作序列，但同时程序员在编程时又必须时时考虑数据结构，因为毕竟要将操作作用于数据上。数据结构和过程的这种分离，给软件人员造成沉重的负担。例如，我们不可能要求数据结构始终没有变化，且不说在软件维护的时候数据结构有可能发生变化，就是在软件开发的过程中也不能保证数据结构不变化；面向  
  a9 a; q4 b2 l; @- v& i9 ^6 c 过程的程序设计的缺点之一就是一旦数据结构需要变更的时候，必须修改与之有关的所有模块。因此，面向过程的程序的可重用性差，维护代价高。  
# u* b0 v+ t7 d4 i0 b    现在，我们给面向对象程序设计下一个定义。  - y+ b7 h: j( ~4 v: t7 p
   面向对象程序设计是一种新的程序设计范型。面向对象程序的主要结构特点是：第一，程序一般由类的定义和类的使用两部分组成，在主程序中定义各对象并规定它们之间传递消息的规律；第二，程序中的一切操作都是通过向对象发送消息来实现的，对象接受到消息后，启动有关方法完成相应的操作。  . `; k- [& ^0 j9 p
　　面向对象程序设计的最大优点就是软件具有可重用性。当人们对软件系统的要求有所改变时，并不需要程序员做大量的工作，就能使系统做相应的变化。  / m5 h4 x% |% f3 |& u' u
　  
+ }) w* ?+ y/ d    二 对象  
) z0 c, l, g# }+ v" p, ]  , y8 l1 q( q" i1 d, {- x. o  p2 x# |
   类与对象是面向对象程序设计中最重要的概念，也是一个难点。首先我们来看一看在现实世界中，人们是如何认识“对象”和“类”的。  . q5 f6 t1 x6 l# h
   其实，在日常生活中对象就是我们认识世界的基本单元，它可以是人，也可以是物，还可以是一件事。整个世界就是由形形色色的“对象”构成的。例如一辆车、一个球、一张桌子、一个小学生、一次演出。对象既可以很简单，也可以很复杂，复杂的对象可以由若干简单的对象构成。  
3 o+ m# q' o4 m3 o+ z) j 　　对象是现实世界中的一个实体，其特性是：    d5 a3 f2 i( o4 p- }/ b' a
　　(1)每一个对象必须有一个名字以区别于其它对象；  4 n: m0 i2 d$ m# v- r
　　(2)用属性(或叫状态)来描述它的某些特征；  * f; i5 {' q) @: y3 n
　　(3)有一组操作，每一个操作决定对象的一种行为。    f4 c9 h+ u$ n
　　  
( j$ ?% n$ r% l; {  b    三 类  2 d8 i0 @+ \# u) m: e
  
! m/ }& `, v- o    在日常生活中，“类”是对一组具有共同的属性特征和行为特征的对象的抽象。 例如每辆汽车都是一个不同的对象。但是多个对象常常具有一些共性如所有的汽车都有轮子、方向盘、刹车装置等。于是我们抽象出一类对象的共性,这就是类。类中定义一类对象共有的变量和方法。把一个类实例化即生成该类的一个对象。例如，由一个个的人构成人类，而一个人是人类的一个实例。公共汽车、出租车、农用车、三轮车、货车、赛车等构成了汽车类,而一辆汽车是汽车类的一个实例。  , n- r# n; q$ f2 q- r* f& _9 r
   类和对象之间的关系是抽象和具体的关系。类是对多个对象进行综合抽象的结果，对象又是类的个体实物，一个对象是类的一个实例。  
- h! ]( w4 m! l5 ` 　　例如，教师黎明是一个对象。  $ o: z6 z3 w* w" s
　　对象名：黎明  
5 h7 f6 x% t7 s7 ?4 ~% n* x$ w 　　对象的属性：  
* u$ y% t# d. ?    年龄：30  
& c: m2 t+ n7 n) l/ v1 w* y) y    学历：博士  
+ d; _" c1 z3 n, y! a8 v4 l    职称：教授  
+ m" m* t: v  _+ u1 s( ^9 [# ^    专业：计算机软件  
7 u! s! g9 o+ h8 y0 c" k 　　对象的操作：  
! v( }" a" v* a, j) a 　　说自己的年龄  # }9 g/ w  z! b: q. {
　　吃饭  6 u4 y. p9 a5 v1 |5 k. r4 c
　　授课  3 i8 [: x5 f- y! o0 a( w
　　一个个的像黎明这样的教师就构成教师类。  
, w: i0 z$ y4 u) b' c! `    我们前面说过，面向对象程序设计更接近人们的思维。面向对象程序设计中的对象和类就来源于现实世界。以面向对象程序设计的观点看，一个对象是由描述其属性的数据和定义在其上面的一组操作组成的实体，是数据单元的组合体。类是对一组对象的抽象，这组对象具有相同的属性结构和操作行为，在对象所属的类中要说明这些结构和行为。一个对象是类的一个实例。有了类，才可以创建对象。  
; c' _, x+ w4 j) ^, t" d+ x    现在我们给出类的更精确的定义：类是创建对象的样板，它包含对创建对象的状态描述和对操作行为的说明。  & j( k: f9 o) `7 n
　　在面向对象程序设计中，一个类只在源程序的代码中出现，而并不会在一个正在内存运行的程序中出现，即类只是在编译时存在；对象作为类的实例在运行的程序中出现，并占有内存空间，它是在运行程序时存在的实体。所以一个类实际上是一种新的类型，当我们要使用一个新的数据类型时，首先要在源程序中说明，而说明的部分代码是不在内存中运行的。在程序中运行的是该类的对象，对象在内存中分配空间，程序的计算任务由对象完成。注意，我们在此必须区分说明和定义。  
0 u+ j1 p6 d1 w; s% t+ }  4 i4 r& w" s, y! a9 y
   四 对象的状态  5 o( r. w1 s' }4 b$ m; z+ a
    
  c) d2 r# u6 u+ j) \; m    在面向对象程序设计中，对象是类的实例。对象给类以生命，类想要做的事必须通过建立对象和在对象上进行操作而实现。创建类的对象的过程也叫实例化对象。对象知道什么能做和什么不能做，并且有能力修改和维护定义在对象上的数据。  - l! j0 @0 q- m
   我们可以将对象看成是一个带有状态和行为的活的实体。属于同一个类中的对象具有相同的行为，但是有各自独立的状态。什么是对象的状态?在现实世界中一个对象能独立存在的原因是它们有各自的特征，这些特征就是对象的状态。对于一个人来说，姓名、性别、身高都是其状态。  
1 w* l  ?- s3 y$ q    对象的状态是所有静态属性的这些属性的动态值的总和。  ; x- k  l& e6 _. u$ j0 r8 g, ?
   对象的状态通常不仅仅是初等的数据类型(整型、实型、字符型等)，而且许多对象将另一个对象作为它们状态的一部分。例如，一辆车有发动机、车轮、座位，发动机是另外一个对象，它可以作为车的状态的一部分。又例如，一个银行对象可以将银行账户对象和顾客对象作为它的状态的一部分。  # `% o& w+ g( q- c
  + x' z( i% u& j( r7 t
　  五 对象的交互  8 k6 }# [' q% u2 |8 w3 h9 b
    
2 @- h2 f# ?  ~* h$ _6 s7 h    现实世界中的对象不是孤立存在的实体，他们之间存在着各种各样的联系，正是它们之间的相互作用、联系和连接，才构成了世间各种不同的系统。同样，在面向对象程序设计中，对象之间也需要联系，我们称为对象的交互。面向对象程序设计技术必须提供一种机制，允许一个对象与另一个对象的交互。这种机制，叫做消息传递。  
& g6 c, |6 i  ~( f, m' d    在面向对象程序设计中的消息传递。实际是对现实世界中的信息传递的直接模拟。以实际生活为例，我们每一个人可以为他人服务，也可以要求他人为自己服务。当我们需要别人为自己服务时，必须告诉他们我们需要的是什么服务。也就是说，要向其它对象提出请求，其它对象接到请求后，才会提供相应的服务。  ( d( |$ ~5 b/ y: `# k
   在面向对象程序设计中，一个对象向另一个过象发出的请求被称为“消息”。消息是一个对象要求另一个对象执行某个功能操作的规格的说明，通过消息传递才能完成对象之间的相互请求或相互协作。例如，我们有一个银行账户对象和一个顾客对象，顾客对象可以请求银行账户对象的服务，如“存入300元”、“取出z00元”等，当银行账户对象接到请求后，确定应执行的相应的操作并执行。  2 r. b0 z4 v, h. c1 t
   一般情况下，我们称发送消息的对象为发送者或请求者，接收消息的对象为接收者或目标对象。对象中的联系只能通过消息传递来进行。接收者只有在接收到消息时，才能被激活，被激活的对象会根据消息的要求完成相应的功能。  & `% v& i8 h- q' ~  x
   消息具有三个性质：  
  a: g: w8 u. g) |0 o. ?: g* p, e    (1)同一个对象可以接收不同形式的多个消息，做出不同的响应；  
3 c5 t, i# m# m# b6 ?6 b6 z( x    (2)相同形式的消息可以传递给不同的对象，所做出的响应可以是不同的；  
# n6 f. p0 i# e* b: d    (3)消息的发送可以不考虑具体的接受者，对象可以响应消息，也可以不响应。  
  c9 k% v; }1 o# a, ?    实际上，对象之间的消息传递机制对应于面向过程程序设计的过程调用。消息传递并非真的传递信息，它的实质就是方法的调用。只不过方法的调用受到消息的控制，而过程调用是直接的。  3 n' a5 q& w$ b6 o
   消息的内容一般应包括接收者的名字、请求的方法、一个或多个参数。  
# |2 r$ d/ w" r7 x% }    由发送者向接受者发送一条消息，就是要求调用特定的方法。所调用的方法可能引起对象状态的改变，还可能会生成更多的消息，而导致调用其它对象中的方法。  4 n: f9 y+ |/ d  t6 j- y
   在面向对象程序设计中，消息分为两类：公有消息和私有消息。假设有一批消息同属于—个对象，其中—部分消息是由其它对象直接向它发送的，称为公有消息；另一部分消息是它向自己发送的，称为私有消息。  
! g. l4 q/ s6 p8 w6 e, a9 ~    公有消息和私有消息的确定，与消息要求调用的方法有关。  
- i7 ?8 x! \1 o" h5 t8 \) f1 v5 v8 f  
( e2 \; z; }  a9 c+ o5 w) h* a    六 类的确定与划分  # _* z) }* j* m2 p! g5 y4 u2 h2 t
  　  , r+ u9 }; x4 r: e
   我们知道，面向对象程序设计技术是将系统分解成若干对象，对象之间的相互作用构成了整个系统。而类是创建对象的样板，在整体上代表一组对象，设计类而不是设计对象，可以避免重复的编码工作，类只需编码一次，就可以创建所有的对象。所以当我们解决实际问题时，需是正确地进行分“类”。我们必须理解一个类究竟表示哪一组对象，如何把实际问题中的事物汇聚成一个个的“类”，而不是一组数据。这是面向对象程序设计中的一个难点。  
4 g( v' d, n3 ~; y* j2 s9 l& w# t    例如，考虑银行系统，我们至少应该有两类对象：顾客类和银行账户类。  4 n: o6 s: i$ e) d) m8 r
   在面向对象程序设计中，类的确定与划分是非常重要的，是软件开发中关键的一步，划分的结果直接影响到软件系统的质量。如果划分得当，既有利于对程序进行扩充，又可以提高代码的可重用性。  ( j! a; u# q0 ^
　　如何确定和划分类?这需要软件人员对实际问题进行全面的细致的分析，使类的对象适合软件系统。值得注意的是，类的确定和划分并没有统一的标准和固定的方法，基本上依赖设计人员的经验、技巧以及对实际问题的把握。一个基本的原则是：寻求一个大系统中事物的共性，将具有共性的系统万分确定为一个类。系统想要达到的目标不同，确定和划分的类就不相同。  ; v  ]" s$ r# k3 e3 o1 e9 c# b6 `
   那么，究竟什么是一组对象的共性呢?我们如何判断一个事物是一个类而不是另外一个类的对象呢？确定一个事物是一个类的第一步，是要判断它是否具有一个以上的实例，如果有，则它可能是一个类；第二步，我们还要判断类的实例中有否绝对的不同点，如果没有，则它是一个类。因为类的每一个实例是相似的，具有相同的行为和属属性结构。  
* ]; j* ~( n: d2 n. n 　 例如，颜色(color)与鲜花联系在一起只是鲜花的一种状态，因为表示颜色的是一些直：红、黄、紫、白等，所以，在此color不是一个类。然而，如果我们把颜色同包括复杂颜色计算的图形处理系统联系在一起，则color是一个类，因为这时的颜色是基于颜色三元素(红、绿、蓝)的成分比例和色度的变量，它不仅仅是一个数值，还可以附带很多的行为。  6 g7 u9 b9 }) m+ b3 l
   由于实际问题的复杂性，要求在第一次就能正确地确定和划分一个类几乎是不可能的。有可能出现这样的情况：第一次设计时被确定为类的事物，第二次可能成为了数据。我们需要不断地对实际问题进行分析和整理，以便得出正确的结果。  2 i% s% k# s( ~
   另外，我们要知道什么事物不能被划分为类，这一点也是非常重要的。不能把一组函数组合在一起构成类。也就是说，不能把一个面向过程的模块直接变成类，如果简单地将模块中的函数变成成员函数而使其成为类是错误的。类不是函数的集合。  ; u9 s! x1 f4 r
   设计类要有一个明确的目标。一个好的类应该是容易理解和使用的．我们不能设计一个color类来表示鲜花的颜色，但是可以在图形处理系统中将颜色color设计为类。因为在两个系统中对颜色的要求不同。  
! r8 n: y! s  x2 j1 y) h  ) s9 a% f( @" p* u, w3 l# o
   七 数据的抽象与封装  ; g& @8 x+ e8 ?( w" i" ?% w6 }
  
1 y% t% t! x& k5 @( q& \    抽象和封装的概念在理实世界中广泛存在．尤其在科学技术日益发展的今天，大量的电器被人们使用，对电器的使用体理了抽象与封装的概念。  
7 d7 h5 ^- o* p* c/ s    以录音机为例，录音机上有若于按健，当人们使用录音机时，只要根据自己的需要，如放音、录音、停止、倒带等，按下与之对应的键，录音机就会完成相应的工作。这些按键安装在录音机的表面，人们通过它们与录音机交互。我们无法(当然也没必要)操作录音机的内部电路，因为它们被装在机壳里，录音机的内部情况对于用户来说是隐蔽的，不可见的。这就是所谓封装的原理。  
$ b+ f! v' w1 e# |! n    那么，我们是如何知道放音按哪个健，停止又按哪个键的呢?是录音机的操作说明书告诉我们的，但操作说明书并不告诉我们录音机的内部将如何去做这些事。操作说明书在录音机做什么(what　to do)与怎样做(how to do)之间做出了明确的区分。这就是所谓抽象的原理。抽象出来的是做什么，而不关心如何实现这些操作。      以一般观点而言，抽象是通过特定的实例或例子抽取共同性质以后形成概念的过程，抽象是对系统的简化描述或规范说明，它强调了系统中的一部分细节和特性，例如做什么，而忽略了其它部分，例如如何做。抽象的描述被称为它的规范说明．例如录音机的操作说明书，而对抽象的解释称为它的实现。  2 z, u' s3 n' u
   将上述观点用在数据结构上，就不难理解数据的抽象与封装。将数据结构和作用于数据结构上的操作组成一个实体，数据的表示方式和对数据的操作细节被隐藏起来，用户通过操作接口对数据进行操作。对于用户来说，只知道如何通过操作接口对该数据进行操作，而并不知道是如何做的，也不知道数据是如何表示的。这就是数据的封装。  
0 l7 k. f2 o( z6 v  _    数据的抽象则是通过对数据实例的分析，抽取其共同性质的结果。数据的抽象和我们前面讨论的类的概念之间显然存在着很强的相似性。  " v( t. n3 h7 ]
   在面向对象程序设计中，数据的抽象是在确定类时强调对象的共同点而忽略它们的不同点的结果。也可以说，在一个类的说明中我们只表示那些主要特性，而忽略次要的、引不起我们兴趣的东西。  % l; e8 j8 ~- z! `- b
   数据的封装则是隐藏了抽象的内部实现细节的结果。封装是将数据抽象的外部接口与内部的实现细节清楚地分离开。抽象和封装是互补的。好的抽象有利于封装，封装的实体则帮助维护抽象的完整性。重要的是抽象先于封装。  
( p$ e0 l, y/ c& t- t; u3 x    封装的单位实际是对象，但是对象的结构和行为是用它自己的类说明来描述的。对象的封装比类的封装更具体化。  , g" o, o+ w8 k3 l9 v
   可以从下面几点来理解对象的封装：  ! p: ]) o  w) }, f  v) d$ v
   (1)对象具有一个清楚的边界，对象的私有数据、成员函数的细节被封装在该边界内；  
. d; v3 y7 z) b! b7 q/ ^    (2)具有一个描述对象与其它对象如何相互作用的接口，该接口必须说明消息传递的使用方法；  
5 f% ^: i1 p* k6 m, m    (3)对象内部的代码和数据应受到保护，其它对象不能直接修改。  9 ]' f' n$ e- h4 m5 a0 a( q
   从用户(或应用程序员)的观点看，对象提供了一组服务，并提供了请求服务的接口。从系统设计员的角度看，封装能够清楚地标明对象提供的服务界面，而对象的行为和数据是隐蔽的，看不见的。  $ c6 x6 q0 |' u) v' g7 n/ h
   对象的这一封装机制，可以将对象的使用者与设计者分开．使用者不必知道对象行为实现的细节，只需要使用设计者提供的接口让对象去做。封装的结果实际上隐藏了复杂性，并提供了代码重用性，从而减轻了开发一个软件系统的难度。同时，封装不鼓励程序员对对象内部的数据成员和成员函数进行不必要的干涉，直接更改数据的危险在于程序员可能忘记哪些操作需要修改，也可能搞错数据。  ; y8 m2 i  ?; k$ q% j7 s3 }
  ; i" ^  l! ]- o! b7 y
  八 对象的特性  
; e8 i+ q7 k5 i0 y- n    ' {6 [# u- i" t7 z* k1 c  p, ?
   (1)封装性  
2 m9 [" j  l  r    对象将私有元素和实现操作的内部细节隐藏起来，并能管理自己的内部状态。外部只能从对象所表示的具体概念、对象提供的服务和对象提供的外部接口来认识对象。通过向对象发运消息来撒活对象的自身动作，达到施加特定操作的目的。  2 p( m9 |. ~4 ~% b5 i5 c
   (2)模块独立性  ( r# \6 e: o& g7 s4 a& a
   一个对象是一个独立存在的模块，具有独立的计算能力；并且其自身的变化不受外界的干扰，也不会涉及到其它的模块；模块的依赖性极小或几乎没有；各模块可以独立地成为软件系统的组件，也可以被程序员重用。  & e" x" u7 ?9 b- r" u
   (3)动态连接性  5 |' ^1 l& h1 d6 o+ z
   对象的动态连接性是指对象通过消息传递机制将对象动态地联系在一起的特性。对象能接收其它对象发送的消息，也能向其它对象发送消息．通过这种联系，若干对象可协同完成某项任务。  ! s1 f$ v8 g9 i1 z. d& q- i% w$ d
   (4)易维护性  ; e3 j9 }* y2 l! ~9 ^- `* y
   由于对象的功能被“隐蔽”，所以修改和完善的工作都棱局限于对象的内部，不会涉及到外部，因此使得对象和整个系统变得非常容易维护。  
1 a0 t6 {' {3 h5 g     
' l. k% j0 e0 k' e/ q+ u- a  9 _' j3 t/ d+ f$ c# k/ ~
   九 继承的概念  7 t2 y$ j" e8 `& c& o
    
  y6 g) p( d7 f, k! t, e    继承在现实生活中是一个很容易理解的概念。例如，我们每一个人都从我们的父母身上继承了一些特性，例如种族、血型、眼睛的颜色等，我们身上的特性来自我们的父母，也可以说，父母是我们所具有的属性的基础。  
7 ]8 r& `& |9 e/ n3 z" f8 e0 w 　　我们再以动物学中对动物继承性的研究为例。  
& t; f# ^# o/ l9 l 　　哺乳动物是一种热血，有毛发、用奶哺育幼仔的动物；狗是有犬牙、食肉、特定的骨骼结构、群居的哺乳动物：柯利狗是尖鼻子、身体颜色红白相间、适合放牧的狗。在继承链中，每个类继承了它前一个类的所有特性。例如，狗具有哺乳动物的所有特性，同时还具有区别于其它哺乳动物(如猫，大象等)的特征。  - w; r: l) j4 f! y7 b' g4 k" h7 r
　　以面向对象程序设计的观点来看，继承所表达的是对象类之间相关的关系。这种关系使得某类对象可以继承另外一举对象的特征和能力。  
7 {; ?( q/ u( s4 o1 t    若类之间具有继承关系，则它们之间具有下列几个特性：  & q+ v$ ?0 `! g5 j! t$ {$ j
   (1)类间具有共享特征(包括数据和程序代码的共享)，  ) t6 p" d1 _" ]3 ~
   (2)类间具有差别或新增部分饱括非共享的数据和程序代码)  
3 k9 i% n) |" e: p9 p; a1 c    (3)类间具有层次结构。  ; h6 ^5 g& q: ~0 e  |# z. w
   假设有两个类a和b，若类b继承类a，则属于类b中的对象具有类a的一切特征(包括数据属性和操作)，这时，我们称被继承类a为基类或父类或超类；而称继承类b为类a的派生类或子类。同时，我们还可以说，类b是从类a中派生出来的。  
! q; v8 [3 ?( t# v8 u    如果类b是从类a派生出来，而类c又是从类b派生出来，就构成了类的层次。这样，我们又有了直接基类和间接基类的概念。类a是类b的直接基类，是类c的间接基类。类c不但继承它的直接基类的所有特性，还继承它    对于动物继承链，用面向对象程序设计的术语，我们称‘哺乳动物”是“狗”的基类，狗是“哺乳动物”的派生类。“哺乳动物”、“狗”、“柯利狗”构成类的层次，‘哺乳动物”是“狗”的直接基类，是“柯利狗”的间接基类。  
  h: e: n& p8 {1 r/ t8 ]3 v, y    同样，我们可以把家族的继承关系推广成父母类和子女类<而不是我的父母和我)，父母类是子女类的基类，子女类是父母类的振生类。  
  m( ^% f* ~' i2 i) z# b$ u    如果类b是类a的派生类，那么，在构造类b的时候，我们不必重新描述a的所有特征，我们只需让它继承类a的特征，然后描述与基类a不同的那些特性。也就是说，类b的特征是由继承来的和新添加的两部分特征构成。  $ g' n9 c/ @1 l4 f& a
　  具体地说，继承机制允许派生类继承基类的数据和操作(即数据成员和成员函数>，也就是说，允许派生类使用基类的数据和操作。同时，派生类还可以增加新的操作和数据。例如，子女类可以从父母类继承房子和汽车，当然可以使用房子和汽车，还可以对房子进行再装修。  
# b- o% h$ v) `    那么，面向对象程序设计为什么要提供继承机制?也就是说，继承的作用是什么?继承的作用有两个：其一，避免公用代码的重复开发，减少代码和数据冗余；其二，通过增强一致性来减少模块问的接口和界面。  5 j3 v9 c, s# ]
   如果没有继承机制，每次的软件开发都要从“一无所有”开始，因为类的开发者们在构造类时，各自为政，使类与类之间没有什么联系，分别是一个个独立的实体。继承使程序不再是毫无关系的类的堆砌，而具有良好的结构。  
. h  `' x. t' k    继承机制为程序员们提供了一种组织、构造和重用类的手段。继承使一个类(基类)的数据结构和操作为另一个类(派生类)重用，在派生类中只需描述其基类中没有的数据和操作。这样，就避免了公用代码的重复开发，增加了程序的可重用性，减少了代码和数据冗余。同时，在描述派生类时，程序员还可以覆盖基类的一些操作，或修改和重定义基类中的操作，例如子女对所继承的房子进行装修。  
& c6 e7 s' h5 h) z4 g    继承机制以相关的关系来组织事物，可以减少我们对相似事物进行说明和记忆的规模，为我们提供了一种简化的手段。程序员可以持相关的类收集在一起，生成高一级的、概括了这些类的共性的类。具有适应关系的类处于一个继承层次结构中，高层的类作为低层的类的抽象，使程序员能够忽略那些低层类的不同实现细节，而按照高层类编写通用程序，并且在掌握了高层类的特征以旨，能够很快地掌握低层类的特征，给编程工作带来方便。  $ p: q  k! m* a" h
  
. r  v) v! @- l    十 继承与封装的关系  ) y3 ~% b& x. w/ m4 t% l
  $ m5 i9 r7 f- v: c
   在面向对象程序设计中，对象具有封装性，对象之间的联系只能通过消息传递来完成，对象的私有数据和行为是被隐藏起来的。那么，继承机制的引入是否削弱了封装性?继承与封装是否产生矛盾?回答是否定的。继承与封装不但没有实质性的冲突，而且还有一定的相似性。  
0 d1 g& n# ], n" l    在面向对象系统中，封装的单位是对象，也就是说，把—个属于某一类的对象封装起来，使其数据和操作成为一个整体。如果该对象所属的类是一个派生类，那么，它只要把从基类那里继承来的操作和数据与自己的操作和数据一并封装起来，就可以了。对象依然是封装好的整体，仍然只通过消息传递与其它的对象交互，而不是直接调用，所以，一个对象，无论它是基类的实例，还是派生类的实例，都是一个被封装的实体。因此，我们得出结论：继承机制的引入并不影响对象的封装性。  
7 m7 b+ q8 p0 e% a5 l7 d- n& o/ x    从另一角度看，继承与封装还有相似性，那就是它们都提供了共享代码的手段，因而增加了代码的重用性。  
* _1 i' g! j8 j( z: a1 l( t    继承提供的代码共享是静态的，派生类对象在成为活动的实体以后，自动地共享其基类中定义的代码段，从而使基类对象与其派生类对象共享一段代码。  
* k) f  p5 h" s6 d2 u+ d6 k" t& m    封装提供的代码共事是动态的，例如我们在一个类中说明了一段代码，那么属于该类的多个实例在程序运行时共享在类中说明的那段代码。  " o! v0 `6 @! a3 b& u
  . c  [* ]8 p# g4 z" t0 k3 }
   十一 多态性  , n& a4 s/ r; p' {: t
     5 r0 h9 z2 t2 [0 @: }8 w
   多态性也是面向对象系统的重要特性。在讨论面向对象程序设计的多态性之前，我们还是来看看现实世界的多态性。现实世界的多态性在自然语言中经常出现。假设一辆汽车停在了属于别人的车位，司机可能会听到这样的要求：“请把你的车挪开”，司机在听到请求后，所做的工作应该是把车开走。在家里，一把凳子挡住了孩子的去路，他可能会请求妈妈：“请把凳子挪开”，妈妈过去搬起凳子，放在一边。在这两件事情中，司机和妈妈的工作都是“挪开”一样东西，但是他们在听到请求以后的行为是截然不同的，这就是多态性，对于“挪开”这个请求．还可以有更多的行为与之对应。“挪开”从字面上看是相同的，但由于用的对象不同，操作的方法就不同。  + j3 b5 a: l7 g. y& ^
   面向对复程序设计借鉴了现实世界的多态性。面向对象系统的多态性是指不同的对象收到相同的的消息时产生多种不同的行为方式。例如，我们有一个窗口(window)类对象，还有一个棋子(chesspiece)类对象，现在我们来考虑对它们都发出“移动”的消息，“移动”操作在window类对象和chesspiece类对象上可以有不同的行为。  
) t' ^7 q* @" `+ q6 [  4 }# v2 o: l9 h! |7 l; b2 _3 f
   十二 重载的概念  * n& h3 o; x' k9 g
  
& m. h; k  m1 t5 f8 n: d) c* b0 f    重载一般包括函数重载和运算符重载。函数重载是指一个标识符可同时用于为多个函数命名，而运算符重载是指一个运算符可同时用于多种运算。也就是说，相同名字的函数或运算符在不同的场合可以表现出不同的行为。  
7 n5 c: d# i( ]0 s0 e    为什么要使用重载?使用重载的目的是为了更好地表达行为共享，这种行为共享就像将相似的操作划分在一起。使用重载可以使程序员在只知道操作的一般含义，而不知道操作具体细节的情况下能正确地对某个对象使用同一个操作。  0 ]. x; d( z& `2 k
   另外，使用重载的直接益处是减少了程序员记忆操作名字的负担。  
* b+ j7 @" g3 z( d+ _1 t! f/ w 十三 com  
7 j5 j. k* t% k9 l" k; w  
5 x7 u/ @7 n! s! z0 z1 o  n    com是microsoft组件对象模型(component object model)的简称。  ) |$ a. m$ j0 u4 p& f0 l/ {
   com是一个说明如何建立可动态交替更新组件的规范。它提供了客户和组件为保证能够互操作应该遵循的标准。该标准对于组件架构的重要性同其他任何一个具有可交替更新部分的系统是一样的。举个例子，如果没有国家标准(gb)，那么各个厂家所生产零件及产品将不能实现互换性。各个厂家各自为政，若电机上的螺栓坏了，就要买原来厂家生产的螺栓，相当不方便。我们所熟悉的超文本格式语言(html)，实际上也是一种趋向于标准化的语言。没有标准，任何东西都将不能一起工作。      9 r  s$ {% f1 i2 j# f; t
   com规范就是一套为组件架构设置标准的文档。那么，什么是com组件呢?  * c# q% d9 s8 z' o7 v% x3 p$ u
   com组件由以win32动态连接库（dll）或可执行文件（exe）形式发布的可执行代码所组成。  
; o. e$ v/ y) k3 l    那么，com组件有什么好处呢?它到底是什么东西呢?  ! _. e' i% o5 p( r
   作为传统软件的应用程序在发行之后，使用者要想省略掉其中的某些内容，或者感觉应用程序的某些部分还不够完善，希望得到更好的版本，只有等到软存发行商将新版本重新全部编译并推出后，使用者的这一梦想才能实现。这是传统软件的典型发行方式。但是，这却严重妨碍了软件使用人员的工作效率，使得使用者想做某件事，而软件却没有相应的实现部分。这使得软件的使用范围大幅度缩小，同时也使得商家频于软件升级方面的应酬，而实际上应用程序的开发进度却丝毫得不到加快。但是，自从com出现以后，以上问题就基本上迎刃而解了。有了com，软件开发人员就可以在应用程序发行后仍可以对它进行修改或给它加上一些新的特性，这大大方便了使用者，因为应用程序能够在更高的程度上被定制，使应用更加灵活、更具动态性。于是，将可能出现这样的情况：每个使用者都在使用相同的软件，而实际上每个使用者的软件却大相径庭。软件开发人员可以用逐步添加的方式开发程序，而不是每隔一两年将其完全重写一遍，这又在很大程度上加快了应用程序的开发进度。com被认为是未来应用程序开发的趋势。  4 k2 y2 i# z8 |/ e- `
   com的前身是ole，它是对象链接及嵌入的microsoft版本。ole的第一个版本使用动态数据交换(dde)作为客户及组件之间的通信方式。ole 1中并没有引入com。但是dde非常缓慢，而且效率也不高。ole的第二个版本使用了com。但ole是开发出来的第一个com系统，不能很好地实现com的功能，这使ole显得比较庞大且使用不便。现今，com在很多方面体现了越来越强劲的生命力。  - z, p3 _2 [) |/ u& m) u% p
　　虽然com是开发软件组件的一种方法，但是组件实际上却是一些小的二进制可执行程序。为此，学习com首先要有一定的编程基础。虽然com本身与编程没有关系，但是开发人员总要选择一种编程语言来实现所需的组件。实际上，大家可以有多种选择的余地。可以是c，java，basic，也可以是python。但是由于大多数组件是用com编写的。  
- t3 |/ {* v: f. z    com中的组件，其实用积木来形容它再恰当不过。我们小时候玩积木时，头脑中总是想象着各种各样的东西，然后就用块状的积木一块一块地将它们垒起来。我们也可以把组件看成是一块一块的积木，或是一个一个的小单元，这些小单元成为应用程序的各个独立部分。这种做法的好处不言自明，它可以随着对应用程序的不断发展而使用新的组件来取代原有的组件。就像堆积木一样，用一块更漂亮的积木搭成更漂亮的建筑。  
; u, t; t; t/ u! y8 s    传统应用程序的组成部分是分立的文件、模块或类，这些组成部分经过编译并链接之后才形成应用程序。要想推出应用程序的新版本，就需要将这些组成部分重新编译，既费时又费力。有了组件的概念，就可以将改进后的新组件插入到应用程序中，并替换掉原有的旧组件，从而赋予应用程序新的活力。  * v% l0 v: j0 x! `  s- i7 ^* f
   另外，由此也可以有这样的想法；把许多已经做好的组件放到一起来形成一个组件库，好比一个类库。当制作应用程序时，如果要用到不同的组件，只需从刚建好的组件库中调出所需要的组件，然后将它们插入到适当的位置，来获得所向往的功能。就像搭积木—样，可以从包装盒中拿出你喜欢的积木单元，扔掉不喜欢的积木单元，然后用智慧修建出属于自己的公寓。  ; b3 h& y  ^* z
    
  _9 k8 t) m1 t' \  
' x+ g% _! s: q1 n( t   - m% y! v/ x& r, s' z4 i
    十四 activex控件  
4 w* t& g! l7 y+ f- s  o- p      ) d9 y2 p0 s- }
   activex是microsoft新近提出的一种技术，它以com(component object　model，组件对象模型)为基础，其中包括了ole技术以及应用于internet的多种技术。它使得不同的进程(甚至是网络上的进程)之间可相互通信，并且朝着多媒体方向发展。activex是一种面向对象的组件系统，其中包括了组件软件的各个方面，有复合文档、自定义控制、ole自动化、交互应用程序脚本、数据传送及其他分布式软件的相互作用。这些组件对象为用户提供了各种不同的功能，使得不同软件共应商提供的组件可在二进制级进行相互连接和通信。对象通过接口实现组件之间及组件与系统之间的相互作用。在桌面系统进行软件交互时，除了系统提供的标准控制外，ole控件是一个重要的组成部分。最初的vbx(visual basic控件)结构由于没有被设计成一个独立的、标准的界面而与visual　basic的设计环境密切相关，很难与其他开发工具、应用软件和对象组合工作。microsoft在公布ole2．0之后，就推出了ole控件以取代vbx控件。随着activex技术的进一步发展，新的activex控件继承了ole控件的特性，同对还弥补了ole接口与intemet之间的冲突。  
0 l5 x7 x1 c0 t  activex控件在两个方面的表现尤为突出。  4 v% f, i& j; {: `: k( |
   (1)开发人员不仅可以将控件加到自己的主页上，还能够在网上传递。利用frompage等主页制作工具，可在主页中加入activex控件，或者编写html代码直接将控件加到主页中。activex控件能激活web页面，在页面中增加client／server能力，允许web网点的访问者执行复杂的操作，从数据库或其他服务器甚至其他web网点上的应用程序收数据。  5 v! w/ d$ c! i* _
   (2)acfivex控件还可以用于vb，foxpro，vc和access等拥有control container功能的应用程序。可用visual c++开发出应用程序所需的控件，再将控件放到foxpro及其他环境下使用。这样就在不同的编程语言之间架起了一座桥梁，既方便了编程者，又拓展了各种编程语言开发程序的能力。  5 j* a. }! ^& w3 ]. j( h
   activex是一种标准，利用这个标准可以使通过不同语言开发的软件构件在单机或，网络环境中相互操作。  
+ v2 w6 d; j3 c; `+ [. y" s  ; x8 y* d: d' l
同时，activex也是以组件对象模型为基础的开放技术的集合，它代表了应用程序与internet的一种集成策略。  
: h* c* m1 t, l* ?9 g  & v4 r9 l. s  j6 _8 a
activex组件最常用的有三种：控件(control)、自动化服务器(auwmation server)和文档(document)。activex  : f' v3 a& t6 m, z* }2 g
  6 n% z0 k3 x& k& |0 \
控件作为一种可重用的组件，相当于一个封装好的代码模块，通过其方法、属性、事件与应用程序进行通信。  5 ?& v# ~4 q# n1 g! v# |1 v
  
! |9 e6 ^$ \. x   0 h9 n7 t# ]: j$ e
   
,

不错，受益匪浅!