OO的三大基础是封装、继承、多态。

这三者是有次序性的，没有封装就不可能有继承、没有继承就不可能有多态。

【封装（encapsulation）】

封装的目的是要将代码切割成许多模块（module），每个模块之间的关连性降到最低，这么一来比较不会产生“牵一发而动全身”的状况，降低相互依赖的程度，也等于是降低复杂度，可以让开发与维护更容易。

事实上，没有人用“模块”一词来称呼封装的结果，而是称为“类”，把模块一词做更高阶的包装用途。因此我们现在应该将“类”视为封装的结果，把“模块”视为整个程序切割出来的许多片段。而在OO的世界，一般来说，一个程序有多个模块，一个模块内包含多个类。

封装是以数据为核心，将相关的数据放在一起，将会用到这些数据的函数也放进来。封装等于是将数据和函数放在一起。

【能见度（visibility）】

封装的目的既然是要“降低互相依赖的程度”，就牵涉到能见度的问题：这个类/方法/属性该不该暴露给别的模块、同一个模块的不同类、自己的派生类、友元类？这就是所谓的能见度。

我们当然希望尽可能降低能见度，这才能降低互相依赖的程度。也就是，别人不需要知道的，就不要让它知道，这就是所谓的信息隐藏。

最该被隐藏的是数据。有些人主张所有的数据一定都不可以直接被外部（包括派生类）访问。

上面提到，封装将相关的数据和使用到这些数据的方法包成类。最理想的状况是，让数据的能见度为最低，外面完全看不见。留下的对外接口（Interface）只剩下method。换句话说，每个对象的Interface是一些方法的集合，完全没有数据。

但设定能见度不是一件容易的事，往往需要深思熟虑。能见度设定得太宽，造成信息隐藏效果不佳，可能会带来相当多负面的效果；能见度设定得太紧，造成效率变差、扩充程度变差。

【继承】

被继承的对象称为基类（base）或父类（parent），继承者称为派生类（derived）或子类（child）。

继承的目的，是要达到“代码复用”或“接口复用”。而继承的手段，就是“扩充”或“修改”。这是继承的重点。

继承所导致的代码复用，是指派生类能自动沿袭基类的所有代码，好让你可以不用写太多代码，只需要稍微扩充或修改，就能符合你的需求。扩充指的是：定义新的方法（Method），修改指的是：针对基类中的某方法重新定义其行为。

（PS：代码复用，通过“继承”（Inheritance）和“组合”（Composition）都可以实现。且现在更多的设计是推荐使用“组合”，组合是动态的，有更好的灵活性。继承更多的是为了多态。）

继承所导致的接口复用，是在为OO的下一个阶段（也就是多态）作准备。接口复用，搭配方法的修改，就形成了多态。

如果你不想复用代码，也不想复用接口，或者说你不进行扩充、也不进行修改，那么透过继承产生派生类，几乎是没有意义的。

唯一的一个小小的意义是，派生类和基类两者是不同的类，你可以在程序中依据这一点做判断，做不同的行为。但是这是一种琐细的程序技巧（RTTI），和OO无关，而且OO也不鼓励你这么做。

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

【多重继承与接口】

单一继承指的是，只有一个基类；多重继承指的是，具有多个基类。

多重继承可能会造成不知继承的方法是来自那个基类或祖先类的困扰。 C++要求编程员要主动指明继承的方法来自何处。

所以有些语言往往禁止多重继承（例如Java等）。

从Java开始，多数的语言使用Interface来解决多重继承的问题。但Interface只能让你继承到Interface，无法继承到代码（Interface不带代码）。因此，如果你在Java中继承多个Interface，你必须亲自定义所有Interface的每个方法，也就是说，你必须写许多代码。但如果是在C++中，你可以继承许多类，不需要再定义这些方法。

[关于C++多重继承的底层实现机理，请看这里]

设计继承时，必须先考虑接口是否共享，再考虑代码是否共享，再考虑分类。但是一般的程序员，反倒会先考虑分类和代码复用，而忽略了"接口复用"是其中最重要的事。

【多态Polymorphism】

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

多态让人觉得对象可以以多种面貌出现。当一个对象具有不同的型态，就有可能会引发多态机制。

