2.存储一个汉字需要2个字节，所以，要存放10个24*24点阵的汉字字模，需要10*24*24/8=720B

**3.CAD完整的拼写形式为：Computer Aided Design，中文意思是计算机辅助设计。

4.CPU是由运算器和控制器两部分组成，可以完成指令的解释与执行。计算机的存储器分为内存储器和外存储器。

内存储器是计算机主机的一个组成部分，它与CPU直接进行信息交换，CPU直接读取内存中的数据。

5.非零无符号二进制整数之后添加一个0，相当于向左移动了一位，也就是扩大了原来数的2倍。在一个非零无符号二进制整数之后去掉一个0，相当于向右移动一位，也就是变为原数的1/2。

6.计算机最主要的工作特点是存储程序与自动控制，其他选项均是其中的一部分特点。

7.存储器分为内存储器和外存储器，随机存储器RAM、只读存储器ROM都属于内存储器，RAM有四种类型：DRAM（动态RAM）、SRAM（静态RAM）、CMOS ROM、VRAM（视频RAM）。

8.5位无符号二进制数可以从最小的00000至最大的11111，即最大为2^5-1=31。

9.五笔字形码输入法属于形码输入法，它是以汉字的形状特点为每个汉字进行编码，其思想是依据汉字的笔划特征将基本笔划划分为5类并分别赋以代号。

*10.计算机网络按地理区域范围可分为：局域网、城域网和广域网。

   1.局 域网（local area network，LAN）。其典型应用场合：（1）同一房间内的所有主机，覆盖距离10米数量级。（2）同一房楼宇内的所有主机，覆盖距离100米数量 级。（3）同一校园内、厂区内、院落内的所有主机，覆盖范围在1公里数量级。答案中的Ethernet网、Novell网和Token Rings网属于局域网。

   2.城域网（metropolitan area network，MAN）。指所有主机（工作站点）分布在同一城区内。覆盖范围约在10公里数量级。

   3.广域网（wide area network，WAN）。指在网络中所有主机与工作站点分布的地理范围，能覆盖几公里以上的范围，包括10公里、100公里与1000公里以上的数量级，比如同一城市、同一国家、同一洲甚至跨越几个洲等。Chinanet网属于广域网。

11.Pentium 4/1.7G中 的1.7G表示CPU的时钟主频为1.7GHz。计算机的存储系统由高速缓存（Cache）、主存和外存组成，高速缓存的特点是存取速度快、容量小，它存 储的内容是主存中经常被访问的程序和数据的副本。使用它的目的是提高计算机运行速度。运算速度指微机每秒能执行的指令数，单位为MIPS或MFLOPS （Million FLOating Point Per Second----每秒百万条浮点指令），目前微机的运算速度在200～300MIPS以上，计算机的运算速度受主频和内存速度的制约。

12.硬盘容量是指微型计算机硬盘所能容纳信息的字节数。

13.汇编语言虽然在编写、修改和阅读程序等方面有了相当的改进，但仍然与人们的要求有一定的距离，仍然是一种依赖于机器的语言。

14.不间断电源（UPS）总是直接从电池向计算机供电，当停电时，文件服务器可使用UPS提供的电源继续工作，UPS中包含一个变流器，它可以将电池中的直流电转成纯正的正弦交流电供给计算机使用。

15.用C 语言、FORTRAN语言等高级语言编制的源程序，需经编译程序转换为目标程序，然后交给计算机运行。由BASIC语言编制的源程序，经解释程序的翻译， 实现的是边解释、边执行并立即得到运行结果，因而不产生目标程序。用汇编语言编制的程序，需经汇编程序转换为目标程序，然后才能被计算机运行。用数据库语 言编制的源程序，需经数据库管理系统转换为目标程序，才能被计算机执行。

16.多媒体计算机是指能综合处理多种媒体信息（如文字、图形、图像、声音等），使多种信息建立联系，并具有交互性的计算机系统。

17.八进制数10化成十进制数是1*8^1+0*8^0=8。

   十六进制数10化成十进制数是1*16^1+0*16^0=16。

   二进制数10化成十进制数是1*2^1+0*2^0=2。

