如何用Java编写自己的库（1）

核心提示：任何一种面向对象语言都有它的库，任何一种面向对象的语言也都离不开库的支持，如何用Java编写自己的库（1），用我们熟悉的 面向对象语言为例子，C++有STL，调试信息就被输出到这个流中， // set this to a print stream if you want debug info // sent to it

　　任何一种面向对象语言都有它的库。任何一种面向对象的语言也都离不开库的支持。用我们熟悉的 面向对象语言为例子，C++有STL，java有API函数，具体到开发工具，Visual C++提供了MFC，Borland C++提供了OWL。也有很多第三方提供的库。我们在开发应用程序的时候，也发觉我们也许需要某些特定的库来完成特定的功能。那么，如何编写自己的库呢？
　　利用Java的面向对象特性，如封装，继续，和一些设计模式，我们可以用标准的方法来建立自己的库。需要明白的一点：在你需要完成某个功能的时候，不要用专有的、特定的方法去编写代码，而要全盘考虑，用通用的方法来完成，这样，在积累了一定数量的库以后，你就能重用这些库来完成新的功能，而不用每回都重头编写代码。这也是面向对象语言提供给我们的好处。也可以用J2EE的 规范为例子，J2EE提供了一个CBT(Component Based Transaction)，所有的组件都尊崇J2EE规范，在CBT中运行，这样，编写开发并且重用标准的通用的组件库，可以缩短开发周期节约成本，并且可 以在任何符合J2EE规范的应用程序服务器(application SERVER)中运行，并且可以继续，扩展已 有的组件库完成新的任务或者适应新的变化。
　　在本文中，我将先讨论如何建立自己的库，需要根据哪些标准，然后给出一个简单的例子。在第二 部分中，我将通过一个功能比较完善的库来做进一步的讨论。
　　什么是库
　　什么是库？
　　库是一个可以重用的组件，它采用通用的设计，完成通用的任务，可以节约开发者的时间，缩短开发周期节约开发成本。一个设计完善的库，并不只是为了完成某一个特定的任务，而是可以完成各种不同的任务。设计一个库是困难的。写一个算法并不难，但是设计库的时候需要一种比较好的结构，它能够被用在各种需要的环境下，完成各种不同的任务，但是还不能影响使用它的 程序代码结构。
　　为什么要重用代码？
　　重头开发一个新的软件，工作量是非常巨大的，不论你用什么工具什么语言。而代码重用能够节约大部分时间，而把时间花在新的功能的开发上。从一定的意义上来说，写一个新的软件是利用了现有的代码，重新拼装以实现新的功能。从另外一个角度上来讲，即使你没有打算把你写的代码变成一个通用的库并分发给其他人使用，从设计的角度来讲，采用一种全盘的通用的设计方法也能让你对所要完成的任务有更好的理解，并且优化你的设计过程，从而优化你的代码结构。
　　采用开发库并且让别人来使用它的方式，能够帮助你在使用它的时候发现它的设计上的缺陷或者代码中的错误，并帮助你改正它。比方说，你写了一个库让别人来使用，你不得不考虑通用的设计，因为你并不能预见别人将在什么环境下使用和使用的目的。在其他人使用你的库的过程中，可能会碰到一些问题，有的可能是你的文档写得不够清楚明白，有的也可能是你程序上的错误，也有可能是使用者觉得在结构上使用起来不方便或者不正确。那么你可以继续作一些修改工作，在保持结构 和接口不变化的情况下，做一些调整。
　　如何设计库
　　在设计库的时候，你需要以一个使用者的眼光来看问题，考虑如何设计和实现它。你需要明白：
　　1、需要解决的问题是什么？需要达到一个什么目的？
　　2、使用者关心的问题是什么？使用者需要得到一个什么结果？
　　3、使用者不需要关心的问题是什么？什么细节是可以对使用者隐藏的？
　　下面，我们用一个简单的例子来说明如何设计和实现一个有用处的库。
　　设计一个网络服务程序，我们需要考虑几点：
　　1、监听一个端口
　　2、接受连接
　　3、读取或者写入连接的流
　　4、处理输入的数据，并且返回一个结果
　　对于我们将要实现的库来说，需要完成的是前三点，而最后一点我们留给使用者去实现，这也是使用者需要完成和关心的地方。
　　库的主要类叫做Server，测试的类叫做EchoServer. EchoServer实现了一个简单的服务，从客户端读取数据，并且返回同样的数据。
　　设计原则一：封装
　　一个好的库必须是一个紧凑的关系紧密的整体，而不是一个分散的关系松散的对象的集合。
　　package是Java提供的一种类库的封装机制。一个package是一个Java类文件的集合，存放在同一个目录中。package有专有的名字空间。
　　专有的名字空间的一个好处是，你不用担心名称的冲突。因为，假如你的类的名称和别人的类的名称冲突，但是他们不在同一个package中，利用这一点可以避免名字的冲突。
　　每一个package都有一个字符串来代表，比如java.lang，或者javax.swing.plaf.basic.实际上每一个类的全名都是由package的名字加上类的名字来代表的，这样就避免了名字的冲突，比如，java.lang.Object或者javax.swing.plaf.basic.BasicMenuBarUI。
　　注重，有一个非凡的package叫做default package。假如你不声明你的类属于任何一个package，那么它就被假定属于default package。
　　每一个package的名字都对应一个目录。比如，java.lang.Object存放在java/lang/Object.java中，每一 个.对应一个/. default package存放的目录是当前目录。
　　声明一个package.
　　// Server.java
　　package mylib;
　　public class Server implements Runnable
　　{
　　// ...
　　假如有import语句，必须放在package语句的后面。 当然你也可以引入别的package. 例如：
　　import mylib.Server;
　　// ...
　　Server server = new Server( portNum );
　　Java答应你决定package中的哪些类对外部是可见的。public类可以被包外的代码使用，而PRivate类 则不行。
　　比如，让Server类能被外部的代码使用：
　　// Server.java
　　package mylib;
　　import java.io.*;
　　import java.net.*;
　　public class Server implements Runnable
　　{
　　假如你不想让类被外部的代码使用，可以用缺省的属性，去掉public. 例如：
　　// Reporter.java
　　package mylib;
　　class Reporter implements Runnable
　　{
　　设计原则二：继续
　　在我们的例子中，Server是主要的类。假如你看这个类的代码，就能看到，它本身其实什么也不做。主循环用来监听连接。当连接建立以后，它把处理连接的任务交给一个叫做handleConnection() 的函数。
　　// subclass must supply an implementation
　　abstract public void handleConnection( Socket s );
　　因为没有实现这一函数，所以这个类被声明为abstract，使用者必须实现这个函数。
　　// This is called by the Server class when a connection
　　// comes in. "in" and "out" come from the incoming socket
　　// connection
　　public void handleConnection( Socket socket ) {
　　try {
　　InputStream in = socket.getInputStream();
　　OutputStream out = socket.getOutputStream();
　　// just copy the input to the output
　　while (true)
　　out.write( in.read() );
　　} catch( IOException ie ) {
　　System.out.println( ie );
　　}
　　}
　　可以说，这一继续的过程叫做定制。因为在Server类中，并没有定义该函数的动作，而是把这个定 义的过程留给使用者，让他们来完成所需要的特定的功能。
　　另外一个定制函数：cleanUp().
　　在设计类的时候，往往你能考虑到使用者需要的功能，例如上面的handleConnection().但是，也需要 考虑另外一种定制，例如在这里，在Server退出后台运行方式的时候，调用了这个cleanUp()函数， 在Server类中的实现为空，什么都不做，这把机会留给使用者，使用者可以用这个函数来做一些清 除工作，这种函数也可以称之为"钩子"。
　　设计原则三：调试
　　没有人能够做到写出一个绝对完美的程序，没有任何的错误。所以，调试是不可缺少的。有时候， 使用者可能会碰到一个问题，从而需要知道在库的代码中发生了什么问题。这个错误可能是库代码 的问题，也可能是使用者的代码在库代码中引起的问题。
　　假如你提供了库的源代码，使用者可以用debugger来调试错误。但是，你不能完全依靠于调试器。 在库代码中加入打印调试信息的语句，是一个好习惯。它可以帮助使用者明白，什么地方发生了错 误。
　　下面的例子说明了这一技术。使用者的代码使用Server.setDebugStream(),指定一个PrintStream对 象。然后，调试信息就被输出到这个流中。
　　// set this to a print stream if you want debug info
　　// sent to it; otherwise, leave it null
　　static private PrintStream debugStream;
　　// call this to send the debugging output somewhere
　　static public void setDebugStream( PrintStream ps ) {
　　debugStream = ps;
　　}
　　
　　
　　当使用者使用了调试的流的时候，你的库代码可以打印错误：
　　
　　// send debug info to the print stream, if there is one
　　static public void debug( String s ) {
　　if (debugStream != null)
　　debugStream.println( s );
　　}
　　
　　
　　下面，来完整的看一看这个具体的例子：
　　
　　EchoServer
　　// $Id$
　　import java.io.*;
　　import java.net.*;
　　import mylib.*;
　　public class EchoServer extends Server
　　{
　　public EchoServer( int port ) {
　　// The superclass knows what to do with the port number, we
　　// don't have to care about it
　　super( port );
　　}
　　// This is call