[关闭]
@Yano 2016-08-07T02:10:50.000000Z 字数 3508 阅读 1776

对象导论

Java编程思想


抽象过程

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

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

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

复用具体实现

使用现有的类合成新的类,称为组合(composition)

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

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

伴随多态的可互换对象

应用场景

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

问题

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

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

前期绑定、后期绑定

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

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

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

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

示例

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

  1. void doSomething(Shape shape){
  2. shape.erase();
  3. shape.draw();
  4. }
  1. Circle circle = new Circle();
  2. Line line = new Line();
  3. doSomething(circle);
  4. doSomething(line);

向上转型

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

单根继承结构

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

好处

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

容器

为什么需要容器?

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

什么是容器?

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

Java类库的容器

为什么需要多种容器?

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

参数化类型

Java SE5之前

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

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

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

Java SE5之后

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

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

对象的创建和生命周期

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

C++

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

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

Java

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

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

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

异常处理:处理错误

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

Java的异常处理

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

并发编程

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

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

并发的隐患

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

总结

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

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

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

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

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注