18.汉 字机内码是计算机系统内部处理和存储汉字的代码，国家标准是汉字信息交换的标准编码，但因其前后字节的最高位均为0，易与ASCII码混淆。因此汉字的机 内码采用变形国家标准码，以解决与ASCII码冲突的问题。将国家标准编码的两个字节中的最高位改为1即为汉字输入机内码。

19.局域网是由网络服务器、工作站或客户机、网络适配器（网卡）、传输介质和网络互连设备组成。

   网间互连设备有中继器、集线器、网桥、路由器、网关和交换集成器。

20.批处理系统不属于交互系统。

　 由于批处理系统禁止用户与计算机系统的交互，因此比较适合那些对处理时间要求不太严、作业运行步骤比较规范、程序已经过考验的作业。

21."2000年问题"是有关计算机处理日期的问题。

22.CD-ROM盘片容量要比软件磁盘容量大得多，目前一张CD-ROM盘片可存放的字节数是640MB。

23.目前微型计算机的CPU可以处理的二进制位至少为8位。

24.在 计算机中，把计算机硬件能够直接识别和执行的命令称之为指令。指令是由一组二进制代码组成，规定了计算机执行程序操作。一台计算机硬件可以识别和执行若干 条指令，一台计算机所能执行的所有指令的集合就是这台计算机的指令系统。指令系统是计算机性能的集中表现，它没有统一的标准，不是所有的计算机指令系统都 相同的。

程序就是为解决某一问题而设计组合的一系列指令。

25.程序设计语言通常分为：机器语言、汇编语言和高级语言三类。机器语言是计算机唯一能够识别并直接执行的语言。必须用翻释的方法把高级语言源程序翻释成等价的机器语言程序才能在计算机上执行。目前流行的高级语言如C、C++、Visual Basic等。

26.正确的电子邮箱地址的格式为：用户名+@+计算机名+机构名+最高域名。

27.由 于计算机中的双字节汉字与单字节的西文字符是混合在一起处理的，所以汉字信息如不予以特别的标识，则它与单字节的ASCII码就会混淆不清，无法识别。为 了解决这个问题，采用的方法之一，就是使表示汉字的两个字节的最高位等于"1"。这种高位为1的双字节（16位）汉字编码称为汉字的"机内码"，又称"内 码"。

28.所谓软件是指为方便使用计算机和提高使用效率而组织的程序以及用于程序开发、使用、维护的有关文档。

29.通常把计数制中使用符号的个数称为该进位制的基数。十进制的基数为10。

30.一条指令包括操作码和操作数地址两个部分。操作码指定计算机执行什么类型的操作；操作数地址指明操作数所在的地址和运算结果存放的地方。

31.Alt键又称为转换键，Ctrl键又称为控制键，Shift键又称为上档键。

32.计算机实际执行程序和加工处理数据时，外存储器中的信息需要先传送入内存储器后才能被CPU使用。

33.根据Internet的域名代码规定，域名中的net表示网络中心，com表示商业组织，gov表示政府部门，org表示其他组织。

34.一般所说的存储器的管理都是指对内存储器的管理。

35.有符号数表示范围是：-32767～32767；无符号数表示范围是：0～65535。

36.计算机中的浮点数表示法包括两个部分：一部分是阶码（表示指数，记作E）；另一部分是尾数（表示有效数字，记作M）。

37.通常，字节是主存储器中信息的基本编址单元，即一个存储单元存放一个字节。主存单元从0开始依自然数编号，最大地址加1就是存储器的存储容量。例如，存储容量为1KB时，其地址为0--1023（十进制）。

38.编译是将用高级语言编写的源程序整个翻译成目标程序，然后将目标程序交给计算机运行；解释是对用高级语言编写的源程序逐行进行分析，边解释、边执行，立即得到运行结果，它不产生目标程序。

39.能被计算机直接识别的并执行的二进制代码语言称为机器语言，用助记符表示二进制代码的机器语言称为汇编语言，高级语言是同自然语言和数字语言比较接近的计算机程序设计语言，用高级语言不能直接在机器上运行，需要通过编译程序转换成机器语言，程序才能在机器上执行。

● 初始化和清除是程序设计安全性的两个最重要的问题

● 创建对象时：1.分配空间    2.调用构造函数对这个对象进行初始化    3.然后把初始化完了对象交给那个引用

