第一篇：達(dá)內(nèi)學(xué)習(xí)心得：精心總結(jié)的面向?qū)ο?/a>

第二篇：達(dá)內(nèi)學(xué)習(xí)心得：精心總結(jié)的面向?qū)ο?/a>

達(dá)內(nèi)學(xué)習(xí)心得：精心總結(jié)的面向?qū)ο?/p>

參賽學(xué)員：方錢有 獲獎(jiǎng)獎(jiǎng)項(xiàng)：二等獎(jiǎng) 什么面向?qū)ο? 個(gè)人分析覺得：在程序設(shè)計(jì)里,面向?qū)ο笫且环N相對(duì)說法，相對(duì)于面向過程而言的； 面向“對(duì)象“：即重點(diǎn)在于“對(duì)象”；而面向過程：則重點(diǎn)在于“過程”，簡單說：就是我我們看待事物在眼光上注重點(diǎn)不一樣；比如說：我們?cè)u(píng)判一個(gè)女孩漂亮與否，有的人看重外表，有的人則看重“心靈”，只是側(cè)重點(diǎn)不一樣。舉個(gè)例子：把大象裝進(jìn)冰箱！

面向過程

面向?qū)ο?/p>

（注重一系列動(dòng)作即過程）

（注重動(dòng)作所操作的承受者［“對(duì)象”］）

“打開”冰箱

“冰箱”打開

“裝入”大象

“大象”裝入

“關(guān)閉”冰箱

“冰箱”關(guān)閉

類：通俗的說類就是“一類事物的簡稱”，并且這些事物至少具有一點(diǎn)“共同的”特征.比如說：動(dòng)物就是一個(gè)類

對(duì)象：就是某一類中一個(gè)具體的（就是可以具體描述出來的）東西，比如：動(dòng)物(類)里的“狗”就是一個(gè)對(duì)象。(個(gè)人覺得對(duì)象相對(duì)于類而言的,因?yàn)楣酚挚梢苑趾枚喾N，‘狗’相對(duì)于‘哈士奇’是一個(gè)類,‘哈士奇’是‘狗’類的一個(gè)具體對(duì)象)

在生活中就拿描述汽車來說，我們都知道汽車都有4個(gè)輪子； 都有跑的功能 可以如下描述:

類

汽車

屬性： 4個(gè)輪

功能： 跑

那么怎么在Java中描述汽車這類呢？ class car{

int wheel=4;//屬性： 4個(gè)輪

void run(){//方法(功能)： 跑

System.out.println(“是汽車都會(huì)跑”);

} } 那么可見“出租車”應(yīng)當(dāng)是“汽車”這類的一個(gè)具體化（實(shí)實(shí)在在的例子即“實(shí)例”）對(duì)象，那自然出租車也就具備了汽車這類所具備的“共有”屬性功能！

如何創(chuàng)建一個(gè)出租車對(duì)象呢？java中通過new關(guān)鍵字來創(chuàng)建一個(gè)類的實(shí)例即對(duì)象，也叫類的實(shí)例化，就是把類具體化成一個(gè)實(shí)例嘛！格式：類名

對(duì)象名 = mew 類名

()

Car

texi =

new Car();創(chuàng)建了“出租車”對(duì)象（實(shí)例）之后那么它也就有了如下“自己”的屬性和功能。

int wheel=4;//屬性： 4個(gè)輪

void run(){//功能： 跑

System.out.println(“我是出租車我也會(huì)跑”);

} 我們?nèi)绾蝸碓L問對(duì)象中的它自己的屬性和方法呢？ 格式：對(duì)象.屬性；

對(duì)象.方法名();

這一點(diǎn)也驗(yàn)證了面向?qū)ο缶幊痰膫?cè)重點(diǎn)在于“對(duì)象”上；

texi.wheel;

texi.run()*********************************************************************************************************************************************************************************************************************************************

1.封裝：

從字面可以解讀為將東西封起來再裝好。要想拿到里面的東西就得有相應(yīng)的方法打開，才能拿到。

舉例來說：一個(gè)房間的門如果沒有上鎖，那么大家都可以進(jìn)去拿東西，但現(xiàn)在我們不想讓誰都進(jìn)來拿東西，我們可以將房門上鎖，只對(duì)外提供一把鑰匙，只有有鑰匙的人才能進(jìn)來，這就是“封裝”現(xiàn)象！

在java程序中，“封裝”現(xiàn)象如何實(shí)現(xiàn)呢？

可以這樣實(shí)現(xiàn)：將類中的一些屬性和方法用private關(guān)鍵字修飾，將他們“私有化（即不對(duì)外直接公開）”,使外部其他類不能通過創(chuàng)建該類對(duì)象或通過類名直接訪問這些屬性和方法;只對(duì)外提供公有的方法，外部其他類必須通過該類對(duì)外提供的公有方法來訪問該類的相應(yīng)成員；例如： class Person{

private String name;//將name屬性私有化（封裝）［相當(dāng)于了上鎖］使外部其他類不能直接訪問到

public SetName(String name){//對(duì)外提供公有方法（相當(dāng)于房門鑰匙）供外部其他類訪問到本類屬性

this.name=name;

} }

2.繼承：

從字面來說繼承就是子父類關(guān)系的簡稱，就是兒子（女兒也行，好吧）會(huì)繼承老爸的一些屬性和行為

在java中如何描述繼承關(guān)系呢？

注意：

第一得知道在java中繼承是類與類之間或者是接口與接口之間才有繼承關(guān)系；通過extends關(guān)鍵字來描述繼承關(guān)系 例如：老爸這個(gè)類 class Dad{

String sex=man;

void smoke(){

System.out.println(“老子會(huì)抽煙！”);

} } 那么我們?cè)趺磥碜寖鹤舆@個(gè)類繼承老爸這個(gè)類呢？

class Son extends Dad{//通過extends關(guān)鍵字兒子這個(gè)類就繼承老爸這個(gè)類了

String name;//定義自己的屬性

String sex=man;//繼承過來的屬性，無須再定義，這里寫出來是為了好理解

void smoke(){//繼承過來的方法，無須再定義，這里寫出來是為了好理解

System.out.println(“老子會(huì)抽煙！”);

}

void playBall(){//定義自己的方法

System.out.println(“兒子即會(huì)打球又會(huì)抽煙！”);

}

void somke(){//重寫的方法

System.out.println(“我不抽20塊以下的煙”);

}

void smoke(int n){//重載的方法

System.out.println(“我抽了+n+”年的煙了“);

} } 那么具有繼承關(guān)系的兩個(gè)類有什么特點(diǎn)呢？

1）子類會(huì)將父類的屬性和方法繼承過來，當(dāng)然子類也可以自己定義的屬性和方法 2）當(dāng)子類自己定義的方法和父類繼承過來的方法相同時(shí)會(huì)發(fā)生“重寫“現(xiàn)象！3）父類用private關(guān)鍵字私有的方法是不能被繼承的！4）子類可以使用super訪問父類的屬性和方法 5）子類通過重寫父類方法，修改父類的功能 6）子類構(gòu)造器一定調(diào)用父類的無參構(gòu)造器 7）構(gòu)造器不能繼承

3.多態(tài)：

字面意思就是多種形態(tài),也就是說一種事物同時(shí)局部多種形態(tài).注意：要出現(xiàn)多態(tài)情況，那么類和類之間一定得是繼承關(guān)系，或者類和接口是實(shí)現(xiàn)關(guān)系 我覺得：在java中多態(tài)是相對(duì)于一個(gè)對(duì)象而言的，就是父類型引用變量引用子類對(duì)象，并且父類型引用變量可以接受不同子類的對(duì)象 例如：拿上面的舉例

Dad uncle=new Son();父類引用變量uncle即具備Son類的成員又具備父類的成員；這也稱為“向上造型”； 多態(tài)時(shí)的特點(diǎn)

1）多態(tài)時(shí)訪問成員變量，如uncle.name;編譯時(shí)看等號(hào)左邊，父類有該成員變量則編譯通過，否則編譯出錯(cuò)！運(yùn)行時(shí)也看等號(hào)左邊，有則運(yùn)行結(jié)果 2）多態(tài)時(shí)訪問方法,如uncle.smoke()編譯時(shí)看等號(hào)左邊，父類有該成員方法則編譯通過，否則編譯出錯(cuò)！運(yùn)行時(shí)看等號(hào)右邊，父類有該方法，子類沒有該方法執(zhí)行父類方法；父類有該方法，子類也有該方法執(zhí)行子類方法 3）多態(tài)時(shí)訪問靜態(tài)方法 編譯運(yùn)行都看等號(hào)左邊

