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: