对象导论

Java编程思想

抽象过程

所有编程语言都是抽象机制。人们所能够解决的问题的复杂性，直接取决于抽象的类型和数量。汇编语言是对底层机器的轻微抽象；“命令式语言”（BASIC、C）是对汇编语言的抽象。

它们所作的主要抽象仍要求在解决问题时要基于计算机的结构，而不是基于所要解决的问题的结构来考虑。程序员必须建立起在 机器模型（解空间，对问题建模的地方——计算机）和实际待解决问题的模型（问题空间，问题存在的地方——一项业务）之间的关联。

另一种对机器建模的方式是只针对待解决问题建模。OOP允许根据问题来描述问题，而不是根据运行方案的计算机来描述问题。但是它仍然与计算机有联系：每个对象看起来有点像一个微型计算机——它具有状态，还具有操作。

复用具体实现

使用现有的类合成新的类，称为组合（composition）。

组合具有极大的灵活性，可以在运行时修改成员对象，以实现动态修改程序的行为。继承并不具备这样的灵活性，编译器必须对继承而创建的类施加编译时的限制。

在建立新类时，应该首先考虑组合，因为它更加简单灵活。

伴随多态的可互换对象

应用场景

在处理类型的层次结构时，想把一个对象不当成它所属的特定类型对待，而是将其作为基类的对象来对待，可以编写出不依赖于特定类型的代码。这样的代码不会受添加新类型影响。

问题

试图将导出类型的对象，当作泛化基类型来看待时，编译器在编译时是不可能知道应该执行哪一段代码的。例如把自行车看成交通工具，让交通工具「行驶」，只有在知道这个交通工具是自行车的情况下才有可能。

当发送这样的消息时，程序员并不想知道哪一段代码将被执行；对象会依据自身的具体类型来执行恰当的代码。

前期绑定、后期绑定

编译器不可能产生传统意义上的函数调用。一个非面向对象编程的编译器，产生的函数调用会引起前期绑定。编译器将产生对一个具体函数名字的调用，而运行时将这个调用解析到将要被执行的代码的绝对地址。但是在OOP中，程序直到运行时才能够确定代码的地址，所以当消息发送到一个泛化对象时，必须采用其他的机制。

为了解决这个问题，面向对象程序设计语言使用了后期绑定的概念。当向对象发送消息时，被调用的代码直到运行时才能确定。编译器确保被调用方法的存在，并对调用参数和返回值执行类型检查，但是并不知道被执行的确切代码。

为了执行后期绑定，Java使用一小段特殊的代码替代绝对地址调用，这段代码使用在对象中存储的信息来计算方法体的地址。

C++：必须明确地声明希望某个方法具备绑定属性所带来的灵活性。方法在默认情况下不是动态绑定的。
Java：动态绑定是默认行为，不需要添加额外的关键字来实现多态。

示例

doSomething方法可以与任何Shape对话。

void doSomething(Shape shape){
    shape.erase();
    shape.draw();
}

Circle circle = new Circle();
Line line = new Line();
doSomething(circle);
doSomething(line);

向上转型

把将导出类看做是它的基类的过程称为向上转型。当Java编译器在编译doSomething()的代码时，并不能确切知道doSomething()要处理的确切类型，所以期望调用基类Shape的erase()版本。

单根继承结构

除C++以外的所有OOP语言，所有的类最终都继承自单一的基类。

好处

1. 单根继承结构保证所有对象都具有一个共用接口，所以它们归根到底都是相同的基本类型。
2. 单根继承结构保证所有对象都具备某些功能。
3. 单根继承结构使垃圾回收器的实现变得容易很多。

容器

为什么需要容器？

如果不知道在解决某个特定问题时，需要多少个对象，或者它们将存活多久，那么就不可能知道如何存储对象。如何才能知道需要多少空间来创建这些对象呢？——你不可能知道，这类信息只有在运行时才能获得。

什么是容器？

一种对象类型，持有对其他对象的引用。在任何需要时都可以扩充自己，以容纳所有东西。

Java类库的容器

• List：用于存储序列
• Map：关联数组，用来建立对象之间的关联
• Set：每种对象类型只有一个

为什么需要多种容器？