******************************************************************************************************************************************************************************************************************************************************************

4.抽象(有爭(zhēng)議)：

什么是抽象？

抽象就是不具體。

一般我們把不能具體描述的東西約定俗成為“抽象”的東西。例如：我們說一個(gè)人長得很“抽象”,n你想你能具體形容描述出來么？ 在JAVA中如何描述抽象這個(gè)概念呢？

我覺得在java中抽象類是由抽象方法而衍生出來的，為什么呢？

因?yàn)镴ava規(guī)定一個(gè)類中定義了抽象方法那這個(gè)類就跟著必須定義為抽象類，而不是因?yàn)橄榷x抽象類再跟著規(guī)定抽象類中的方法必須是抽象的，可能最后理解的結(jié)果是一樣的但性質(zhì)是不一樣的（個(gè)人理解）簡單說：就是有抽象方法的類一定是抽象類，但是抽象類中不一定都是抽象方法，也可以有具體方法。首先就是當(dāng)我要在一個(gè)類定義一個(gè)方法時(shí)，暫時(shí)我不知道該方法具體功能是什么；等我想好了我在用他實(shí)現(xiàn)一個(gè)功能時(shí)我再具體描述他功能，這樣我們就可以將這個(gè)方法用abstract關(guān)鍵字修飾定義為抽象方法

（還有一點(diǎn)也就是什么時(shí)候定義抽象類的？也可以說抽象類是向上抽取而來的，就是幾個(gè)類據(jù)有共同的屬性和方法，不想每個(gè)類都定義一次，那么定義一個(gè)公有類（即抽象類）其他類只要繼承抽象類再重寫方法就行！）

例如：我有一百塊錢，現(xiàn)在我不知道怎么用，等我想好了在具體怎么用！abstract class Money{//因?yàn)橛辛顺橄蠓椒ㄋ员仨毝x為抽象類

public abstract void buySomthing();//現(xiàn)在不知道怎么用，那就把它的功能代碼體去掉 } //現(xiàn)在我餓了，想買東西吃了，我就知道怎么用了 class Hungry extends Money{

void buySomething(){

System.out.println(”我餓了，現(xiàn)在我要買東西吃！“)

} } 抽象類的特點(diǎn)

1）抽象類不能實(shí)例化 2）抽象類可以繼承抽象類

3）繼承抽象類必須得重寫抽象方法

5.抽象類，接口，普通類 的不同點(diǎn)和相同點(diǎn)？

1）不同點(diǎn)：

普通類

接口

抽象類 可以直接實(shí)例化對(duì)象

不可以直接實(shí)例化對(duì)象

不可以直接實(shí)例化對(duì)象

可以定義任何成員

只能定義抽象成員方法和常量

成員方法必須定義為抽象其他和普通類相同

可以被繼承

類可以實(shí)現(xiàn)接口，且可以實(shí)現(xiàn)多個(gè)接口

可以被繼承

接口可以繼承多個(gè)接口

抽象類有構(gòu)造方法，接口中不能有

抽象類有普通成員變量，接口中沒有

抽象類可以有非抽象方法，接口中不能有

抽象類可以用public、protected修飾，接口中只能public（默認(rèn)public）

抽象類包含靜態(tài)方法，接口中沒有

接口中的變量只能是public static final，抽象類中可以是任意類型修飾

2)相同點(diǎn)：都可以用于描述(封裝)事物的，內(nèi)部類分為哪幾種？分別如何創(chuàng)建對(duì)象？ 分為 局部內(nèi)部類，匿名內(nèi)部類...3種

1）外部類名.內(nèi)部類名 對(duì)象名＝new 外部類名（）.new 內(nèi)部類名（）2）外部類名.內(nèi)部類名 對(duì)象名＝外部類名.new 內(nèi)部類名（）3）....不記得了第3種 匿名內(nèi)部類

二、集合集合的定義？

集合：用來保存一組數(shù)據(jù)的數(shù)據(jù)結(jié)構(gòu)

集合的父接口，實(shí)現(xiàn)接口，實(shí)現(xiàn)類，實(shí)現(xiàn)類的常用方法是什么？(建議以樹狀圖畫出來，便于加深印象)。

Collection

list

set

Arraylist

LinkedList

HashSet TreeSet

1.List集合

List集合的特征是元素可重復(fù)且有序 ；我們可以把他看成是一個(gè)動(dòng)態(tài)數(shù)組，一般通過下標(biāo)訪問

ArrayList和LinkedList最常用的兩個(gè)子類實(shí)現(xiàn) 1)list可以使用for循環(huán)遍歷 for（int i=;i

list.get(i);} 2)list的淺層復(fù)制

調(diào)用ArraryList.clone()方法

注意：不能使用list.clone(),clone()方法是Object類的方法,list是接口是不能繼承Object類的

2.Set集合： 不重復(fù)且無序集

遍歷set只能迭代器，用迭代器遍歷集合遵循的操作原則:先問后取。問一次取一次。Iterator it=set.iterator();while(it.hashnext()){

E e=it.next();} 3)map表

Map存儲(chǔ)數(shù)據(jù)使用key-value(鍵-值)對(duì)的形式存儲(chǔ)數(shù)據(jù)的。

對(duì)于Map而言，要求key值是唯一的。value值可以重復(fù)

獲取數(shù)據(jù)時(shí)，使用key可以獲取其對(duì)應(yīng)的value 遍歷map有3種方法 1）遍歷key

Set keySet = map.keySet();

for(String key:keySet){

System.out.println(”key：“ + key);

//可以根據(jù)每一個(gè)key獲取其對(duì)應(yīng)的value值

int value = map.get(key);2)遍歷value Collection values = map.values();

Iterator it = values.iterator();

while(it.hasNext()){

int value = it.next();//不能采用 map.next()

System.out.println(”value:“ + value);注意：通過迭代器在遍歷集合的過程中，不能通過集合(即不能采用 map.next())去改變集合元素?cái)?shù)量

3)遍歷鍵值對(duì)

Set> entries= map.entrySet();

for(Entry entry : entries){

//獲取一組鍵值對(duì)的鍵和值

String key = entry.getKey();

int value = entry.getValue();

System.out.println(key + ”=" + value);

Collection接口方法的定義

這里我主要列舉 Iterator iterator()方法的使用

Collection提供的方法 Iterator iterator()方法來獲取迭代器 Iterator是一個(gè)接口，定義了遍歷集合應(yīng)有的方法。

使用迭代器遍歷集合遵循的操作原則:先問后取。問一次取一次。

問：boolean hashNext()

?。篛bject next()

迭代器可以將取出的數(shù)據(jù)刪除掉

刪：remove()將當(dāng)前獲取的元素刪除掉。

注意：1)刪除的是next()取出的元素。且只能刪除一次！

2)調(diào)用1次next()后只能調(diào)用一次remove()!

第三篇：學(xué)習(xí)心得《面向?qū)ο蟆?/a>

面向?qū)ο笳n程學(xué)習(xí)心得

這學(xué)期的面向?qū)ο笳n程對(duì)我來說是收獲匪淺的一門課。通過老師課件的講解，自己一些相關(guān)書籍的閱讀和實(shí)踐作業(yè)的完成，逐步對(duì)課程有了由淺及深的認(rèn)識(shí)。

面向?qū)ο?Object Oriented,OO)是一門以實(shí)踐為主課程，課程中可以分開兩塊OOA（面向?qū)ο笙到y(tǒng)分析)和OOD（面向?qū)ο笙到y(tǒng)設(shè)計(jì)）。OOA（面向?qū)ο笙到y(tǒng)分析)主要內(nèi)容: 研究問題域和用戶需求,運(yùn)用面向?qū)ο蟮挠^點(diǎn)和原則發(fā)現(xiàn)問題域中與系統(tǒng)責(zé)任有關(guān)的對(duì)象,以及對(duì)象的特征和相互關(guān)系.OOA不涉及針對(duì)具體實(shí)現(xiàn)采取的設(shè)計(jì)決策和有關(guān)細(xì)節(jié),獨(dú)立于具體實(shí)現(xiàn)的系統(tǒng)模型。是一個(gè)完整確切反映問題域和用戶需求的系統(tǒng)模型。OOA的優(yōu)勢(shì)：復(fù)用、可擴(kuò)展、可維護(hù)性、彈性。