● 重载
在日常生活中，我们用相同的词表达多种不同的含义，即词的“重载”。
大多数程序设计语言要求我们为每个函数都设定一个独一无二的标识符。
但是构造函数的出现要求函数名也要能够“重载”。
即函数名相同，参数不同的构造函数
使用时各自调用不同的参数构造函数。

构造函数名与类名相同

● 缺省构造函数
如果一个类没有定义构造函数，则编译程序会帮我们自动创建一个缺省构造函数。
但是一旦定义了一个，就不会帮我们自动生成一个。

● this
this关键字可以为已调用了其方法的那个对象生成相应的句柄。
调用这个函数的那个对象--this，即这个函数要作用在哪个对象之上。
在一个构造函数中可以调用一次另一个构造函数，用this(参数)

● 垃圾收集机制
垃圾收集机制只知道怎样释放由new分配的内存，所以它不知道如何释放对象的“特殊”内存。一旦垃圾收集机制准备好释放对象中占用的存储空间，他首先调用finalize()。
finalize() 由Object定义

在构造函数内只进行基本的初始化

定义初始化：
一个直接的做法是在定义数据成员的同时也为其赋值
可以调用一个方法进行初始化
在构造函数之前就进行定义初始化

用一个类创建类的对象时，先分配一个空间，依次做成员变量的定义初始化，再调用构造函数。

● 静态数据初始化
静态的东西属于类。
类Class与类对象。
如果一个变量是一个静态变量的话，所有对象里的这个变量的值是同一个。
静态数据成员只在这个类的第一个对象要创建的时候初始化（装载这个类的时候）。

运行java命令后，启动jvm，找到类的定义文件，找到类的定义文件之后，装载；装载完成之后在内存里形成了一个类对象来代表这个类，然后要对这个类对象里的静态成员变量进行初始化

初始化顺序
1.类型为Dog的一个对象首次创建时，或者Dog类的静态方法/数据首次访问时，Java解释器必须找到Dog.class。
2.找到Dog.class后，它的所有的静态初始化模块都会运行。因此，静态初始化仅发生一次。
3.创建一个new Dog()时，new语句首先会在堆里分配一个足够的空间。
4.这个空间将会被清除为零，因此Dog中所有的数据成员都得到了缺省值。
5.执行定义初始化。
6.执行构造函数。
先静态后动态；先定义初始化后构造函数。

● 显式初始化
静态初始化块，地位相当于一条静态初始化语句
定义初始化块，地位相当于一条定义初始化语句

● 数组
数组代表一系列对象或者基本数据类型，所有相同类型的对象都封装在一起——采用一个统一的标识符名称。
数组变量实际上是一个指向数组的句柄（引用），所以推荐使用int[] a这样的书写方式
通常情况下java的数组通过new出来： a1=new int[5]，表示a1是一个引用，指向一个int型数组
使用length

对象数组
对于对象数组，数组的成员实际上是句柄（对象的引用）
对象数组也可以定义初始化
Integer i;   i 为对对象的引用

● 隐藏实施过程——访问控制
面向对象程序设计的一个概念：隐藏尽可能多的东西
库创建者应声明哪些是客户程序员可以使用的，哪些是不可一使用的

● 包：库单元
用import来引入包或包里的成员。
import java.util.*;    java.util 表示包名  *号表示包里的所有类
import java.util.Vector;      类的全名
目的是在所有对象范围内唯一的标识一个类
之所以要这样的引入，是为了提供一种特殊的机制，来实现命名空间的管理

● 编译单元
每个编译单元必须是以.java结尾的文件名称，在一个编译单元里，可以有一个 public的类，这个类的名字必须与文件的名字相同。在一个单元内，可以有多个类，但只能有一个public的类。
编译一个.java文件时，对应于文件中的每一个类，会得到一个.class文件，文件名与类的名字相同。一个程序是一堆.class文件。

● 定义包
一个库是一堆这样的.class文件，它们被定义为一个包，但是并不真正地合并在一个文件中。
包没有什么管理机制，包只要声明就可以了
   package mypackage;
   public class MyClass;  //MyClass这个类就属于mypackage这个包
现在，如果客户程序员想要使用MyClass，就要用import来引入mypackage包，或者是使用MyClass的全名。
    import mypackage;    //引入mypackage包
    MyClass m = new MyClass(); mypackage.MyClass m = new mypackage.MyClass();
