@Yano
2016-08-07T10:10:50.000000Z
字数 3508
阅读 2625
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语言,所有的类最终都继承自单一的基类。
如果不知道在解决某个特定问题时,需要多少个对象,或者它们将存活多久,那么就不可能知道如何存储对象。如何才能知道需要多少空间来创建这些对象呢?——你不可能知道,这类信息只有在运行时才能获得。
一种对象类型,持有对其他对象的引用
。在任何需要时都可以扩充自己,以容纳所有东西。
容器存储的对象都是Java的通用类型:Object。单根继承结构意味着所有东西都是Object类型,所以可以存储Object的容器可以存储任何东西。
但是由于容器只存储Object,所以当将对象引用置入容器时,它必须被向上转型为Object,会丢失身份。当把它取回时,就获取了一个对Object对象的引用,而不是具体类型的对象的引用。
这次转型不是向继承结构的上层转型为一个更泛化的类型,而是向下转型为更具体的类型——向下转型。向上转型是安全的,向下转型是不安全的
。
如何创建容器,使它知道自己所保存的对象的类型,从而不需要向下转型以及消除犯错误的可能?——参数化类型机制。参数化类型是一个编译器可以自动定制作用于特定类型上的类。在Java中成为泛型,使用一对尖括号,中间包含类型信息。
ArrayList<Shape> shapes = new ArrayList<Shape>();
使用对象,最关键的问题是生成和销毁的方式,因为每个对象都需要占用内存。当我们不需要一个对象时,它必须被清理掉,使其占有的资源可以被释放和重用。
为了追求最大的执行速度,对象的存储空间和生命周期
可以在编写程序时确定,通过将对象置于堆栈
或静态存储区域内实现。
这种方式将存储空间分配和释放放在最优先的位置,但是牺牲了灵活性,因为必须在编写程序时知道对象确切的数量、生命周期和类型。
在堆(heap)的内存池
动态地创建对象。在这种方式中,直到运行时才知道需要多少对象,它们的生命周期如何,以及它们的具体类型是什么。这些问题只能在程序运行时相关代码被执行到的那一刻才能确定。
如果需要一个新对象,可以在需要的时刻直接在堆中创建。因为存储空间是在运行时被动态管理的,所以需要大量的时间在堆中分配存储空间,这可能>>在堆栈中(C++)创建存储空间的时间。
动态方式基于一个一般性的逻辑假设:对象趋于复杂,所以查找和释放存储空间的开销不会对对象的创建造成重大冲击。Java完全采用了动态内存分配方式。
异常处理就像是与程序正常执行路径并行的、在错误发生时执行的另一条路径。因为它是另一条完全分离的执行路径,所以它不会干扰正常的执行代码。
Java一开始就内置了异常处理,而且强制你必须使用它。它是唯一可接受的错误报告方式。如果没有编写正确的处理异常的代码,那么就会得到一条编译时的错误。这种有保障的一致性有时会使得错误处理变得非常容易。
如何在同一时刻处理多个任务?把问题切分成多个可独立运行的部分,从而提高程序的响应能力。在程序中,这些彼此独立运行的部分称为线程,上述概念称为“并发”。
线程只是一种为单一处理器分配执行时间的手段。但是如果操作系统支持多处理器,那么每个任务都可以被指派给不同的处理器,并且它们是在真正地并行执行。在语言级别上,多线程使得程序员不再操心机器是多处理器还是一个处理器。
共享资源
。如果有多个并行任务都要访问同一个资源,就会出问题。对于共享的资源,必须在使用期间被锁定
。
过程型语言:数据定义和函数调用。
因为OOP在你能够在过程型语言中找到的概念的基础上,又添加了许多新概念,所以你可以假设:由此而产生的Java程序比等价的过程型程序要复杂得多。但是你会感到很惊喜:编写良好的Java程序通常比过程型程序要简单得多,而且易于理解得多。
你只需要两部分内容的定义:用来表示问题空间概念的对象,发送给这些对象的用来表示在此空间内的行为的消息。许多问题都可以通过重用现有的类库代码而得到解决。
即使最终仍旧选择Java作为编程语言,至少也要理解还有哪些选项可供选择,并且对为什么选择这个方向要有清楚的认识。