OOD（面向?qū)ο笙到y(tǒng)設(shè)計(jì)）：以O(shè)OA模型為基礎(chǔ)，按照實(shí)現(xiàn)的要求進(jìn)行設(shè)計(jì)決策，包括全局性的決策和局部細(xì)節(jié)的設(shè)計(jì)，與具體的實(shí)現(xiàn)條件相關(guān)。OOD的步驟：細(xì)化重組類→細(xì)化和實(shí)現(xiàn)類之間的關(guān)系，明確其可見性→增加屬性,指定屬性的類型和可見性→分配職責(zé),定義執(zhí)行每個(gè)職責(zé)的方法→對(duì)消息驅(qū)動(dòng)的系統(tǒng),明確消息傳遞的方式→利用設(shè)計(jì)模式進(jìn)行局部設(shè)計(jì)→畫出詳細(xì)的類圖和時(shí)序圖。

面向?qū)ο蟮姆治雠c設(shè)計(jì)方法將致力于解決傳統(tǒng)軟件研發(fā)過程中由于軟件模塊化結(jié)構(gòu)化程度不高帶來的軟件重用性差、軟件可維護(hù)性差、開發(fā)出的軟件不能滿足用戶需要等方面問題。面向?qū)ο蟮母拍畎ǎ簩?duì)象、對(duì)象的狀態(tài)和行為、類、類的結(jié)構(gòu)、消息和方法。對(duì)象概念將包含對(duì)象唯一性、抽象性、繼承性、多態(tài)性的重要特征。面向?qū)ο蟮囊匕撼橄?、封裝性、共享性三方面。

在設(shè)計(jì)模式的研究過程中，我們組選擇的是迭代器（Iterator）的設(shè)計(jì)模式研究。完成設(shè)計(jì)研究后，我對(duì)迭代器的設(shè)計(jì)模式有了更為深刻的理解。迭代器（Iterator）提供一個(gè)方法順序訪問一個(gè)聚合對(duì)象的各個(gè)元素，而又不暴露該對(duì)象的內(nèi)部表示。并了解到迭代器設(shè)計(jì)模式一般在以下三類場(chǎng)合使用較多。

? 訪問一個(gè)聚合對(duì)象的內(nèi)容而無需暴露它的內(nèi)部表示。? 支持對(duì)聚合對(duì)象的多種遍歷。因?yàn)楸闅v狀態(tài)是保存在每一個(gè)迭代器對(duì)象中的。

? 為遍歷不同的聚合結(jié)構(gòu)提供一個(gè)統(tǒng)一的接口。根據(jù)實(shí)現(xiàn)方式的不同，效果上會(huì)有差別。同時(shí)還簡化了容器的接口。但是在java Collection中為了提高可擴(kuò)展性，容器還是提供了遍歷的接口。在面向?qū)ο蟮能浖O(shè)計(jì)中，我們經(jīng)常會(huì)遇到一類集合對(duì)象，這類集合對(duì)象的內(nèi)部結(jié)構(gòu)可能有著各種各樣的實(shí)現(xiàn)，但是歸結(jié)起來，無非有兩點(diǎn)是需要我們?nèi)リP(guān)心的：一是集合內(nèi)部的數(shù)據(jù)存儲(chǔ)結(jié)構(gòu)，二是遍歷集合內(nèi)部的數(shù)據(jù)。面向?qū)ο笤O(shè)計(jì)原則中有一條是類的單一職責(zé)原則，所以我們要盡可能的去分解這些職責(zé)，用不同的類去承擔(dān)不同的職責(zé)。Iterator模式就是分離了集合對(duì)象的遍歷行為，抽象出一個(gè)迭代器類來負(fù)責(zé)，這樣既可以做到不暴露集合的內(nèi)部結(jié)構(gòu)，又可讓外部代碼透明的訪問集合內(nèi)部的數(shù)據(jù)。

在Java Collection的應(yīng)用中，提供的具體迭代器角色是定義在容器角色中的內(nèi)部類。這樣便保護(hù)了容器的封裝。但是同時(shí)容器也提供了遍歷算法接口，你可以擴(kuò)展自己的迭代器。至于迭代器模式的使用?？蛻舫绦蛞鹊玫骄唧w容器角色，然后再通過具體容器角色得到具體迭代器角色。這樣便可以使用具體迭代器角色來遍歷容器了。

OOA和OOD之間沒有明顯的界限。OOA與OOD的不可分割性正好說明了OO思想的強(qiáng)大，即軟件過程階段的無縫連接，在交流與溝通中不會(huì)產(chǎn)生鴻溝，這是相對(duì)結(jié)構(gòu)化思想的好處，因?yàn)閺墓δ苣K到某塊詳細(xì)控制邏輯設(shè)計(jì)兩者之間的聯(lián)系不是十分緊密，需要分析人員與設(shè)計(jì)人員的再溝通。

通過課程的學(xué)習(xí)與實(shí)踐，對(duì)面向?qū)ο蟮睦砟?，以及相關(guān)方法，設(shè)計(jì)模式有了更為深刻的理解與掌握。針對(duì)面向?qū)ο蟮姆治雠c設(shè)計(jì)課程的授課內(nèi)容及方法，我個(gè)人覺得對(duì)我還是有不少的幫助和 提高。結(jié)合自己的工作，雖然與開發(fā)接觸的比較少，但是在運(yùn)維過程中，如果能了解開發(fā)原理，結(jié)合實(shí)際的工作，會(huì)對(duì)一些源代碼的分析能力以及工作效率的提高起到明顯的幫助作用。

第四篇：C#面向?qū)ο髮W(xué)習(xí)心得

一、封裝

這是一種隱藏信息的特性。拿本節(jié)引例來說，類CalculateDate 將數(shù)據(jù)結(jié)構(gòu)與算法隱藏在類的內(nèi)部，外界使用者無需知道具體技術(shù)實(shí)現(xiàn)細(xì)節(jié)即可使用此類。封裝這一特性不僅大大提高了代碼的易用性，而且還使得類的開發(fā)者可以方便地更換新的算法，這種變化不會(huì)影響使用類的外部代碼?？梢杂靡韵鹿秸故绢惖姆庋b特性：封裝的類=數(shù)據(jù)+對(duì)此數(shù)據(jù)所進(jìn)行的操作（即算法）。通俗地說，封裝就是：包起外界不必需要知道的東西，只向外界展露可供展示的東西。在面向?qū)ο罄碚撝校庋b這個(gè)概念擁有更為寬廣的含義。小到一個(gè)簡單的數(shù)據(jù)結(jié)構(gòu)，大到一個(gè)完整的軟件子系統(tǒng)，靜態(tài)的如某軟件系統(tǒng)要收集數(shù)據(jù)信息項(xiàng)，動(dòng)態(tài)的如某個(gè)工作處理流程，都可以封裝到一個(gè)類中。具備這種“封裝”的意識(shí)，是掌握面向?qū)ο蠓治雠c設(shè)計(jì)技巧的關(guān)鍵。

二、繼承

繼承是面向?qū)ο缶幊讨幸粋€(gè)非常重要的特性，它也是另一個(gè)重要特性——多態(tài)的基礎(chǔ)?，F(xiàn)實(shí)生活中的事物都?xì)w屬于一定的類別。在一些書中，將父類稱為超類（super class）?！袄^承”關(guān)系有時(shí)又稱為“派生”關(guān)系，“B 繼承自A”，可以說為“B 派生自A”，或反過來說，“A 派生出B”。父類與子類之間擁有以下兩個(gè)基本特性：

(1)是一種（IS-A）關(guān)系：子類是父類的一種特例。

(2)擴(kuò)充（Extends）關(guān)系：子類擁有父類所沒有的功能。

1.類成員的訪問權(quán)限

面向?qū)ο缶幊痰囊淮筇攸c(diǎn)就是可以控制類成員的可訪問性。當(dāng)前主流的面向?qū)ο笳Z言都擁有以下三種基本的可訪問性：

(1)公有 public 訪問不受限制。

(2)私有 private 只有類自身成員可以訪問。

(3)保護(hù) protected 子類可以訪問，其他類無法訪問。

