面向对象的一些概念

参考文献：http://www.cppblog.com/snowball/archive/2011/10/05/55051.html

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

1.1封装

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

封装，也就是把客观事物封装成抽象的类，而且类能够把本身的数据和方法只让可信的类或者对象操做，对不可信的进行信息隐藏。

1.2继承

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

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

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

继承的过程，就是从通常到特殊的过程。

要实现继承，能够经过 “ 继承 ” （ Inheritance ）和 “ 组合 ” （ Composition ）来实现。

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

 

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

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

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

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

在考虑使用继承时，有一点须要注意，那就是两个类之间的关系应该是 “ 属于 ” 关系。例如， Employee 是一我的， Manager 也是一我的，所以这两个类均可以继承 Person 类。可是 Leg 类却不能继承 Person 类，由于腿并非一我的。

抽象类仅定义将由子类建立的通常属性和方法，建立抽象类时，请使用关键字 Interface 而不是 Class 。

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

1.3多态

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

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

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

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

其实，重载的概念并不属于 “ 面向对象编程 ” ，重载的实现是：编译器根据函数不一样的参数表，对同名函数的名称作修饰，而后这些同名函数就成了不一样的函数（至少对于编译器来讲是这样的）。如，有两个同名函数： function func(p:integer):integer; 和 function func(p:string):integer; 。那么编译器作过修饰后的函数名称多是这样的： int_func 、 str_func 。对于这两个函数的调用，在编译器间就已经肯定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），所以，重载和多态无关！真正和多态相关的是 “ 覆盖 ” 。当子类从新定义了父类的虚函数后，父类指针根据赋给它的不一样的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是没法肯定的（调用的子类的虚函数的地址没法给出）。所以，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句 Bruce Eckel 的话： “ 不要犯傻，若是它不是晚邦定，它就不是多态。 ”

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

2.泛化、聚合、组合和依赖的概念解析

2.1泛化（ 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.2聚合（组合）

图表 2 组合

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

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

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

2.3聚合（ aggregation ）

 

图表 3 共享

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

2.4组合（ composition ）

图表 4 复合

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

2.5依赖 (Dependency)

图表 5 依赖

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

3接口与抽象类有什么区别

abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是因为这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具备很大的类似性，甚至能够相互替换，所以不少开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实，二者之间仍是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在两者之间进行选择的依据。

3.1理解抽象类

abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并不是从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为咱们带来什么好处呢？

在面向对象的概念中，咱们知道全部的对象都是经过类来描绘的，可是反过来却不是这样。并非全部的类都是用来描绘对象的，若是一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类每每用来表征咱们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不一样，可是本质上相同的具体概念的抽象。好比：若是咱们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不一样的，可是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是由于抽象的概念在问题领域没有对应的具体概念，因此用以表征抽象概念的抽象类是不可以实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。咱们能够构造出一个固定的一组行为的抽象描述，可是这组行为却可以有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为全部可能的派生类。模块能够操做一个抽象体。因为模块依赖于一个固定的抽象体，所以它能够是不容许修改的；同时，经过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者必定知道，为了可以实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。

3.2从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface给出了不一样的定义方式，下面以定义一个名为Demo的抽象类为例来讲明这种不一样。

使用abstract class的方式定义Demo抽象类的方式以下：

abstract class Demo ｛ 
abstract void method1(); 
abstract void method2(); 
… 
｝

使用interface的方式定义Demo抽象类的方式以下：

interface Demo { 
void method1(); 
void method2(); 
… 
}

在abstract class方式中，Demo能够有本身的数据成员，也能够有非abstarct的成员方法，而在interface方式的实现中，Demo只可以有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中通常不定义数据成员），全部的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。

从编程的角度来看，abstract class和interface均可以用来实现"design by contract"的思想。可是在具体的使用上面仍是有一些区别的。

首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。可是，一个类却能够实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

其次，在abstract class的定义中，咱们能够赋予方法的默认行为。可是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，可是这会 增长一些复杂性，有时会形成很大的麻烦。

在抽象类中不能定义默认行为还存在另外一个比较严重的问题，那就是可能会形成维护上的麻烦。由于若是后来想修改类的界面（通常经过abstract class或者interface来表示）以适应新的状况（好比，添加新的方法或者给已用的方法中添加新的参数）时，就会很是的麻烦，可能要花费不少的时间（对于派生类不少的状况，尤其如此）。可是若是界面是经过abstract class来实现的，那么可能就只须要修改定义在abstract class中的默认行为就能够了。

一样，若是不能在抽象类中定义默认行为，就会致使一样的方法实现出如今该抽象类的每个派生类中，违反了"one rule，one place"原则，形成代码重复，一样不利于之后的维护。所以，在abstract class和interface间进行选择时要很是的当心。