1. 不同容器提供了不同类型的接口和外部行为。
2. 不同容器对于某些操作具有不同的效率。最好的例子就是两种List：ArrayList和LinkedList。接口List所带来的抽象，把在容器间进行转换时对代码产生的影响降到最小限度。

参数化类型

Java SE5之前

容器存储的对象都是Java的通用类型：Object。单根继承结构意味着所有东西都是Object类型，所以可以存储Object的容器可以存储任何东西。

但是由于容器只存储Object，所以当将对象引用置入容器时，它必须被向上转型为Object，会丢失身份。当把它取回时，就获取了一个对Object对象的引用，而不是具体类型的对象的引用。

这次转型不是向继承结构的上层转型为一个更泛化的类型，而是向下转型为更具体的类型——向下转型。向上转型是安全的，向下转型是不安全的。

Java SE5之后

如何创建容器，使它知道自己所保存的对象的类型，从而不需要向下转型以及消除犯错误的可能？——参数化类型机制。参数化类型是一个编译器可以自动定制作用于特定类型上的类。在Java中成为泛型，使用一对尖括号，中间包含类型信息。

ArrayList<Shape> shapes = new ArrayList<Shape>();

对象的创建和生命周期

使用对象，最关键的问题是生成和销毁的方式，因为每个对象都需要占用内存。当我们不需要一个对象时，它必须被清理掉，使其占有的资源可以被释放和重用。

C++

为了追求最大的执行速度，对象的存储空间和生命周期可以在编写程序时确定，通过将对象置于堆栈或静态存储区域内实现。

这种方式将存储空间分配和释放放在最优先的位置，但是牺牲了灵活性，因为必须在编写程序时知道对象确切的数量、生命周期和类型。

Java

在堆（heap）的内存池动态地创建对象。在这种方式中，直到运行时才知道需要多少对象，它们的生命周期如何，以及它们的具体类型是什么。这些问题只能在程序运行时相关代码被执行到的那一刻才能确定。

如果需要一个新对象，可以在需要的时刻直接在堆中创建。因为存储空间是在运行时被动态管理的，所以需要大量的时间在堆中分配存储空间，这可能＞＞在堆栈中（C++）创建存储空间的时间。

动态方式基于一个一般性的逻辑假设：对象趋于复杂，所以查找和释放存储空间的开销不会对对象的创建造成重大冲击。Java完全采用了动态内存分配方式。

异常处理：处理错误

异常处理就像是与程序正常执行路径并行的、在错误发生时执行的另一条路径。因为它是另一条完全分离的执行路径，所以它不会干扰正常的执行代码。

Java的异常处理

Java一开始就内置了异常处理，而且强制你必须使用它。它是唯一可接受的错误报告方式。如果没有编写正确的处理异常的代码，那么就会得到一条编译时的错误。这种有保障的一致性有时会使得错误处理变得非常容易。

并发编程

如何在同一时刻处理多个任务？把问题切分成多个可独立运行的部分，从而提高程序的响应能力。在程序中，这些彼此独立运行的部分称为线程，上述概念称为“并发”。

线程只是一种为单一处理器分配执行时间的手段。但是如果操作系统支持多处理器，那么每个任务都可以被指派给不同的处理器，并且它们是在真正地并行执行。在语言级别上，多线程使得程序员不再操心机器是多处理器还是一个处理器。

并发的隐患

共享资源。如果有多个并行任务都要访问同一个资源，就会出问题。对于共享的资源，必须在使用期间被锁定。

总结

过程型语言：数据定义和函数调用。

因为OOP在你能够在过程型语言中找到的概念的基础上，又添加了许多新概念，所以你可以假设：由此而产生的Java程序比等价的过程型程序要复杂得多。但是你会感到很惊喜：编写良好的Java程序通常比过程型程序要简单得多，而且易于理解得多。

你只需要两部分内容的定义：用来表示问题空间概念的对象，发送给这些对象的用来表示在此空间内的行为的消息。许多问题都可以通过重用现有的类库代码而得到解决。

即使最终仍旧选择Java作为编程语言，至少也要理解还有哪些选项可供选择，并且对为什么选择这个方向要有清楚的认识。