//使用MyClass的全名

rt.jar   java基础类库的所有包
使用jar命令来查看   |more

● CLASSPATH
-  .表示当前目录     d:";.  d盘根下是一个搜索的根
- CLASSPATH包含一个或多个目录，它们作为一种特殊的根使用，从这里展开对.class文件的搜索

● 类成员的访问属性
“Friendly” （缺省包）
public: 界面访问 (accessor/mutator)
private: 不能接触!
protected: "某种友好"  包内可以访问，子类也可以访问。子类和父类不在一个包的情况下。

● 类的访问控制
一个编译单元（文件）中只能有一个public的类。因此一个编译单元只有一个唯一的公共界面，其余的类都是"friendly"的。 public类的名字必须和文件的名字一样。
可以，尽管很少见，一个编译单元没有一个public类，所有的类都是"friendly"的，那么文件名可以任意起。

● 继承
class ThisClass extends SuperClass {
??? //??? class body
}
ThisClass是第三人称弹数，extend要加s---extends

● 传递构造参数
先初始化父类的部分，在初始化自己的
-缺省构造函数
-super(…)  调用父类的一个构造函数并且传递参数

● 初始化和类的装载
-先父类静态，后子类静态
-先父类定义初始化，父类构造函数
-后子类定义初始化，子类构造函数

● Upcasting
-子类和父类之间的关系是： The new class is a type of the existing class.
-Upcasting是安全的.

● Method call binding
-早绑定（静态绑定））  晚绑定（动态绑定）
-Java中所有的绑定都是晚绑定，除了final的方法
-早绑定有早绑定的优点，晚绑定有晚绑定的优点。但是，晚绑定带来了多态性。
-多态性就是把一个子类的对象当作父类的对象来看待，然后让它执行父类所能执行的函数。
静态绑定：若方法类型为priavte static final 编译器会准确知道该调用哪个方法
动态绑定：是很重要的特性,它能使程序变得可扩展而不需要重编译已存代码

● 多态性
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

● final
final : This cannot be changed
-final for data
-final for methods
-final for a class

● Final data
-只能被赋值一次的变量
-可以看作是常量
final Value v2 -- final的Value类的引用v2，final保护了对象的引用v2不被改变（这个引用的本身不能被改变）但是Value所指的对象是可以改变的

● Final Methods
-有两种final方法：
1.在方法上加上一把锁，防止继承者改变它的意义。
2.编译器把对该方法的调用变成inline（嵌入）调用。
-Private is Final，不存在override问题

● Final classes
-Final classes是不允许被继承的。为防止他人从你的类上派生新类，此类是不可扩展的。主要是安全上的作用。

● abstract类和abstract方法（抽象类和抽象方法）
可以定义某个类是抽象的（只制造概念）
-一个类的作用仅仅是表达接口，而不是具体的实现细节
-抽象的方法是不完全的，它只是一个声明，没有方法体
-包含一个抽象方法的类被称作抽象类
-不能制造抽象类的对象
-从抽象类继承的类必须override所有父类的抽象方法，否则子类本身成为一个抽象类
-可以声明一个抽象类但是里面没有一个抽象方法
关键字abstract定义抽象类
做这样类的目的是禁止产生这样类的对象

abstract类不能用new运算符创建对象，必须产生其子类，由子类创建对象。
对于abstract方法，只允许声明，而不允许实现
如果一个类是一个abstract类的子类，它必须具体实现父类的abstract方法
如果一个类中含有abstract方法，那么这个类必须用abstract来修饰（abstract也可以没有abstract方法）
一个abstract类只关心它的子类是否具有某种功能，而不关心功能的具体行为，功能的具体行为由子类负责实现

● Interface 
——totally abstract class（完全抽象的类）
-Interface在java中的地位和class一样  可以继承
-Interface没有body（也没有构造函数），只表达概念  
-在Interface中所有的方法都是public的，即使你没有声明它是public的。
-在Interface中所有的数据成员都是public static final的，即使你没有声名。但不能是blank final
使用implements，表示实现了什么功能
-Interface编译后也生成一个class文件。其实Interface也是class，只不过是一种完全抽象的类

● 实现interface
-实现interface的类，其interface中所有的方法必须被“实现”，否则这个类成为一个抽象类。
-所有实现interface中的方法必须被申明为public
-Interface可以从多个Interface得到继承，但是不能继承类。

-为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口
-接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号结尾
-一个类通过使用implements声明自己使用一个或多个接口，如使用多个接口，用逗号隔开接口名
- 要注意的是，接口中的方法被默认是public的，所以类在实现接口方法时，一定要用public来修饰。另外，如接口方法的返回类型不是void的，那 么在类中实现该接口方法时，方法体至少要有一个return语句；如果是void型，类体除了两个大括号外，也可以没有任何语句。
-Java为我们提供的接口都在相应的包中，通过引入包可以使用Java提供的接口，也可以自己定义接口，一个Java源文件就是由类和接口组成的。

● Inner class（内部类）
-In Java 1.1, it is possible to place a class definition within another class definition.
-所谓内部类就是定义在另外一个类内部的类（某个类的定义，在另一个类的内部）
 新的消息机制需要有一个类能够访问另外一个类的私有成员
 为了解决因为多类类同时继承一个很小的类时，所带来的命名问题。
-什么是使用一个类或访问一个类：用这个类去制造对象
-类里面除了有成员变量、成员函数，还有成员类，实际上内部类可以称之为成员类，成员类也具有成员函数和成员变量一样的属性。成员类可以访问私有变量，成员类里面的所有的成员函数可以访问内部类外面那个类的所有私有变量。
-内部类什么时候被初始化？编译时生成几个class文件？
 每个内部类生成一个class文件

1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据
2.对于同一个包中的其他类来说,内部类能够隐藏起来
3.匿名内部类可以很方便的定义回调
4.使用内部类可以非常方便的编写事件驱动程序

● Private inner class
Inner classes可以完全被封闭起来，不被外界所看到

● Why inner classes?
两个理由要在方法和scope中定义inner class:
-我们准备实现某种形式的interface，使自己能创建和返回一个句柄。
-要解决一个复杂的问题，并希望创建一个类，用来辅助自己的程序，同时不愿意把类的细节公开。

在函数里面定义的类都加一个数字（序号），从1开始
有变量有函数就是一个类，这个类没有名字，是匿名类，生成一个“父类名$序号”的class文件
子类送参数给父类的构造函数：在子类的构造函数里用super

如何让内部类访问外部类，被访问的
匿名类没有名字，也就没有构造函数，定义初始化块相当于匿名类的构造函数

● Outter class?
inner classer拥有访问外部类的所有成员的能力，这是使用inner类的主要理由

父类与子类函数与函数之间的关系，如果函数名相同，参数表相同，则构成override的关系。
私有的为静态绑定
inner class 与 inner class 之间不会构成override关系。

● Exception机制处理
但是如果你完全检查任何时刻的错误，你的代码就会变成无法阅读的梦魇。
所有的函数调用的返回值都要判断，但是可能发生由于嵌套过多而造成代码阅读和维护困难，所以java里使用了try...catch，每一个catch针对一种错误，将事务逻辑与错误处理分开
-使用异常机制，读、写和调试代码变得清晰。它把处理错误的代码和正常的代码分开。

● Throw an exception
-throw new NullPointerException();
-throw new NullPointerException("HERE!");
异常发生时，你不能解决问题，所以必须扔(throw)出一个异常。
1.一个异常对象建立起来了。
2.当前运行的路径被停止，异常对象被弹出(eject)。
3.异常处理机制接管，开始寻找一个合适的地方来继续执行。

● Catch an exception
Java的异常机制的好处就在于它使我们在一个地方将精力集中在要解决的问题上，而在另一个地方处理来自那部分代码的异常情况。
  try {      //   code that may make exception
  } catch ( Type1 id1) {
  } catch ( Type2 id2) {
  }
catch的匹配不是一种精确匹配，只要这个对象是那个类的对象就可以了
catch不管再多，只需满足一个就结束了。

● Catch all kind of exception
一个捕捉任何异常的捕捉器是一个捕捉基本类型异常的捕捉器。
catch ( Exception e) {
 System.out.println("caught an exception")
}
捕捉任何异常的catch

● Interface: Throwable
String getMessage();
String toString();
void printStackTrace();
void printStackTrace(PrintStream);