3.3从设计理念层面看abstract class和interface

上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本小节将从另外一个层面：abstract class和interface所反映出的设计理念，来分析一下两者的区别。做者认为，从这个层面进行分析才能理解两者概念的本质所在。

前面已经提到过，abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的（参考文献〔3〕中有关于"is a"关系的大篇幅深刻的论述，有兴趣的读者能够参考）。对于interface 来讲则否则，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将经过一个简单的实例进行说明。

考虑这样一个例子，假设在咱们的问题领域中有一个关于Door的抽象概念，该Door具备执行两个动做open和close，此时咱们能够经过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别以下所示：

使用abstract class方式定义Door：

abstract class Door { 
abstract void open(); 
abstract void close()； 
}

使用interface方式定义Door：

interface Door { 
void open(); 
void close(); 
}

其余具体的Door类型能够extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

若是如今要求Door还要具备报警的功能。咱们该如何设计针对该例子的类结构呢（在本例中，主要是为了展现abstract class和interface反映在设计理念上的区别，其余方面无关的问题都作了简化或者忽略）？下面将罗列出可能的解决方案，并从设计理念层面对这些不一样的方案进行分析。

解决方案一：

简单的在Door的定义中增长一个alarm方法，以下：

abstract class Door { 
abstract void open(); 
abstract void close()； 
abstract void alarm(); 
}

或者

interface Door { 
void open(); 
void close(); 
void alarm(); 
}

那么具备报警功能的AlarmDoor的定义方式以下：

class AlarmDoor extends Door { 
void open() { … } 
void close() { … } 
void alarm() { … } 
}

或者

class AlarmDoor implements Door ｛ 
void open() { … } 
void close() { … } 
void alarm() { … } 
｝

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念自己固有的行为方法和另一个概念"报警器"的行为方法混在了一块儿。这样引发的一个问题是那些仅仅依赖于Door这个概念的模块会由于"报警器"这个概念的改变（好比：修改alarm方法的参数）而改变，反之依然。

解决方案二：

既然open、close和alarm属于两个不一样的概念，根据ISP原则应该把它们分别定义在表明这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另外一个概念使用interface方式定义。

显然，因为Java语言不支持多重继承，因此两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，可是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。咱们一一来分析、说明。

若是两个概念都使用interface方式来定义，那么就反映出两个问题：一、咱们可能没有理解清楚问题领域，AlarmDoor在概念本质上究竟是Door仍是报警器？二、若是咱们对于问题领域的理解没有问题，好比：咱们经过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么咱们在实现时就没有可以正确的揭示咱们的设计意图，由于在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

若是咱们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具备报警的功能。咱们该如何来设计、实现来明确的反映出咱们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is a"关系。因此对于Door这个概念，咱们应该使用abstarct class方式来定义。另外，AlarmDoor又具备报警功能，说明它又可以完成报警概念中定义的行为，因此报警概念能够经过interface方式定义。以下所示：

abstract class Door { 
abstract void open(); 
abstract void close()； 
} 
interface Alarm { 
void alarm(); 
} 
class AlarmDoor extends Door implements Alarm { 
void open() { … } 
void close() { … } 
void alarm() { … } 
}

这种实现方式基本上可以明确的反映出咱们对于问题领域的理解，正确的揭示咱们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，你们在选择时能够做为一个依据，固然这是创建在对问题领域的理解上的，好比：若是咱们认为AlarmDoor在概念本质上是报警器，同时又具备Door的功能，那么上述的定义方式就要反过来了。

小结

1. abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。可是，一个类却能够实现多个interface。
2. 在abstract class 中能够有本身的数据成员，也能够有非abstarct的成员方法，而在interface中，只可以有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中通常不定义数据成员），全部的成员方法都是abstract的。
3. abstract class和interface所反映出的设计理念不一样。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 
4. 实现抽象类和接口的类必须实现其中的全部方法。抽象类中能够有非抽象方法。接口中则不能有实现方法。
5. 接口中定义的变量默认是public static final 型，且必须给其初值，因此实现类中不能从新定义，也不能改变其值。
6. 抽象类中的变量默认是 friendly 型，其值能够在子类中从新定义，也能够从新赋值。 
7. 接口中的方法默认都是 public,abstract 类型的。

结论

　　abstract class 和 interface 是 Java语言中的两种定义抽象类的方式，它们之间有很大的类似性。可是对于它们的选择却又每每反映出对于问题领域中的概 念本质的理解、对于设计意图的反映是否正确、合理，由于它们表现了概念间的不一样的关系（虽然都可以实现需求的功能）。这其实也是语言的一种的惯用法，但愿读者朋友可以细细体会。