一个对象为何为有不同的型态？这是因为继承而来，对象可以扮演所有祖先类的角色。例如当某对象的类是派生类，当此对象被“转型”成基类之后，此对象就具有两种不同的类，“实际类”是派生类，“形式类”是基类，此时调用此对象的方法m，会执行到的是基类定义的方法m？还是派生类定义（修改）的方法m？

答案是实际类的方法，也就是派生类定义的方法m。所以所谓的多态就是：不管形式类是什么，一定会执行到实际类的方法。

你可能会觉得疑惑，为何当初要将对象转型为祖先类，导致“形式类”（宣告类）和“实际类”（定义类）不一样？

因为我们想用一个东西（基类）来表示多个东西（派生类）。

更重要的是，良好的设计是面向接口编程。我们在基类定义了接口，在派生类实现，不同的派生类可以有不同的实现。我们可以让接口的使用者不变（使用对象的“形式类”），而改变其“实际类”，改变类的行为。这样可以使程序易于修改和扩展。[比如，框架。]

类的方法，可以分成虚拟（Virtual）与非虚拟两种。只有虚拟方法才能搭配多态机制使用。如果是非虚拟方法，则会执行到形式类（而非实际类）的方法，因为多态没有发挥作用。

关于虚拟，每个语言有不同的作法。 Java强调动态，所以默认是虚拟；C++注重效率，所以默认不是虚拟。

切记：「接口复用」比「代码复用」更重要。这是因为多态的缘故，多态才是OO的终极目的。

[话外：关于重载与覆盖]

覆盖，是指子类重新定义父类的虚函数的做法。（我不喜欢“覆盖”这个名字，容易把人搞晕）

重载，是指允许存在多个同名函数，而这些函数的参数表不同

重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

[注：本段改编自（http://www.cnblogs.com/clongge/archive/2008/07/09/1239076.html）]

【框架】

为了方便软件的开发，许多软件厂商都会提供应用框架（ApplicationFramework），现今流行的框架相当多，例如：.NET Framework等。有了框架，我们终于可以享受到OO的好处，重复利用别人写好的代码，不用一切自己重头写。

框架厂商先将一大部分的程序先写好，程序员只需要“利用继承来做修改”，就能套用整个框架，为了要让你修改的部分能够确实被执行到（而不是执行到框架本身的方法），所以这些允许修改的方法都是定义成虚拟的。

因为程序员“利用继承来做修改”所以产生了派生类和重新定义的方法。框架比这个派生类更早被定义，当然不认识这个派生类，所以框架内都是以此派生类的祖先类为“形式上”的处理对象（处理接口）。当此派生类对象被传入框架中，就会被自动转型成为祖先类，因此产生“形式类”和“实际类”的差异。正因为这样的类差异，加上次类有重新定义方法，所以多态机制出现了。

【乱谈面向对象】

面向过程编程和面向对象编程，是两种不同的世界观。从面向过程来看，解决一个问题是分多个步骤的流程。而从面向对象来看，解决一个问题靠的是相关类的协作。

面向对象是对现实世界直观的模拟，面向对象程序中核心的问题是，类与类之间的关系。

不同的事物有不同的属性，且有不同的能力（类的方法）。对象与对象之间传递消息，根据收到的信息，做出不同的反应。由此协作来解决问题。

类是有相同属性的对象的一种抽象，而基类之于派生类，是在一些派生类中提取共性而成的基类。是一种更高层次的抽象。

抽象，是人类理解改造这个世界的方法。人类总是试图用最简单的理论解释更多的现象。

各个学科和领域也都有相应的理论（比如热力学方程、电磁学方程），它们是对某些范围的事物的一种抽象。牛顿的万有引力，是对所有事物的一种抽象，他提取了万物的共性。这是最高层次的抽象。

（现在比较热门的“弦论”有望成为包罗所有理论的大一统理论，它也许是人类对宇宙的终极抽象吧。^_^）

[注：以上内容有参考网上的，有参考书中的，为平日所搜集，今日之整理，外加自己的一些乱谈。作为一个初级菜鸟，有些地方的理解可能是有问题的，希望大家不吝指正。]