由此可見，可以通過子類對(duì)象訪問其父類的所有公有成員，事實(shí)上，外界根本分不清楚對(duì)象的哪些公有成員來自父類，哪些公有成員來自子類自身。小結(jié)一下繼承條件下的類成員訪問權(quán)限：

(1)所有不必讓外人知道的東西都是私有的。

(2)所有需要向外提供的服務(wù)都是公有的。

(3)所有的“祖?zhèn)鹘^招”，“秘不外傳”的都是保護(hù)的。

C#中還有一種可訪問性，就是由關(guān)鍵字internal 所確定的“內(nèi)部”訪問性。internal 有點(diǎn)像public，外界類也可以直接訪問聲明為internal 的類或類的成員，但這只局限于同一個(gè)程序集內(nèi)部。

讀者可以簡單地將程序集理解為一個(gè)獨(dú)立的DLL 或EXE 文件。一個(gè)DLL 或EXE 文件中可以有多個(gè)類，如果某個(gè)類可被同一程序集中的類訪問，但其他程序集中的類不能訪問它，則稱此類具有internal 訪問性。internal 是C#的默認(rèn)可訪問性，這就是說，如果某個(gè)類沒有任何可訪問性關(guān)鍵字在它前面，則它就是internal 的。

2.子類父類變量的相互賦值

子類對(duì)象可以被當(dāng)成基類對(duì)象使用。這是因?yàn)樽宇悓?duì)象本就是一種（IS_A）父類對(duì)象，因此，以下代碼是合法的：

Parent p;

Son c = new Son();

p = c;

然而，反過來就不可以，父類對(duì)象變量不可以直接賦值給子類變量。如果確信父類變量中所引用的對(duì)象的確是子類類型，則可以通過類型強(qiáng)制轉(zhuǎn)換進(jìn)行賦值，其語法格式為： 子類對(duì)象變量=(子類名稱)基類對(duì)象變量;

子類對(duì)象變量=基類對(duì)象變量 as 子類名稱;

3.方法重載、隱藏與虛方法調(diào)用

由于子類對(duì)象同時(shí)匯集了父類和子類的所有公共方法，而C#并未對(duì)子類和父類的方法名稱進(jìn)行過多限制，因此，一個(gè)問題出現(xiàn)了：如果子類中某個(gè)方法與父類方法的簽名一樣（即方法名和方法參數(shù)都一樣），那當(dāng)通過子類對(duì)象訪問此方法時(shí)，訪問的是子類還是父類所定義的方法？讓我們先從子類方法與父類方法之間的關(guān)系說起。總的來說，子類方法與父類方法之間的關(guān)系可以概括為以下三種：

(1)擴(kuò)充（Extend)：子類方法，父類沒有；

(2)重載（Overload）：子類有父類的同名函數(shù)，但參數(shù)類型或數(shù)目不一樣；

(3)完全相同：子類方法與父類方法從方法名稱到參數(shù)類型完全一樣。

當(dāng)子類與父類擁有完全一樣的方法時(shí)，稱“子類隱藏了父類的同名方法，當(dāng)分別位于父類和子類的兩個(gè)方法完全一樣時(shí)，調(diào)用哪個(gè)方法由對(duì)象變量的類型決定。“new”關(guān)鍵字明確告訴C#編譯器，子類隱藏父類的同名方法，提供自己的新版本。如果子類隱藏了父類的同名方法，要在子類方法的實(shí)現(xiàn)代碼中調(diào)用父類被隱藏的同名方法時(shí)要使用base 關(guān)鍵字。如果子類隱藏了父類的同名方法，不進(jìn)行強(qiáng)制轉(zhuǎn)換，就無法通過父類變量直接調(diào)用子類的同名方法，哪怕父類變量引用的是子類對(duì)象。這是不太合理的。我們希望每個(gè)對(duì)象都只干自己職責(zé)之內(nèi)的事，即如果父類變量引用的是子類對(duì)象，則調(diào)用的就是子類定義的方法，而如果父類變量引用的就是父類對(duì)象，則調(diào)用的是父類定義的方法。這就是說，希望每個(gè)對(duì)象都“各人自掃門前雪，莫管他人瓦上霜”。為達(dá)到這個(gè)目的，可以在父類同名方法前加關(guān)鍵字virtual，表明這是一個(gè)虛方法，子類可以重寫此方法：即在子類同名方法前加關(guān)鍵字override，表明對(duì)父類同名方法進(jìn)行了重寫。所以，將父類方法定義為虛方法，子類重寫同名方法之后，通過父類變量調(diào)用此方法，到底是調(diào)用父類還是子類的，由父類變量引用的真實(shí)對(duì)象類型決定，而與父類變量無關(guān)！很明顯，“虛方法調(diào)用”特性可以讓我們寫出非常靈活的代碼，大大減少由于系統(tǒng)功能

擴(kuò)充和改變所帶來的大量代碼修改工作量。由此給出結(jié)論：面向?qū)ο笳Z言擁有的“虛方法調(diào)用”特性，使我們可以只用同樣的一個(gè)語句，在運(yùn)行時(shí)根據(jù)對(duì)象類型而執(zhí)行不同的操作。

三、抽象

1.抽象類與抽象方法

在一個(gè)類前面加上“abstract”關(guān)鍵字，此類就成為了抽象類。對(duì)應(yīng)地，一個(gè)方法類前面加上“abstract”關(guān)鍵字，此方法就成為了抽象方法。注意抽象方法不能有實(shí)現(xiàn)代碼，在函數(shù)名后直接跟一個(gè)分號(hào)。抽象類專用于派生出子類，子類必須實(shí)現(xiàn)抽象類所聲明的抽象方法，否則，子類仍是抽象類。抽象類一般用于表達(dá)一種比較抽象的事物，而抽象方法則說明此抽象類應(yīng)該具有的某種性質(zhì)，從同一抽象類中繼承的子類擁有相同的方法（即抽象類所定義的抽象方法），但這些方法的具體代碼每個(gè)類都可以不一樣。抽象類不能創(chuàng)建對(duì)象，一般用

它來引用子類對(duì)象。一個(gè)抽象類中可以包含非抽象的方法和字段。因此：包含抽象方法的類一定是抽象類，但抽象類中的方法不一定是抽象方法。除了方法可以是抽象的之外，屬性也可以是抽象的。

2.接口

接口可以看成是一種“純”的抽象類，它的所有方法都是抽象方法。抽象類定義了對(duì)象所屬的類別，而接口實(shí)際上定義了一種對(duì)象應(yīng)具有的行為特性。某個(gè)類可以實(shí)現(xiàn)多個(gè)接口，當(dāng)創(chuàng)建一個(gè)此類的對(duì)象之后，通過引用這個(gè)對(duì)象的對(duì)象變量可以訪問其所有的公有方法（包括自身的公有方法以及由接口定義的公有方法以）。在這種情況下，根本分不清哪些方法是由接口定義的，哪些是由類自己定義的。C#提供了一種“顯式接口”實(shí)現(xiàn)機(jī)制，可以區(qū)分開這兩種情況。由此得到一個(gè)結(jié)論：如果一個(gè)類顯式實(shí)現(xiàn)某個(gè)接口，則只能以此接口類型的變量為媒介調(diào)用此接口所定義的方法，而不允許通過類的對(duì)象變量直接調(diào)用?；蛘哌@樣說：被顯式實(shí)現(xiàn)的接口方法只能通過接口實(shí)例訪問，而不能通過類實(shí)例直接訪問。

四、多態(tài)

方法重載屬于多態(tài)的一種，兩個(gè)構(gòu)成重載關(guān)系的函數(shù)必須滿足幾個(gè)條件：函數(shù)名相同、參數(shù)類型不同，或參數(shù)個(gè)數(shù)不同。具體調(diào)用哪個(gè)方法要看參數(shù)，需要注意的是，方法返回值類型的不同不是方法重載的判斷條件。多態(tài)編程的基本原理是：使用基類或接口變量編程。在多態(tài)編程中，基類一般都是抽象基類，其中擁有一個(gè)或多個(gè)抽象方法，各個(gè)子類可以根據(jù)需要重寫這些方法。或者使用接口，每個(gè)接口都規(guī)定了一個(gè)或多個(gè)抽象方法，實(shí)現(xiàn)接口的類根據(jù)需要實(shí)現(xiàn)這些方法。因此，多態(tài)的實(shí)現(xiàn)分為兩大基本類別：繼承多態(tài)和接口多態(tài)。

1.接口多態(tài)與繼承多態(tài)

接口多態(tài)與繼承多態(tài)其編程方式與作用都是類似的。但由于一個(gè)類可以實(shí)現(xiàn)多個(gè)接口，所以，接口多態(tài)較繼承多態(tài)更靈活，因而在編程中也用得更廣。多態(tài)是面向?qū)ο蠹夹g(shù)中最精華的部分之一。大量的精巧軟件設(shè)計(jì)方案都建立在對(duì)多態(tài)特性的巧妙應(yīng)用上。在編程中應(yīng)用多態(tài)，可以將其簡化為兩句：應(yīng)用繼承實(shí)現(xiàn)對(duì)象的統(tǒng)一管理；應(yīng)用接口定義對(duì)象的行為特性。對(duì)比傳統(tǒng)的不使用多態(tài)的編程方式，使用多態(tài)的好處是：當(dāng)要修改程序并擴(kuò)充系統(tǒng)時(shí)，需要修改的地方較少，對(duì)其他部分代碼的影響較小。

五、類與對(duì)象

類是面向?qū)ο缶幊痰幕締卧?，與使用C語言等結(jié)構(gòu)化編程語言不一樣，使用C#編程，所有的程序代碼幾乎都放在類中，不存在獨(dú)立于類之外的函數(shù)。一個(gè)類可以包含兩種成員：靜態(tài)成員和實(shí)例成員，靜態(tài)成員是供類的所有對(duì)象所共享的，而實(shí)例成員只供某一個(gè)對(duì)象所有。實(shí)例成員與靜態(tài)成員的訪問規(guī)則：位于同一類中的實(shí)例方法可直接相互調(diào)用；類的字段（包括實(shí)例字段和靜態(tài)字段）可以被同一類中的所有實(shí)例方法直接訪問；類中的靜態(tài)方法只能直接訪問類靜態(tài)字段。

類中包括：方法和字段，屬性是一種特殊的字段，它可以保證數(shù)據(jù)的合法性，方法和字段這兩個(gè)概念是面向?qū)ο罄碚摰男g(shù)語，是通用于各種面向?qū)ο笳Z言的。字段（Field）代表了類中的數(shù)據(jù)，在類的所有方法之外定義一個(gè)變量即定義了一個(gè)字段。在變量之前可以加上public、private 和protected 表示字段的訪問權(quán)限。方法(function)功能代碼的集合，在程序開發(fā)過程中，經(jīng)常發(fā)現(xiàn)多處需要實(shí)現(xiàn)或調(diào)用某一個(gè)公用功能，這些功能的實(shí)現(xiàn)都需要書

寫若干行代碼。如果在調(diào)用此功能的地方重復(fù)書寫這些功能代碼，將會(huì)使整個(gè)程序中代碼大量重復(fù)，會(huì)增大開發(fā)工作量，增加代碼維護(hù)的難度。為了解決代碼重復(fù)的問題，絕大多數(shù)程序設(shè)計(jì)語言都將完成某一公用功能的多個(gè)語句組合在一起，起一個(gè)名字用于代表這些語句的全體，這樣的代碼塊被稱為“函數(shù)（function）”。引入“函數(shù)”概念之后，程序中凡需要調(diào)用此公用功能的地方都可以只寫出函數(shù)名，此名字就代表了函數(shù)中所包含的所有代碼，這樣一來，就不再需要在多個(gè)地方重復(fù)書寫這些功能代碼。

對(duì)象是以類為模板創(chuàng)建出來的。類與對(duì)象之間是一對(duì)多的關(guān)系。在C#中，使用new 關(guān)鍵字創(chuàng)建對(duì)象。在程序中“活躍”的是對(duì)象而不是類。在面向?qū)ο箢I(lǐng)域，對(duì)象有時(shí)又被稱為是“類的實(shí)例”，“對(duì)象”與“類的實(shí)例”這兩個(gè)概念是等同的。

六、值類型與引用類型

1.值類型

值類型變量與引用類型變量的內(nèi)存分配模型也不一樣。每個(gè)正在運(yùn)行的程序都對(duì)應(yīng)著一個(gè)進(jìn)程（process），在一個(gè)進(jìn)程內(nèi)部，可以有一個(gè)或多個(gè)線程（thread），每個(gè)線程都擁有一塊“自留地”，稱為“線程堆?！保笮?M，用于保存自身的一些數(shù)據(jù)，比如函數(shù)中定義的局部變量、函數(shù)調(diào)用時(shí)傳送的參數(shù)值等，這部分內(nèi)存區(qū)域的分配與回收不需要程序員干涉。所有值類型的變量都是在線程堆棧中分配的。值類型共有三種：簡單類型、枚舉類型和結(jié)構(gòu)類型。

2.引用類型

另一塊內(nèi)存區(qū)域稱為“堆（heap）”，在.NET 這種托管環(huán)境下，堆由CLR 進(jìn)行管理，所以又稱為“托管堆（managed heap）”。用new 關(guān)鍵字創(chuàng)建的類的對(duì)象時(shí)，分配給對(duì)象的內(nèi)存單元就位于托管堆中。在程序中我們可以隨意地使用new 關(guān)鍵字創(chuàng)建多個(gè)對(duì)象，因此，托管堆中的內(nèi)存資源是可以動(dòng)態(tài)申請(qǐng)并使用的，當(dāng)然用完了必須歸還。打個(gè)比方更易理解：托管堆相當(dāng)于一個(gè)旅館，其中的房間相當(dāng)于托管堆中所擁有的內(nèi)存單元。當(dāng)程序員用new 方法創(chuàng)建對(duì)象時(shí)，相當(dāng)于游客向旅館預(yù)訂房間，旅館管理員會(huì)先看一下有沒有合適的空房間，有的話，就可以將此房間提供給游客住宿。當(dāng)游客旅途結(jié)束，要辦理退房手續(xù)，房間又可以為其他旅客提供服務(wù)了。引用類型共有四種：類類型、接口類型、數(shù)組類型和委托類型。所有引用類型變量所引用的對(duì)象，其內(nèi)存都是在托管堆中分配的。嚴(yán)格地說，我們常說的“對(duì)象變量”其實(shí)是類類型的引用變量。但在實(shí)際中人們經(jīng)常將引用類型的變量簡稱為“對(duì)象變量”，用它來指代所有四種類型的引用變量。

七、命名空間與類庫

1.命名空間

在使用面向?qū)ο蠹夹g(shù)開發(fā)的現(xiàn)代軟件系統(tǒng)中，經(jīng)常擁有數(shù)百甚至上千個(gè)類，為了方便地管理這些類，面向?qū)ο蠹夹g(shù)引入了“命名空間（namespace）”的概念。命名空間可以看成是類的“容器”，它可以包含多個(gè)類。.NET Framework 使用命名空間來管理所有的類。如果把類比喻成書的話，則命名空間類似于放書的書架，書放在書架上，類放在命名空間里。當(dāng)我們?nèi)D書館查找一本書時(shí)，需要指定這本書的編號(hào)，編號(hào)往往規(guī)定了書放在哪個(gè)書庫的哪個(gè)書架上，通過逐漸縮小的范圍：圖書館->書庫->書架，最終可以在某個(gè)書架中找到這本書。類似地，可以采用圖書館保存圖書類似的方法來管理類，通過逐漸縮小的范圍：最大的命名空間->子命名空間->孫命名空間??，最終找到一個(gè)類。

2.類庫

為了提高軟件開發(fā)的效率，人們?cè)谡麄€(gè)軟件開發(fā)過程中大量應(yīng)用了軟件工程的模塊化原則，將可以在多個(gè)項(xiàng)目中使用的代碼封裝為可重用的軟件模塊，其于這些可復(fù)用的軟件模塊，再開發(fā)新項(xiàng)目就成為“重用已有模塊，再開發(fā)部分新模塊，最后將新舊模塊組裝起來”的過程。整個(gè)軟件開發(fā)過程類似于現(xiàn)代工業(yè)的生產(chǎn)流水線，生產(chǎn)線上的每個(gè)環(huán)節(jié)都由特定的人員負(fù)責(zé)，整個(gè)生產(chǎn)線上的工作人員既分工明確又相互合作，大大地提高了生產(chǎn)效率。在組件化開發(fā)大行其道的今天，人們通常將可以重用的軟件模塊稱為“軟件組件”。在全面向?qū)ο蟮?NET 軟件平臺(tái)之上，軟件組件的表現(xiàn)形式為程序集（Assembly），可以通過在Visual Studio 中創(chuàng)建并編譯一個(gè)類庫項(xiàng)目得到一個(gè)程序集。在Visual Studio 的項(xiàng)目模板中，可以很方便地創(chuàng)建類庫（Class Library）項(xiàng)目，Visual Studio 會(huì)自動(dòng)在項(xiàng)目中添加一個(gè)名為Class1.cs 的類文件，程序員可在此類文件中書寫代碼，或者添加新的類。一個(gè)類庫項(xiàng)目中可以容納的類數(shù)目沒有限制，但只有聲明為public 的類可以被外界使用。類庫項(xiàng)目編譯之后，會(huì)生成一個(gè)動(dòng)態(tài)鏈接庫（DLL：Dynamic Link Library）文件。這就是可以被重用的.NET 軟件組件——程序集。默認(rèn)情況下，類庫文件名就是項(xiàng)目名加上“.dll”后綴。每個(gè)類庫項(xiàng)目都擁有一個(gè)默認(rèn)的命名空間，可以通過類庫項(xiàng)目的屬性窗口來指定。需要仔細(xì)區(qū)分“類庫項(xiàng)目”、“程序集”和“命名空間”這三個(gè)概念的區(qū)別：

(1)每個(gè)類庫項(xiàng)目編譯之后，將會(huì)生成一個(gè)程序集。

(2)類庫項(xiàng)目中可以擁有多個(gè)類，這些類可屬于不同的命名空間。

(3)不同的類庫項(xiàng)目可以定義相同的命名空間。

根據(jù)上述三個(gè)特性，可以得到以下結(jié)論：“命名空間”是一個(gè)邏輯上的概念，它的物理載體是“程序集”，具體體現(xiàn)為“DLL”（或EXE）文件。在Visual Studio 中，可通過創(chuàng)建“類庫”類型的項(xiàng)目生成程序集。一個(gè)程序集可以有多個(gè)命名空間，而一個(gè)命名空間也可以分布于多個(gè)程序集。一旦生成了一個(gè)程序集，在其他項(xiàng)目中就可以通過添加對(duì)這一程序集的引用而使用此程序集中的類。其方法是在“項(xiàng)目”菜單中選擇“添加程序集”命令，激活“瀏覽”卡片，選擇一個(gè)現(xiàn)有的程序集文件（DLL 或EXE）。一個(gè)項(xiàng)目添加完對(duì)特定程序集的引用之后，就可以直接創(chuàng)建此程序集中的類了，當(dāng)然要注意指明其命名空間。

八、委托

委托是一種新的面向?qū)ο笳Z言特性，在歷史比較長的面向?qū)ο笳Z言比如C++中并未出現(xiàn)過。微軟公司在設(shè)計(jì)運(yùn)行于.NET Framework平臺(tái)之上的面向?qū)ο笳Z言（如C#和VisualBasic.NET）時(shí)引入了這一新特性。委托（delegate）也可以看成是一種數(shù)據(jù)類型，可以用于定義變量。但它是一種特殊的數(shù)據(jù)類型，它所定義的變量能接收的數(shù)值只能是一個(gè)函數(shù)，更確切地說，委托類型的變量可以接收一個(gè)函數(shù)的地址，很類似于C＋＋語言的函數(shù)指針。簡單地說：委托變量可看成是一種類型安全的函數(shù)指針，它只能接收符合其要求的函數(shù)地址。委托可以看成是一個(gè)函數(shù)的“容器”，將某一具體的函數(shù)“裝入”后，就可以把它當(dāng)成函數(shù)一樣使用。定義委托類型時(shí)對(duì)函數(shù)的要求被稱為函數(shù)的“簽名（signature）”。函數(shù)的簽名規(guī)定了函數(shù)的參數(shù)數(shù)目和類型，以及函數(shù)的返回值，體現(xiàn)了函數(shù)的本質(zhì)特征。每一個(gè)委托都確定了一個(gè)函數(shù)的簽名。擁有不同簽名的函數(shù)不能賦值給同一類型的委托變量。因此，一個(gè)委托類型的變量，可以引用任何一個(gè)滿足其要求的函數(shù)。

1.委托的組合與分解

委托變量可以代表某一函數(shù)，使用委托變量就相當(dāng)于調(diào)用一個(gè)函數(shù)。如果僅是這么簡單，那么直接調(diào)用函數(shù)不就行了嗎？為什么還要引入“委托”這一特性？事實(shí)上，委托不僅可以代表一個(gè)函數(shù)，還可以組合“一堆”的函數(shù)，然后批量執(zhí)行它們，這樣的委托變量又稱為“多路委托變量”?？梢杂眉臃ㄟ\(yùn)算符來組合單個(gè)委托變量為多路委托變量。類似地，也可以使用減法運(yùn)算符來從一個(gè)多路委托變量中移除某個(gè)委托變量。

2.事件與多路委托

事件的主要特點(diǎn)是一對(duì)多關(guān)聯(lián)，即一個(gè)事件源，多個(gè)響應(yīng)者。在具體技術(shù)上，.NET Framework 的事件處理機(jī)制是基于多路委托實(shí)現(xiàn)的。事件與多路委托其實(shí)大同小異，只不過多路委托允許在事件源對(duì)象之外激發(fā)事件罷了。所有的.NET Framework 可視化窗體控件的預(yù)定義事件，都是某一對(duì)應(yīng)的“事件名＋Handler”委托類型的變量。與此事件相關(guān)的信息都封裝在“事件名＋Args”類型的事件參數(shù)中，此事件參數(shù)有一個(gè)基類EventArgs，它是所有事件參數(shù)的基類。明了上述內(nèi)部機(jī)理，對(duì)于我們?cè)诔绦蛑卸x自己的事件非常有好處，尤其是開發(fā)一個(gè)自定義的可視化控件時(shí)，如果需要增加新的事件類型，我們應(yīng)盡量遵循.NET Framework 的定義事件的框架，給事件取一個(gè)名字，定義一個(gè)“事件名＋Handler”的事件委托類型，再從EventArgs 派生出自定義事件的參數(shù)，取名為“事件名＋Args”。

面向?qū)ο蟮能浖到y(tǒng)有許多都是事件驅(qū)動(dòng)的，ASP.NET 就采用了“事件驅(qū)動(dòng)”的編程方式。所謂“事件驅(qū)動(dòng)”的開發(fā)方式，就是指整個(gè)系統(tǒng)包含許多的對(duì)象，這些對(duì)象可以引發(fā)多種事件，軟件工程師的主要開發(fā)工作就是針對(duì)特定的事件書寫代碼響應(yīng)它們。.NET 事件處理機(jī)制建立在委托的基礎(chǔ)之上，而這兩者都是ASP.NET 技術(shù)的基礎(chǔ)之一。因此，必須牢固地掌握好委托和事件這兩種編程技術(shù)，才能為掌握ASP.NET 技術(shù)掃清障礙。

第五篇：java面向?qū)ο蟮膶W(xué)習(xí)心得

Java面向?qū)ο蟮膶W(xué)習(xí)心得

大三的時(shí)候?qū)W校組織我們?nèi)ヌK州NIIT參加四個(gè)月的java實(shí)訓(xùn)，我開始系統(tǒng)的學(xué)習(xí)期java，之前大學(xué)的時(shí)候?qū)W的比較寬泛，沒有專門的正對(duì)java的學(xué)習(xí)。

首先我是從學(xué)習(xí)Java編程開始接觸OOP(面向?qū)ο缶幊?，剛開始使用Java編寫程序的時(shí)候感覺很別扭，因?yàn)槲以缫粤?xí)慣用C來編寫程序，很欣賞C的簡潔性和高效性，喜歡C簡練而表達(dá)能力豐富的風(fēng)格，特別忍受不了Java運(yùn)行起來慢吞吞的速度，相對(duì)冗長的代碼，而且一個(gè)很簡單的事情，要寫好多類，一個(gè)類調(diào)用一個(gè)類，心里的抵觸情緒很強(qiáng)。

我對(duì)Java的面向?qū)ο蟮奶匦宰聊チ季?，自認(rèn)為有所領(lǐng)悟，也開始有意識(shí)的運(yùn)用OOP風(fēng)格來寫程序，然而還是經(jīng)常會(huì)覺得不知道應(yīng)該怎樣提煉類，面對(duì)一個(gè)具體的問題的時(shí)候，會(huì)覺得腦子里千頭萬緒的，不知道怎么下手，一不小心，又會(huì)回到原來的思路上去。

舉個(gè)例子，要發(fā)廣告郵件，廣告郵件列表存在數(shù)據(jù)庫里面。倘若用C來寫的話，一般會(huì)這樣思考，先把郵件內(nèi)容讀入，然后連接數(shù)據(jù)庫，循環(huán)取郵件地址，調(diào)用本機(jī)的qmail的sendmail命令發(fā)送。

然后考慮用Java來實(shí)現(xiàn)，既然是OOP，就不能什么代碼都塞到main過程里面，于是就設(shè)計(jì)了三個(gè)類：

一個(gè)類是負(fù)責(zé)讀取數(shù)據(jù)庫，取郵件地址，調(diào)用qmail的sendmail命令發(fā)送； 一個(gè)類是讀郵件內(nèi)容，MIME編碼成HTML格式的，再加上郵件頭；

一個(gè)主類負(fù)責(zé)從命令讀參數(shù)，處理命令行參數(shù)，調(diào)用發(fā)email的類。

把一件工作按照功能劃分為3個(gè)模塊分別處理，每個(gè)類完成一件模塊任務(wù)。

仔細(xì)的分析一下，就會(huì)發(fā)現(xiàn)這樣的設(shè)計(jì)完全是從程序員實(shí)現(xiàn)程序功能的角度來設(shè)計(jì)的，或者說，設(shè)計(jì)類的時(shí)候，是自低向上的，從機(jī)器的角度到現(xiàn)實(shí)世界的角度來分析問題的。因此在設(shè)計(jì)的時(shí)候，就已經(jīng)把程序編程實(shí)現(xiàn)的細(xì)節(jié)都考慮進(jìn)去了，企圖從底層實(shí)現(xiàn)程序這樣的出發(fā)點(diǎn)來達(dá)到滿足現(xiàn)實(shí)世界的軟件需求的目標(biāo)。

這樣的分析方法其實(shí)是不適用于Java這樣面向?qū)ο蟮木幊陶Z言，因?yàn)?，如果改用C語言，封裝兩個(gè)C函數(shù)，都會(huì)比Java實(shí)現(xiàn)起來輕松的多，邏輯上也清楚的多。

我覺得面向?qū)ο蟮木柙谟诳紤]問題的思路是從現(xiàn)實(shí)世界的人類思維習(xí)慣出發(fā)的，只要領(lǐng)會(huì)了這一點(diǎn)，就領(lǐng)會(huì)了面向?qū)ο蟮乃季S方法。

舉一個(gè)非常簡單的例子：假使現(xiàn)在需要寫一個(gè)網(wǎng)頁計(jì)數(shù)器，客戶訪問一次頁面，網(wǎng)頁計(jì)數(shù)器加1，計(jì)數(shù)器是這樣來訪問的后臺(tái)有一個(gè)數(shù)據(jù)庫表，保存每個(gè)id（一個(gè)id對(duì)應(yīng)一個(gè)被統(tǒng)計(jì)訪問次數(shù)的頁面）的計(jì)數(shù)器當(dāng)前值，請(qǐng)求頁面一次，對(duì)應(yīng)id的計(jì)數(shù)器的字段加1(這里我們忽略并發(fā)更新數(shù)據(jù)庫

表，出現(xiàn)的表鎖定的問題)。

如果按照一般從程序?qū)崿F(xiàn)的角度來分析，我們會(huì)這樣考慮：首先是從HTTP GET請(qǐng)求取到id，然后按照id查數(shù)據(jù)庫表，獲得某id對(duì)應(yīng)的訪問計(jì)數(shù)值，然后加1，更新數(shù)據(jù)庫，最后向頁面顯示訪問計(jì)數(shù)。

現(xiàn)在假設(shè)一個(gè)沒有程序設(shè)計(jì)經(jīng)驗(yàn)的人，他會(huì)怎樣來思考這個(gè)問題的呢？他會(huì)提出什么樣的需求呢？他很可能會(huì)這樣想：

我需要有一個(gè)計(jì)數(shù)器，這個(gè)計(jì)數(shù)器應(yīng)該有這樣的功能，刷新一次頁面，訪問量就會(huì)加1，另外最好還有一個(gè)計(jì)數(shù)器清0的功能，當(dāng)然計(jì)數(shù)器如果有一個(gè)可以設(shè)為任意值的功能的話，我就可以作弊了。

做為一個(gè)沒有程序設(shè)計(jì)經(jīng)驗(yàn)的人來說，他完全不會(huì)想到對(duì)數(shù)據(jù)庫應(yīng)該如何操作，對(duì)于HTTP變量該如何傳遞，他考慮問題的角度就是我有什么需求，我的業(yè)務(wù)邏輯是什么，軟件應(yīng)該有什么功能。

按照這樣的思路(請(qǐng)注意，他的思路其實(shí)就是我們平時(shí)在生活中習(xí)慣的思維方式)，我們知道需要有一個(gè)計(jì)數(shù)器類 Counter，有一個(gè)必須的和兩個(gè)可選的方法：

getCount()// 取計(jì)數(shù)器值方法

resetCounter()// 計(jì)數(shù)器清0方法

setCount()// 設(shè)計(jì)數(shù)器為相應(yīng)的值方法

把Counter類完整的定義如下：

public class Counter {

public int getCount(int id){}

public void resetCounter(int id){}

public void setCount(int id, int currentCount){}

}

解決問題的框架已經(jīng)有了，來看一下如何使用Counter。在count.cgi里面調(diào)用Counter來計(jì)數(shù)，程序片斷如下：

// 這里從HTTP環(huán)境里面取id值

...Counter myCounter = new Counter();// 獲得計(jì)數(shù)器

int currentCount = myCounter.getCount(id);// 從計(jì)數(shù)器中取計(jì)數(shù)

// 這里向客戶瀏覽器輸出

...程序的框架全都寫好了，剩下的就是實(shí)現(xiàn)Counter類方法里面具體的代碼了，此時(shí)才去考慮具體的程序語言實(shí)現(xiàn)的細(xì)節(jié)，比如，在getCount()方法里面訪問數(shù)據(jù)庫，更新計(jì)數(shù)

值。

從上面的例子中看到，面向?qū)ο蟮乃季S方法其實(shí)就是我們?cè)诂F(xiàn)實(shí)生活中習(xí)慣的思維方式，是從人類考慮問題的角度出發(fā)，把人類解決問題的思維方式逐步翻譯成程序能夠理解的思維方式的過程，在這個(gè)翻譯的過程中，軟件也就逐步被設(shè)計(jì)好了。

在運(yùn)用面向?qū)ο蟮乃季S方法進(jìn)行軟件設(shè)計(jì)的過程中，最容易犯的錯(cuò)誤就是開始分析的時(shí)候，就想到了程序代碼實(shí)現(xiàn)的細(xì)節(jié)，因此封裝的類完全是基于程序?qū)崿F(xiàn)邏輯，而不是基于解決問題的業(yè)務(wù)邏輯。

學(xué)習(xí)JDBC編程的經(jīng)典錯(cuò)誤問法是：“我怎樣封裝對(duì)數(shù)據(jù)庫的select操作？”

面向?qū)ο蟮脑O(shè)計(jì)是基于解決業(yè)務(wù)問題的設(shè)計(jì)，而不是基于具體編程技術(shù)的設(shè)計(jì)。我不會(huì)去封裝select語句的，我只封裝解決問題的業(yè)務(wù)邏輯，對(duì)數(shù)據(jù)庫的讀取是在業(yè)務(wù)邏輯的編碼實(shí)現(xiàn)階段才去考慮的問題。

回過頭看上面那個(gè)發(fā)廣告郵件的例子，應(yīng)該如何應(yīng)用面向?qū)ο蟮乃季S方法呢？

對(duì)于一個(gè)郵件來說，有郵件頭，郵件體，和郵件地址這三個(gè)屬性，發(fā)送郵件，需要一個(gè)發(fā)送的方法，另外還需要一個(gè)能把所有郵件地址列出來的方法。所以應(yīng)該如下設(shè)計(jì)：

類JunkMail

屬性：

head

body

address

方法：

sendMail()// 發(fā)送郵件

listAllMail()// 列郵件地址

用Java來表示：

public class JunkMail {

private String head;

private String body;

private String address;

public JunkMain(){ // 默認(rèn)的類構(gòu)造器

// 從外部配置文件讀郵件頭和郵件體

this.head=...;

this.body=...;

}

public static boolean sendMail(String address){

// 調(diào)用qmail，發(fā)送email

}

public static Collection listAllMail(){

// 訪問數(shù)據(jù)庫，返回一個(gè)郵件地址集合}

}

當(dāng)把JunkMail設(shè)計(jì)好了以后，再調(diào)用JunkMail類完成郵件的發(fā)送，將是非常輕松的事情。

如果說傳統(tǒng)的面向過程的編程是符合機(jī)器運(yùn)行指令的流程的話，那么面向?qū)ο蟮乃季S方法就是符合現(xiàn)實(shí)生活中人類解決問題的思維過程。

在面向?qū)ο蟮能浖治龊驮O(shè)計(jì)的時(shí)候，要提醒自己，不要一上來就去想程序代碼的實(shí)現(xiàn)，應(yīng)該拋開具體編程語言的束縛，集中精力分析我們要實(shí)現(xiàn)的軟件的業(yè)務(wù)邏輯，分析軟件的業(yè)務(wù)流程，思考應(yīng)該如何去描述和實(shí)現(xiàn)軟件的業(yè)務(wù)。畢竟軟件只是一個(gè)載體，業(yè)務(wù)才是我們真正要實(shí)現(xiàn)的目標(biāo)。

但是在設(shè)計(jì)過程中，心里卻往往在擔(dān)心，如果我完全不去考慮程序代碼的實(shí)現(xiàn)的話，那么我怎么知道我的設(shè)計(jì)一定合理呢？我怎么知道我設(shè)計(jì)的類、接口一定可以實(shí)現(xiàn)呢？所以經(jīng)?？梢钥吹降默F(xiàn)象就是：

在設(shè)計(jì)過程中，雖然知道不能過早考慮代碼實(shí)現(xiàn)，但是每設(shè)計(jì)一個(gè)類，一個(gè)接口，心里都要不知不覺的用自己熟悉的編程語言大概的評(píng)估一下，看看能否編出來，因此，一不小心，就會(huì)又回到按照程序功能實(shí)現(xiàn)的思路進(jìn)行設(shè)計(jì)的老路上去了。

舉個(gè)例子來說明，在做Web程序設(shè)計(jì)的時(shí)候，經(jīng)常要遇到分頁顯示數(shù)據(jù)的情況。比如說需要把系統(tǒng)中所有的用戶都列出來這樣的功能。假設(shè)使用User類來表示用戶，增加用戶addUser()，刪除用戶deleteUser()，查詢所有用戶listUsers()方法。而數(shù)據(jù)庫中有一個(gè)user表，一條記錄是一個(gè)用戶的信息。下面考慮一下User類的方法的實(shí)現(xiàn)：

addUser()和deleteUser()方法都好實(shí)現(xiàn)，就是對(duì)數(shù)據(jù)庫增加記錄和刪除記錄。對(duì)于listUsers()方法，其實(shí)就是對(duì)user表的select，取出一個(gè)記錄集。但是該怎么從listUsers()方法中得到所有用戶的列表呢？

一個(gè)方法調(diào)用的返回值只有一個(gè)，沒有多個(gè)，所以很多情況下采用的辦法就是返回值定義為集合類型，比如Vector。這樣就可以在listUsers()方法的具體代碼實(shí)現(xiàn)的時(shí)候，從數(shù)據(jù)庫依次取出一個(gè)個(gè)記錄，插入到Vector里面來。在主程序里面，調(diào)用listUsers()方法可以返回一個(gè)Vector，然后再對(duì)Vector遍歷操作，就可以得到用戶列表了。

public class User {

public static void addUser(...){

// 數(shù)據(jù)庫insert一條記錄

}

public static void deleteUser(...){

// 數(shù)據(jù)庫delete一條記錄

}

public Vector listUsers(...){

// 數(shù)據(jù)庫select結(jié)果放到一個(gè)集合里面

}

}

這樣的設(shè)計(jì)基本合理，但是仍然有點(diǎn)小問題。因?yàn)樵谠O(shè)計(jì)的時(shí)候，就考慮到了用Java的集合類Vector來實(shí)現(xiàn)對(duì)不定長數(shù)據(jù)集的存放，因而違反了面向?qū)ο笤O(shè)計(jì)的一個(gè)原則：在設(shè)計(jì)的時(shí)候不應(yīng)過早的考慮具體程序語言的實(shí)現(xiàn)。所以必須用抽象的方法，和具體實(shí)現(xiàn)無關(guān)的方法來表達(dá)業(yè)務(wù)邏輯。

我們知道，通常對(duì)具有集合特征的數(shù)據(jù)結(jié)構(gòu)進(jìn)行遍歷通常可以使用next和hasNext方法，next實(shí)現(xiàn)取下一個(gè)用戶，hasNext判斷是否還有元素。因此我們定義一個(gè)接口Iterator，這個(gè)接口中定義兩個(gè)方法next和hasNext：

public interface Iterator {

public boolean hasNext(){}

public Object next(){}

}

而User類的listUses方法返回值改為Iterator接口的實(shí)現(xiàn)類:

public class User {

...public Iterator listUsers(){

}

...}

這樣就把User類的設(shè)計(jì)和具體的實(shí)現(xiàn)方法分離開了，因?yàn)榇藭r(shí)任何實(shí)現(xiàn)了next()和hasNext()方法的類都可以做為listUsers的返回值，都可以被用來表達(dá)“用戶列表”，而不僅僅可以使用Vector而已。比如，我可以用ArrayList來表達(dá)用戶列表，因?yàn)锳rrayList也實(shí)現(xiàn)了Iterator，當(dāng)然我也可以自己專門寫一個(gè)類來存放用戶列表，只要實(shí)現(xiàn)next()和hasNext()方法就行了。

這樣在具體的編寫代碼的時(shí)候，程序員具有了最大的靈活性，可以根據(jù)具體的情況，采用不同的編程方法來存放用戶列表。特別是降低了程序的耦合度，提高了程序的可移植性。對(duì)于上面那個(gè)JunkMail的listAllMail()方法也同樣應(yīng)該改為接口類型。

然后，在主程序里面就這樣來使用User類的listUsers方法：

User myUser = new User();

Iterator iterator = myUser.listUsers();

while(iterator.hasNext()){

iterator.next();

}

這樣就可以完全不用考慮程序代碼實(shí)現(xiàn)了，從高層次上把功能抽象出來，定義成為接口，同時(shí)又可以把系統(tǒng)設(shè)計(jì)的很合理，完全根據(jù)業(yè)務(wù)的需求來進(jìn)行設(shè)計(jì)。

結(jié)語

通過上面的幾個(gè)例子的設(shè)計(jì)說明，使用面向?qū)ο蟮乃季S方法，其實(shí)是一個(gè)把業(yè)務(wù)邏輯從具體的編程技術(shù)當(dāng)中抽象出來的過程，而這個(gè)抽象的過程是自上而下的，非常符合人類的思維習(xí)慣，也就是先不考慮問題解決的細(xì)節(jié)，把問題的最主要的方面抽象成為一個(gè)簡單的框架，集中精力思考如何解決主要矛盾，然后在解決問題的過程中，再把問題的細(xì)節(jié)分割成一個(gè)一個(gè)小問題，再專門去解決細(xì)節(jié)問題。

因而一旦牢牢的抓住了這一點(diǎn)，你就會(huì)發(fā)現(xiàn)在軟件設(shè)計(jì)和開發(fā)過程中，你自己總是會(huì)不知不覺的運(yùn)用面向?qū)ο蟮乃季S方法來設(shè)計(jì)和編寫程序，并且程序的設(shè)計(jì)和開發(fā)也變得不再那么枯燥，而一個(gè)合理運(yùn)用面向?qū)ο蠹夹g(shù)進(jìn)行設(shè)計(jì)和架構(gòu)的軟件，更是具備了思維的藝術(shù)美感。

最后，愿面向?qū)ο蟮乃季S方法也能給您的程序設(shè)計(jì)之路帶來創(chuàng)作的樂趣。