第一篇：Java設計模式學習心得

Java設計模式學習心得

閱讀次數: 1584次 發布時間: 2010-04-10 14:52:13發布人: 網絡轉載

來源: 網絡轉載

整個設計模式貫穿一個原理:面對介面編程，而不是面對實現，（面向物件編程應該改爲面向介面編程）。目標原則是:降低耦合，增強靈活性。

一、創建模式

1.設計模式之Factory(工廠方法和抽象工廠)

使用工廠模式就象使用new一樣頻繁.2.設計模式之Prototype(原型)

用原型實例指定創建物件的種類，並且通過拷貝這些原型創建新的物件。

3.設計模式之Builder

汽車由車輪 方向盤 發動機很多部件組成，同時，將這些部件組裝成汽車也是一件複雜的工作，Builder模式就是將這兩種情況分開進行。

4.設計模式之Singleton(單態)

保證一個類只有一個實例,並提供一個訪問它的全局訪問點

二、結構模式

1.設計模式之Facade

可擴展的使用JDBC針對不同的資料庫編程,Facade提供了一種靈活的實現。

2.設計模式之Proxy

以Jive爲例,剖析代理模式在用戶級別授權機制上的應用

3.設計模式之Adapter

使用類再生的兩個方式:組合(new)和繼承(extends),這個已經在“thinking in java”中提到過。

4.設計模式之Composite

就是將類用樹形結構組合成一個單位。你向別人介紹你是某單位，你是單位元元中的一個元素，別人和你做買賣，相當於和單位做買賣。文章中還對Jive再進行了剖析。

5.設計模式之Decorator

Decorator是個油漆工,給你的東東的外表刷上美麗的顔色。

6.設計模式之Bridge

將“牛郎織女”分開(本應在一起,分開他們,形成兩個介面),在他們之間搭建一個橋(動態的結合)

7.設計模式之Flyweight

提供Java運行性能,降低小而大量重復的類的開銷。

三、行爲模式

1.設計模式之Template

實際上向你介紹了爲什麼要使用Java 抽象類,該模式原理簡單,使用很普遍。

2.設計模式之Memento

很簡單一個模式,就是在記憶體中保留原來資料的拷貝。

3.設計模式之Observer

介紹如何使用Java API提供的現成Observer

4.設計模式之Chain of Responsibility

各司其職的類串成一串,好象擊鼓傳花,當然如果自己能完成,就不要推委給下一個。

5.設計模式之Command

什麼是將行爲封裝,Command是最好的說明。

6.設計模式之State

狀態是編程中經常碰到的實例,將狀態物件化,設立狀態變換器,便可在狀態中輕鬆切換。

7.設計模式之Strategy

不同演算法各自封裝,用戶端可隨意挑選需要的演算法。

8.設計模式之Mediator

Mediator很象十字路口的紅綠燈,每個車輛只需和紅綠燈交互就可以。

9.設計模式之Interpreter

主要用來對語言的分析,應用機會不多。

10.設計模式之Visitor

訪問者在進行訪問時,完成一系列實質性操作,而且還可以擴展。

11.設計模式之Iterator

這個模式已經被用來遍曆Collection中物件。使用頻率很高。在Java中無需專門闡述,在大多數場合也無需自己制造一個Iterator,只要將物件裝入Collection中，我們就直接可以使用Iterator模式。

第二篇：java設計模式考試題

一選擇題：共10分

1.Open-Close原則的含義是一個軟件實體(a)

A.應當對擴展開放，對修改關閉

2.是10道選擇題第一題考完了

二 簡答題 共10分

1.什么是設計模式？

設計模式是從許多優秀軟件系統中總結出的成功的可復用的設計方案。

2.設計模式的四個基本要素是什么，以及他們是什么含義？

名稱：

問題：

方案：

效果：含義在書上p1

三 畫類圖

14畫出命令模式的類圖，并寫出關鍵的代碼？

見書上17頁

15.畫出迭代器模式的類圖，并寫出關鍵的代碼？、見書上105頁

四寫代碼學一個關于求職中心，通知求職者的問題

這是一個觀察者模式，具體看看書

我的書是第五章的書上例題

2.是一個交通工具營銷問題；

應該是外觀模式；見書上99頁，應該就是個

這是我們學校的考試題，2012年

第三篇：JAVA設計模式之創建模式

設計模式之Builder

Builder模式定義: 將一個復雜對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的表示.Builder模式是一步一步創建一個復雜的對象,它允許用戶可以只通過指定復雜對象的類型和內容就可以構建它們.用戶不知道內部的具體構建細節.Builder模式是非常類似抽象工廠模式,細微的區別大概只有在反復使用中才能體會到.為何使用?

是為了將構建復雜對象的過程和它的部件解耦.注意: 是解耦過程和部件.因為一個復雜的對象,不但有很多大量組成部分,如汽車,有很多部件:車輪 方向盤 發動機還有各種小零件等等,部件很多,但遠不止這些,如何將這些部件裝配成一輛汽車,這個裝配過程也很復雜(需要很好的組裝技術),Builder模式就是為了將部件和組裝過程分開.如何使用?

首先假設一個復雜對象是由多個部件組成的,Builder模式是把復雜對象的創建和部件的創建分別開來,分別用Builder類和Director類來表示.首先,需要一個接口,它定義如何創建復雜對象的各個部件: public interface Builder {

//創建部件A 比如創建汽車車輪

void buildPartA();

//創建部件B 比如創建汽車方向盤

void buildPartB();

//創建部件C 比如創建汽車發動機

void buildPartC();

//返回最后組裝成品結果(返回最后裝配好的汽車)

//成品的組裝過程不在這里進行,而是轉移到下面的Director類中進行.//從而實現了解耦過程和部件

Product getResult();} 用Director構建最后的復雜對象,而在上面Builder接口中封裝的是如何創建一個個部件(復雜對象是由這些部件組成的),也就是說Director的內容是如何將部件最后組裝成成品: public class Director {

private Builder builder;

public Director(Builder builder){

this.builder = builder;} // 將部件partA partB partC最后組成復雜對象 //這里是將車輪 方向盤和發動機組裝成汽車的過程 public void construct(){

builder.buildPartA();

builder.buildPartB();

builder.buildPartC();

} } Builder的具體實現ConcreteBuilder: 通過具體完成接口Builder來構建或裝配產品的部件;定義并明確它所要創建的是什么具體東西;提供一個可以重新獲取產品的接口: public class ConcreteBuilder implements Builder {

Part partA, partB, partC;public void buildPartA(){

//這里是具體如何構建partA的代碼

};public void buildPartB(){

//這里是具體如何構建partB的代碼 };public void buildPartC(){

//這里是具體如何構建partB的代碼 };public Product getResult(){

//返回最后組裝成品結果 };} 復雜對象:產品Product: public interface Product { } 復雜對象的部件: public interface Part { }

我們看看如何調用Builder模式: ConcreteBuilder builder = new ConcreteBuilder();Director director = new Director(builder);

director.construct();Product product = builder.getResult();Builder模式的應用

在Java實際使用中,我們經常用到“池”(Pool)的概念,當資源提供者無法提供足夠的資源,并且這些資源需要被很多用戶反復共享時,就需要使用池.“池”實際是一段內存,當池中有一些復雜的資源的“斷肢”(比如數據庫的連接池,也許有時一個連接會中斷),如果循環再利用這些“斷肢”,將提高內存使用效率,提高池的性能.修改Builder模式中Director類使之能診斷“斷肢”斷在哪個部件上,再修復這個部件.設計模式之Factory

定義:提供創建對象的接口.為何使用?

工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。

為什么工廠模式是如此常用？因為工廠模式就相當于創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A()工廠模式也是用來創建實例對象的，所以以后new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。我們以類Sample為例，如果我們要創建Sample的實例對象: Sample sample=new Sample();可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢數據庫等。

首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成: Sample sample=new Sample(參數);但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。為什么說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當于將很多雞蛋放在一個籃子里，是很危險的，這也是有背于Java面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派“切割”成每段，將每段再“封裝”起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以后如果需要修改，只要更改每段，不會再發生牽一動百的事情。

在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。

這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向接口編程,我們需要將Sample抽象成一個接口.現在Sample是接口,有兩個子類MySample 和HisSample.我們要實例化他們時,如下: Sample mysample=new MySample();Sample hissample=new HisSample();隨著項目的深入,Sample可能還會“生出很多兒子出來”, 那么我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入后來生出兒子的實例.這在傳統程序中是無法避免的.但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.工廠方法

你會建立一個專門生產Sample實例的工廠: public class Factory{

public static Sample creator(int which){

//getClass 產生Sample 一般可使用動態類裝載裝入類。if(which==1)

return new SampleA();else if(which==2)

return new SampleB();

} } 那么在你的程序中,如果要實例化Sample時.就使用 Sample sampleA=Factory.creator(1);這樣,在整個就不涉及到Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.使用工廠方法 要注意幾個角色，首先你要定義產品接口，如上面的Sample,產品接口下有Sample接口的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：

進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。抽象工廠

工廠模式中有: 工廠方法(Factory Method)抽象工廠(Abstract Factory).這兩個模式區別在于需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品接口Sample2.這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2 那么，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠: public abstract class Factory{

public abstract Sample creator();

public abstract Sample2 creator(String name);} public class SimpleFactory extends Factory{

public Sample creator(){

.........return new SampleA } public Sample2 creator(String name){

.........return new Sample2A } } public class BombFactory extends Factory{

public Sample creator(){

......return new SampleB } public Sample2 creator(String name){

......return new Sample2B } }

從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什么我不可以使用兩個工廠方法來分別生產Sample和Sample2? 抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特征，也許制造過程是統一的，比如：制造工藝比較簡單，所以名稱叫SimpleFactory。在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用，舉例

我們以Jive的ForumFactory為例，這個例子在前面的Singleton模式中我們討論過，現在再討論其工廠模式: public abstract class ForumFactory {

private static Object initLock = new Object();

private static String className = “com.jivesoftware.forum.database.DbForumFactory”;

private static ForumFactory factory = null;

public static ForumFactory getInstance(Authorization authorization){

//If no valid authorization passed in, return null.if(authorization == null){

return null;

}

//以下使用了Singleton 單態模式

if(factory == null){

synchronized(initLock){

if(factory == null){

......}

}

} try {

//動態轉載類

Class c = Class.forName(className);

factory =(ForumFactory)c.newInstance();} catch(Exception e){

return null;}

//Now, 返回 proxy.用來限制授權對forum的訪問

return new ForumFactoryProxy(authorization, factory，factory.getPermissions(authorization));

}

//真正創建forum的方法由繼承forumfactory的子類去完成.public abstract Forum createForum(String name, String description)

throws UnauthorizedException, ForumAlreadyExistsException;

....}

因為現在的Jive是通過數據庫系統存放論壇帖子等內容數據,如果希望更改為通過文件系統實現,這個工廠方法ForumFactory就提供了提供動態接口: private static String className = “com.jivesoftware.forum.database.DbForumFactory”;你可以使用自己開發的創建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.在上面的一段代碼中一共用了三種模式,除了工廠模式外,還有Singleton單態模式,以及proxy模式,proxy模式主要用來授權用戶對forum的訪問,因為訪問forum有兩種人:一個是注冊用戶 一個是游客guest,那么那么相應的權限就不一樣,而且這個權限是貫穿整個系統的,因此建立一個proxy,類似網關的概念,可以很好的達到這個效果.看看Java寵物店中的CatalogDAOFactory: public class CatalogDAOFactory {

/**

* 本方法制定一個特別的子類來實現DAO模式。

* 具體子類定義是在J2EE的部署描述器中。

*/

public static CatalogDAO getDAO()throws CatalogDAOSysException {

CatalogDAO catDao = null;

try {

InitialContext ic = new InitialContext();//動態裝入CATALOG_DAO_CLASS //可以定義自己的CATALOG_DAO_CLASS，從而在無需變更太多代碼 //的前提下，完成系統的巨大變更。

String className =(String)ic.lookup(JNDINames.CATALOG_DAO_CLASS);

catDao =(CatalogDAO)Class.forName(className).newInstance();

} catch(NamingException ne){

throw new CatalogDAOSysException(“

CatalogDAOFactory.getDAO: NamingException while

getting DAO type : n” + ne.getMessage());

} catch(Exception se){

throw new CatalogDAOSysException(“

CatalogDAOFactory.getDAO: Exception while getting

DAO type : n” + se.getMessage());

}

return catDao;

} } CatalogDAOFactory是典型的工廠方法，catDao是通過動態類裝入器className獲得CatalogDAOFactory具體實現子類，這個實現子類在Java寵物店是用來操作catalog數據庫，用戶可以根據數據庫的類型不同，定制自己的具體實現子類，將自己的子類名給與CATALOG_DAO_CLASS變量就可以。

由此可見，工廠方法確實為系統結構提供了非常靈活強大的動態擴展機制，只要我們更換一下具體的工廠方法，系統其他地方無需一點變換，就有可能將系統功能進行改頭換面的變化。

設計模式之Prototype(原型)

定義: 用原型實例指定創建對象的種類,并且通過拷貝這些原型創建新的對象.Prototype模式允許一個對象再創建另外一個可定制的對象，根本無需知道任何如何創建的細節,工作原理是:通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。如何使用? 因為Java中的提供clone()方法來實現對象的克隆(具體了解clone()按這里),所以Prototype模式實現一下子變得很簡單.以勺子為例：

public abstract class AbstractSpoon implements Cloneable {

String spoonName;

public void setSpoonName(String spoonName){this.spoonName = spoonName;}

public String getSpoonName(){return this.spoonName;}

public Object clone()

{

Object object = null;

try {

object = super.clone();

} catch(CloneNotSupportedException exception){

System.err.println(“AbstractSpoon is not Cloneable”);

}

return object;

} } 有兩個具體實現(ConcretePrototype): public class SoupSpoon extends AbstractSpoon {

public SoupSpoon()

{

setSpoonName(“Soup Spoon”);

} } public class SaladSpoon extends AbstractSpoon {

public SaladSpoon()

{

setSpoonName(“Salad Spoon”);

} } 調用Prototype模式很簡單: AbstractSpoon spoon = new SoupSpoon();AbstractSpoon spoon = new SaladSpoon();當然也可以結合工廠模式來創建AbstractSpoon實例。

在Java中Prototype模式變成clone()方法的使用，由于Java的純潔的面向對象特性，使得在Java中使用設計模式變得很自然，兩者已經幾乎是渾然一體了。這反映在很多模式上，如Interator遍歷模式。

設計模式之Singleton(單態)

定義: Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄 數據庫連接都需要這樣的單線程操作。

還有, singleton能夠被狀態化;這樣，多個單態類在一起就可以作為一個狀態倉庫一樣向外提供服務，比如，你要論壇中的帖子計數器，每次瀏覽一次需要計數，單態類能否保持住這個計數，并且能synchronize的安全自動加1，如果你要把這個數字永久保存到數據庫，你可以在不修改單態接口的情況下方便的做到。

另外方面，Singleton也能夠被無狀態化。提供工具性質的功能，Singleton模式就為我們提供了這樣實現的可能。使用Singleton的好處還在于可以節省內存，因為它限制了實例的個數，有利于Java垃圾回收（garbage collection）。

我們常常看到工廠模式中類裝入器(class loader)中也用Singleton模式實現的,因為被裝入的類實際也屬于資源。如何使用?

一般Singleton模式通常有幾種形式: public class Singleton {

private Singleton(){}

//在自己內部定義自己一個實例，是不是很奇怪？

//注意這是private 只供內部調用

private static Singleton instance = new Singleton();

}

第二種形式: public class Singleton {

private static Singleton instance = null;public static synchronized Singleton getInstance(){

//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次

//使用時生成實例，提高了效率！if(instance==null)

instance＝new Singleton();return instance;} //這里提供了一個供外部訪問本class的靜態方法，可以直接訪問

public static Singleton getInstance(){

return instance;

} }

使用Singleton.getInstance()可以訪問單態類。

上面第二中形式是lazy initialization，也就是說第一次調用時初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，這個synchronized很重要，如果沒有synchronized，那么使用getInstance()是有可能得到多個Singleton實例。關于lazy initialization的Singleton有很多涉及double-checked locking(DCL)的討論，有興趣者進一步研究。

一般認為第一種形式要更加安全些。使用Singleton注意事項：

有時在某些情況下，使用Singleton并不能達到Singleton的目的，如有多個Singleton對象同時被不同的類裝入器裝載；在EJB這樣的分布式系統中使用也要注意這種情況，因為EJB是跨服務器，跨JVM的。

我們以SUN公司的寵物店源碼(Pet Store 1.3.1)的ServiceLocator為例稍微分析一下：

在Pet Store中ServiceLocator有兩種，一個是EJB目錄下；一個是WEB目錄下，我們檢查這兩個ServiceLocator會發現內容差不多，都是提供EJB的查詢定位服務，可是為什么要分開呢？仔細研究對這兩種ServiceLocator才發現區別：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator屬于資源定位，理所當然應該使用Singleton模式。但是在EJB中，Singleton模式已經失去作用，所以ServiceLocator才分成兩種，一種面向WEB服務的，一種是面向EJB服務的。

Singleton模式看起來簡單，使用方法也很方便，但是真正用好，是非常不容易，需要對Java的類 線程 內存等概念有相當的了解。進一步深入可參考：

Double-checked locking and the Singleton pattern When is a singleton not a singleton?

第四篇：JAVA學習書籍- 設計模式

談到設計模式很多人多會推薦GOF 的那本，該書在Amzon上是五星級的推薦書籍。不過對于學習java 沒多久的、特別是java 初學者，我很不推薦這本書。主要是該書的例子基本都是C++的，很多細節沒有講述得足夠清楚。

我給大家推薦的第一本是閻宏博士的《Java 與模式》，它是第一本中國人自己寫的關于設計模式的書籍，寫的比較有趣，融合了很多中

華民族的文化和觀念，例子、類圖都比較多，且相對簡單！非常不錯的入門書籍――又是大塊頭哦！

其次我推薦Wiley 出版社出版的《Pattern In Java》一套三本，我才看了第一本，好像第二本不怎么樣，第三本還不錯！

第三本是中文翻譯版的關于多線程模式的（很難得的中文翻譯版）中國鐵道出版社2003 年出版的《Java 多線程設計模式》，將多線程模

式講得非常淺顯，配有大量的圖例，每章都有習題，最后有答案！我研究多線程模式就是由它開始的！

第四本，今年出版的Head First 系列的《Head First Design Pattern》，秉承Head First 系列圖書的優點，大量的類圖、豐富的實例、有趣的注解，值得購買！

其次在J2EE 方向你可以研究閱讀Addison Wesley 2002 年出版的《Patterns of Enterprise Application Architecture》，眾多大腕的作品，講企業消息集成的！Sun 提供的《J2EE PATTERNS SL500》也很好！晚了推薦那一本Amzon 4 星半的《Holub on patterns》，大師的作品，提供了，很值得研究的例子，不過對上面四本不是很熟悉的讀者，最好不要讀它！可能會讓你比較累！

我學習設計模式經過一段很曲折的路線，前前后后大約看了20 本，閻宏博士的《Java 與模式》我看了4 遍，還排除我第一次基本沒看

懂的看！記得研一時老師給我們講了GOF 的那本，作為選修課，我和它們計算機系的碩士、博士們一起，到最后一個班40－50 個人，不

超過3 個人明白，我也沒有明白任何一點（基礎差吧――主要我對C++語言一點都不了解），憑我不伏輸的性格，我認為我對java 語言理

解還可以，我就借了《Java 與模式》，結果還是基本沒看懂。很有幸的是讀研三時，聽過了上交大饒若楠老師關于Java OOP 語言的講座，我懂了組合書籍模式等三種設計模式后，對其它模式有了強烈的興趣和要征服它的愿望！工作后我買的第一本就是《Java 與模式》，第一遍花了2 個月研究了這個1000 多頁的大塊頭，后來第三遍15 天左右就可以搞定，筆記記了一大本！從此一發不可收拾。

選對書、埋頭研究。相信很快就會入門的！

學習Java 語言8 個簡單的部分，這只是我們研究Java 語言的開始！這些都懂了充其量一個java 程序員而已，后面的路很長很長！我們

可以繼續研究數據庫實現的源代碼、Servlet 服務器的源代碼、RMI、EJB、JNDI、面向方面編程、重構、ANT 工具、Eclipse 工具、Spring

工具、JBoss、JOnAS、Apache Geronimo 等J2EE 服務器！研究了這些你可能會成為一個出色的J2EE Architecture！你可以繼續研究剖

析器、編譯器、JNODE（java 寫的操作系統）

第五篇：java學習心得

Java學習心得

專業：信息與計算科學班級：

姓名：學號：

日期：

河北建筑工程學院數理系

java語言產生于C＋＋語言之后，是完全的面向對象的編程語言，充分吸取了C＋＋語言的優點，采用了程序員所熟悉的C和C＋＋語言的許多語法，同時又去掉了C語言中指針、內存申請和釋放等影響程序健壯性的部分，可以說java語言是站在C＋＋語言這個“巨人的肩膀上”前進的。

java采用的是相對簡單的面向對象技術，去掉了運算符重載、多繼承的復雜概念，而采用了單一繼承、類強制轉換、多線程、引用（非指針）等方式。

在java程序中不能采用地址計算的方法通過指針訪問內存單元，大大減少了錯誤發生的可能性；而且java的數組并非用指針實現，這樣就可以在檢查中避免數組越界的發生。

Java語言學習要點

一、掌握靜態方法和屬性

靜態方法和屬性用于描述某一類對象群體的特征，而不是單個對象的特征。Java中大量應用了靜態方法和屬性，這是一個通常的技巧。但是這種技巧在很多語言中不被頻繁地使用。理解靜態方法和屬性對于理解類與對象的關系是十分有幫助的，在大量的Java規范中，靜態方法和屬性被頻繁使用。因此學習者應該理解靜態方法和屬性。Java在方法和屬性的調用上是一致的，區別只表現在聲明的時候，這和c++是不同的。

二、重視接口

在面向對象早期的應用中大量使用了類繼承。隨著軟件工程理論的不斷發展，人們開始意識到了繼承的眾多缺點，開始努力用聚合代替繼承。軟件工程解決擴展性的重要原則就是抽象描述，直接使用的工具就是接口。接口近年來逐漸成為Java編程方法的核心。另一方面，就應用而言，大部分開發是建立在規范基礎之上的，不需要自己建立復雜的繼承關系和龐大的類。因此讀懂規范和用好規范已經成為應用程序開發人員的首要任務，Java各項規范的主要描述手段就是接口。

三、學好集合框架

Java描述復雜數據結構的主要方式是集合框架。Java沒有指針，而是通過強大的集合框架描述數組、對象數組等復雜的數據結構。學好這些數據結構的描述方法對于應用程序編寫，特別是涉及到服務器方、3層結構編程至關重要。程序員在這個時候不能再用諸如數據庫結果集之類的結構描述數據了。

四、例外捕捉

Java對例外捕捉的強調是空前的，它強迫程序員用顯著的與邏輯方法完全不同的方式描述例外捕捉，對于程序描述的完整性和嚴謹性有很大的意義。

總之學編程語言不僅僅是從理論上的學習，更重要的是要利用這門語言為你的思想服務。理解這門語言是首要的，但是要達到心領神會、融會貫通就必須勤動手，多去時間，多編一些例子。計算機科學是注重實踐的學科，成功的軟件開發人員無不經過大量的上機鍛煉，只有理論和實踐相結合才能真正掌握只是和技能。