● Re-throwing
catch (Exception e) {
 throw e;
}
-关于fillInStackTrace()
-也可以抛出一个与接收到的异常不同的异常

● Announce for exception
通知客户程序员自己写的方法中可能抛出什么样的异常是一种文明的做法。
 void f() throws tooBig, tooSmall, oldStyle { // Body of f() }
如果你要从你的方法中抛出某种异常，你必须申明。
但是你可以撒谎申明你并不真正抛出的异常。

● Override of exception
当你override一个方法，你只能申明和抛出不比它的父类版本中申明的异常多的异常

● finally

      在你能耐下心来看完这篇帖子之前，我想要明确告诉你一个结论：Java 和 .Net 在异常处理的本质上是没有区别的。

一、Java 是如何处理异常的

      如果一个 Java 方法要抛出异常，那么需要在这个方法后面用 throws 关键字定义可以抛出的异常类型。倘若没有定义，就认为该方法不抛出任何异常。如果从方法的入口和出口的角度去考虑一下这个规范，我们知道参数可以认为是方 法的入口（当然某些情况下也可以是出口），而返回值则是方法的出口，这是在程序正常执行的情况下，数据从入口入，出口出。要是程序非正常执行，产生异常又 当如何? 被抛出的异常应该如何从方法中释放出来呢? Java 的这种语法规范就如同给异常开了一个后门，让异常可以堂而皇之“正确”地从方法里被抛出。

      这样的规范决定了 Java 语法必须强行对异常进行 try-catch。设想一下，对于以下的方法签名：

public void foo() throws BarException { ... }

暗含了两方面的意思：第一，该方法要抛出 BarException 类型的异常；第二，除了 BarException 外不能抛出其他的异常。而正是这第二点的缘故，我们要如何保证没有除 BarException 之外的任何异常被抛出呢? 很显然，就需要 try-catch 其他的异常。也就是说，一般情况下，方法不抛出哪些异常就要在方法内部 try-catch 这些异常。

      Java 这样的机制既有优点，也有缺点。先来说说优点：

• 很显然，这种规范是由 Java 编译器决定的。倘若 Java 程序的入口点 main() 方法没有任何异常抛出，就是说要在 main() 方法内部，即整个程序内部捕捉所有的异常，否则将无法通过编译。这样编译器保证了程序对每个异常都有相应的计划和处理，不会有未处理的异常被泄露到虚拟机 中，导致程序意外中断或退出，也就是增强了程序的健壮性。当然，Java 有 RuntimeException 的概念，这样的异常仍然可以随时被抛出到虚拟机中。
• 强行 try-catch 要求把异常作为程序设计的一部分看待。就如同方法的参数和返回值一样，在编写一个方法时，要结合上下文做出通盘的考虑和打算。虽然异常是所谓的“意外情况”，但是这些“例外”理应是被我们全部了解并处理的。
• 方便调试。异常理应在正确的位置被捕捉。当异常发生时，我们能更清楚的了解到其来源和相应处理程序的位置，而免去了在整个调用栈中摸索的麻烦。
• 在不借助任何文档的情况下，从方法签名就可以知晓应该对哪些异常进行处理。

      Java 异常处理机制的这些优点也直接导致了他的致命弱点：将程序变得异常繁复。往往一个简单的程序，功能代码寥寥几行，而异常处理部分却占用了程序的绝大部分篇 幅；同时导致缩进深度加深，既不利于书写，也不利于阅读。另外他的强行 try-catch 需要程序员有更高深的造诣，能够通盘考虑异常处理设计问题，这个在程序开始之初或者对于初学者是一个不小的门槛。这往往会阻碍其推广与发展，因为低水平初 学者的信心往往因此而受到打击。然而对于高手来说，编译器是否能帮助他们找到未被处理的异常只是一个方便与否的问题，只要在编写方法时注意了异常处理，即 便没有编译器的支持，情况也不会糟糕太多。反而倒是由于要遵循这样复杂的异常处理规范，以至于大多数人都可能为了图一时方便，对异常的基类型 Exception 或 Throwable 进行笼统地捕捉，这样做的危害就是那些你无法处理的异常被溺死在处理程序中，（按照异常处理原则，我们应该只捕捉那些可以被处理或恢复的异常，而把其他的 异常继续抛出。至于这样做的优势，以及不这样做所带来的问题，不是一两句能够说清楚，这里就不展开讨论了。）导致程序的不稳定和不确定。既没有发挥 Java 语法在这方面的优势，反而增加了忧患。

二、.Net 是如何处理异常的

      一句话概括 .Net 的异常处理方式就是随心所欲。没有人要求你一定要抛出异常，也更没有人要求你一定要捕捉异常。未被捕捉的异常会被以 Unhandled Exception 的形式抛出到虚拟机中。在此我就要先解决一下文章开头提到的问题，为什么说 Java 和 .Net 这两种异常处理机制在本质上是相同的。可以从两个方面来考虑：

1. 默认情况下。Java 在默认情况下 main() 方法是不抛出异常的，正如前面所说的，这要求所有的异常都必须在 main() 方法内部被捕捉；而 .Net 则没有这种约束，他的 Main() 以至于整个应用程序中的任何一个方法对异常都是完全开放的。这样来看，这两者刚好是对立互补的。
2. 非默认情况下。Java 可以通过在 main() 方法后面加 throws 关键字使得整个应用程序对异常开放；而 .Net 则可以通过给应用程序域（Application Domain）的 UnhandledException 事件添加委托达到捕捉所有异常的目的，很显然这又是对立互补的。

因此，就好像一个是“正反”，一个是“反正”，加在一起“正反反正”都是一样的，对于达到控制异常的目录来说，是没有区别的。

      很多 Java 爱好者都鄙视 .Net 的这种行为，一方面他令程序变得不够健壮，因为默认情况下没有强制的办法要求所有的异常都被处理，或被正确处理；另外，他为调试增加了困难，不借助文档或 代码你将无法了解到一个方法可能抛出什么异常，而当一个异常被抛出的时候，同时异常处理代码又写得不够完善，你将不得不仔细查看整个调用栈来确定异常出现 的位置，而对于这一点 Java 默认是强制的。

      但是 Anders 的想法总是有道理的。

1. .Net 代码写起来非常容易。这是对于初学者，或者那些只是想实现一些测试性小功能的人而言，你完全没有必要考虑太多异常处理的细节，你要的就是写代码，然后让他 跑起来。这样的简单性无疑是你希望看到的，这样的简单性无疑更有利于 .Net 在市场上的推广。由于他在这方面并没有什么理论上的漏洞，也就仍然适合构建庞大的项目，只是感觉没有那么舒服罢了。
2. 一定程度上增加了程序的安全性。难道不捕捉异常可以被成为是安全的吗?这个话也许要从另外一方面来想，前面说过，有些 Java 程序员（绝对不占少数）为了图省事，在强行捕捉异常的压迫下，选择捕捉异常的基类型，也就是捕捉所有的异常。这样当有你无法处理的异常出现时，他们就溺死 在了你的代码中，而外面的程序全然不知，还在以一种不确定的状态运行着，这就可能是危险的开始。而如果是 .Net，那么 Unhandled Exception 会被虚拟机捕获，导致程序异常退出，虽然这从面子上对于用户不是一个好的交代，但是深层次地他避免了程序在危险的状态下继续运行。

      总之，萝卜白菜各有所爱。我的这篇帖子力求公正地讨论了这个问题，希望能对你有所帮助。

对于对Myeclipse不熟悉却还要用它来开发spring的初学者来说，是比较有困难的，因为我就是这样过来的。所以，我做了个flash演示项目的 步骤，但是太大了，上传不了。对于我这个刚注册blogjava的新手来说，有些功能还不太清楚。现在我先把步骤写下来，等以后我有时间把 blogjava弄明白了，看能不能再把那个flash上传上来。

步骤：

第一步：建工程
   File -> New -> Project ->Web Project,"Project Name":MySpringTest,然后"Finish";

第二步：导入spring包
   选中MySpringTest,右击,MyEclipse -> Add Spring Capabilities……,都默认即可；

第三步：
   建立项目所需类；MySpringTest -> src -> New ...（以下三个都这样建）

Spring 的开发没法自动生成 Bean， 这里大家只好手工来写了， 也很简单。

1、接口Action:（MySpringTest -> src -> New -> interface ,取名为Action）

2、实现接口Action的类UpperAction:（将其 message 属性与输入字符串相连接，并返回其大写形式。）

3、实现接口Action的类LowerAction: