文/陈刚 at 2006年4月12日　from www.ChenGang.com.cn


前段时间把一个界面框架完成了，今天基于这个框架开发一个小模块，在这里把这个模块设计的全过程记录下来，希望大家讨论并指正。

一、起因

公司交给我一个任务，为测试员写一个手机模拟界面，以方便她们的手机短信测试。过去她们都是用MC4J直接调用公司服务器的MBean服务来模拟进行测试，以验证我们整个系统平台。这种测试主要是检查收发短信是否正常，而我的要做的工作就是，让她们在测试的时候更方便更直观。

二、需求

我和测试员陈MM（也就是软件的使用者）约定了一个时间，大家一起来讨论这个软件的需求。

1、首先，我大概了解了一下她们的测试工作，知道我要做个什么东东。

2、然后我回去思考了一下，再次找她详细了解其测试的具体步骤，并在一张白纸上以UML用例图的方式，记录下需求的功能。用例是什么？用例就是需求，就是你的软件应该具有的功能，当然用例图只是概括性的对功能进行了描述。

3、最后，我坐在我的电脑前开始用MagicDraw UML来画用例图（我不喜欢用Rose，那玩意太笨重了，界面友好性也不好）。在画用例图的时候，我发现了一些隐含的功能，这些是陈MM在和我做需求时没有考虑到的（注：开发者应该为用户挖掘隐含需求）。我和陈MM一一确定了这些我新发现的需求，最后得到如下的用例图。

（1）手机前台测试操作的用例图（说明：include是指某用例包含(include)子用例）


 （2）后台管理



三、界面设计

接下来是界面设计。既然是手机模拟，我很自然就拿我的motorola手机的操作界面来做参考。不过这里应该注意到，手机操作环境和电脑操作环境不尽相同（比如说电脑有鼠标，还有键盘可以输入文字），所以没有必要唯妙唯肖的完全模枋，还是以使用者操作方便为主。

界面设计是很重要的一步，不要一上来就写程序，一定要先做到心中有个大概，否则返工的可能性就很大。而且，把界面拿出来给客户看，客户也就能做到心中有数，还能尽早提出一些新需求和意见来。千万不要等到软件做完了再拿给客户看，到时客户看了如果要修改，那就做太多白费工了。

由于软件界面相对简单，陈ＭＭ基本没有提修改意见，但这不是个好兆头。不过极限编程就是要拥抱变化不是^_^。咱不怕她改，只要大致的界面她能定下来就行了。

界面我喜欢用Visio来画，当然也听说有人喜欢用ＶＢ来快速构建界面原型的，看个人喜好了。整个界面如下：




这个是后台管理界面




四、类图

类图反映了软件的数据模型。在设计数据模型，我参考了界面设计图和用例图，找出一个个的类。然后参照用例图的一个个功能，设计出了各类的属性和方法。设计初始的类图当然不可能很详细，但至少应该看到个大概。有错误不要紧，后期可以慢慢修正，但大体关系就算定下来了。

Neil（公司ＣＴＯ，一个40岁左右的真正的资深程序员）说：看一个软件的设计主要看两个类：类图和时序图。类图确定了软件数据模型的静态关型，时序图则是数据模型的动态关系。

类图如下，看英文大致可以知道类／属性／方法的含义和作用了，就不一一介绍了。






五、时序图

时序图是本文最后一个图，时序图表明了用例图中各功能的实现方案，同时也反应了类图中各类的交互关系。以后程序的逻辑和时序图基本一致。不过，有些人会去画得很详细的时序图，详细到都快赶上伪代码级别了，我觉得这没必要。我把时序图看做反映自己思路的大概过程，所以也就画个大概。

我认为时序图要简洁易懂，这样以后你的后继维护者，拿到这个软件的时序图（当然也包括用例图、类图），就能明白你的大概设计思路。另外，画时序图也能整理自己的思路，同时还可以对类图的设计进行验证。在画这个时序图的过程中，我就纠正了在类图中的几处考虑不周的地方。

总结：时序图可以（１）整理思路（２）验证类的设计（３）是很好的软件文档，对维护者理解代码很有帮助。

这里仅给出其中几个时序图（实际上我也没有把用例都画完，有些类似的简单的，就忽略了）

（１）新增一个手机号码


（２）关机

（３）开机

（４）发送短信




到这里设计阶段就完成了，用时一天。下一步是编码，将应用ＴＤＤ先写测试代码的方式来写代码，下次再介绍了。

作者简介

陈刚，广西桂林人，著作有《Eclipse从入门到精通》
您可以通过其博客了解更多信息和文章：http://www.ChenGang.com.cn
版权声明：本博客所有文章仅适用于非商业性转载，并请在转载时注明出处及作者的署名。

异常处理

●      概念

●      异常处理

●      激发异常

●      创建自己的异常

●      示例

Java 语言的设计从根本上便于我们写出整洁、设计良好的代码；尽管如此，在程序运行中仍可能有各种各样的错误出现。

1 、概念

采用新的异常处理机制

      在以往的程序开发过程中，常常采用返回值进行处理。例如，在编写一个方法，可以返回一个状态代码，调用者根据状态代码判断出错与否。若状态代码表示一个错误，则调用这进行相应的处理，或显示一个错误页面或错误信息。通过返回值进行处理的方法是有效的，但是有它的许多不足之处。

1 、   程序复杂

2 、   可靠性差

3 、   返回信息有限

4 、   返回代码标准化困难

采用错误代码和异常处理相结合的方式的优越性：

1 、   把错误代码与常规代码分开

2 、   可以在 catch 中传播错误信息

3 、   可以对错误类型分组

4 、   方便定位错误，维护

异常

异常就是异常事件，它是程序遇到异常情况所激发的事件。许多异常，如程序错误，空指针，数组溢出等。下面是一个出错流程

上图中：

第一步：插入用户的 Keynet ，登录系统

第二步：服务器验证用户的身份，判断用户的权限

第三步：返回错误的信息。

这是一个简单的异常处理示例，怎样简单、方便、快捷的得到错误信息。可以采用错误代码和异常两种方式相结合的方式处理。

2 、异常处理

Java 的异常是面向对象的。一个 Java 的 Exception 是一个描述异常情况的对象 . 当出现异常情况时，一个 Exception 对象就产生了 , 并放到异常的成员函数里。

Java 的异常处理是通过 5 个关键词来实现的： try,catch,throw,throws 和 finally 。在 Java 语言的错误处理结构由 try ， catch ， finally 三个块组成。其中 try 块存放将可能发生异常的 Java 语言，并管理相关的异常指针； catch 块紧跟在 try 块后面，用来激发被捕获的异常； finally 块包含清除程序没有释放的资源，句柄等。不管 try 块中的代码如何退出，都将执行 finally 块。

try … catch … 块

可以采用 try 来指定一块预防所有异常的程序。紧跟在 try 程序块后面，应包含一个

或多个 catch 子句来指定你想要捕获的异常类型： try catch 的格式一般为：

try{

/**do something*/

}catch(…){

…

}catch(…){

   …

}

例如：

try{

int a= 100/0

}catch(Exception e){;

System.out.println(e.getMessage());

}

每当 Java 程序激发一个异常时，它实际上是激发了一个对象，而只有其超类为 Throwable 类的对象才能被激发。 Throwable 类中的提供了一些方法。如：其中的 getMessage() 方法打印出异常对应信息。

Catch 子句的目标是解决异常情况，把变量设到合理的状态，并象没有出错一样继续运行。如果一个子程序不处理没个异常，则返回到上一级处理，如此可以不断的递归向上直到最外一级。

finally 块

finally 关键字是对 Java 异常处理模型的最佳补充。 finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。如果没有 finally ，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：

import java.net.*;import java.io.*;

class WithoutFinally{ 

public void foo() throws IOException  {    // 在任一个空闲的端口上创建一个套接字    

ServerSocket ss = new ServerSocket(0);   

try {      Socket socket = ss.accept();    

 // 此处的其他代码 ...    }   

catch (IOException e) {

      ss.close();                        //1     

throw e;    }

   ss.close();               //2  }}

这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close ，它是该方法的最后一条语句。但是，如果 try 块中发生一个异常会怎么样呢？在这种情况下， //2 处的 close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。

这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。 Java 中的 finally 子句解决了这个问题。有了 finally ，前面的代码就可以重写为以下的形式：

import java.net.*;import java.io.*;

class WithFinally{

public void foo2() throws IOException  {

// 在任一个空闲的端口上创建一个套接字    

ServerSocket ss = new ServerSocket(0);   

try {      Socket socket = ss.accept();     

// 此处的其他代码 ...    }  

finally {     

ss.close();   

}}}

finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。

finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，如果您在 try 块执行期间拨掉电源， finally 也不会执行。）

try … catch … finally 块

最好采用此结构处理异常 . 在 catch 中捕获异常 , 在 finally 块中清除不需要的资源 , 这样程序结构将会更完善 , 健壮 . 例如 :

try{

      /**to do */

}

catch(Exception ex){

      System.out.println(ex.getMessage());

}

finally{

      clearUpAll()

}

3 、激发异常

Java 语言可以不在方法中直接捕获，而用 throw 语句将异常抛给上层的调用者。 Throw 语句就是来明确地抛出一个异常；首先你必需得到一个 Throwable 的实例句柄，通过参数传到 catch 中，或者采用 new 操作符来创建一个。

格式： throw new WhcaException(e.getMessage);

程序会在 throw 语句后立即终止，它后面的语句都不执行，然后在包含它的所有 try 块中从里到外寻找含有与其匹配的 catch.

声明异常类

当 throw 语句被用在方法说明中时， throw 有用 throws 代替。关键字 throws 用来标明一个方法可能抛出的各种异常。对大多数 Exception 子类来说， Java 编译器会强迫你声明在一个方法中抛出的异常的类型。如下：

格式： type method_name(arg_list) throws WhcaException{

             ……

}

例如： public void execute(String str,int index) throws WhcaException{

             try{

}

             catch(Exception e){

                    throw new WhcaException(“JB: M:”+e.getMessage)

}

}

4 、创建自己的异常类

当程序员为提供一些特定的功能用 Java 类时，往往需要保证类之间有良好的关系，而且类之间的接口易于理解和实现，这是定义一个新的异常类。建议创建自己的异常类，便于维护，管理。

定义一个新的异常类

      通常采用 Exception 作为异常类的超类，如：

package whca.common;

public class WhcaException extends Exception{

    public WhcaException(){

    }

    public WhcaException(String s){

        super(s);

    }

}