chinesefreesexvideos高潮,欧美极品少妇性运交,久久久国产一区二区三区,99久久婷婷国产综合精品,成人国产一区二区三区

1. 什么是代理模1式

抽象點(diǎn)說是一個類代表另一個類的功能，或者說一個對象為另一個對象提供一個代理或者占位符以控制對這個對象的訪問。同樣我也會舉例子來說明，這里我舉一個買車票的例子。通常我們我們買車票需要去車站買，但是這樣會很麻煩，可能要坐很久的車去車站，然后在排隊買票。但是如果我們?nèi)ヒ粋€賣車票的代理點(diǎn)買車票可能就會省去這么多的事情。這樣車票售賣處就代理你購買車票。

2. 代理模式結(jié)構(gòu)

3. 應(yīng)用

下面我們就用具體的代碼來實(shí)現(xiàn)上面這個買車票的靜態(tài)代理。

首先創(chuàng)建一個售票服務(wù)的接口，它有售票咨詢和退票的業(yè)務(wù)可以供客戶選擇。

public interface TicketService {
 //售票
 void sellTicket();
 //咨詢
 void Consultation();
 //退票
 void ReturnTicket();
}

然后創(chuàng)建一個售票服務(wù)接口實(shí)現(xiàn)類，就好比是車站。

public class Station implements TicketService {
 @Override
 public void sellTicket() {
 System.out.println("售票");
 }
 @Override
 public void Consultation() {
 System.out.println("咨詢");
 }
 @Override
 public void ReturnTicket() {
 System.out.println("退票");
 }
}

然后創(chuàng)建一個代理售票點(diǎn)

public class StationProxy implements TicketService {
 private Station station;
 public StationProxy(Station station){
 this.station = station;
 }
 @Override
 public void sellTicket() {
 System.out.println("歡迎使用車票代售點(diǎn)進(jìn)行購票，每張票將會收取5元手續(xù)費(fèi)！");
 station.sellTicket();
 System.out.println("歡迎下次光臨");
 }
 @Override
 public void Consultation() {
 System.out.println("歡迎咨詢，咨詢不收取費(fèi)用");
 station.Consultation();
 System.out.println("歡迎下次光臨");
 }
 @Override
 public void ReturnTicket() {
 System.out.println("歡迎使用車票代售點(diǎn)進(jìn)行退票，每張票將會收取5元手續(xù)費(fèi)！");
 station.ReturnTicket();
 System.out.println("歡迎下次光臨");
 }
}

創(chuàng)建購買車票的角色,去代理點(diǎn)完成購買車票的需求

public class ProxyTest {
 public static void main(String[] args) {
 Station station = new Station();
 StationProxy stationProxy = new StationProxy(station);
 stationProxy.sellTicket();
 }
}

可以看到這個購買車票的客戶是去的車票代理點(diǎn)，直接購買車票，那代理點(diǎn)能否幫助他正常購買到車票呢？請看下面的執(zhí)行結(jié)果

從結(jié)果看到售票代理點(diǎn)成功幫助客戶購買到車票，節(jié)省了客戶去車站排隊等待的時間和精力。代理模式有點(diǎn)像是委派模式中的中介，前面的文章也提到過靜態(tài)代理和策略模式是委派模式的一種組合。那當(dāng)然除了靜態(tài)代理還有動態(tài)代理和CGLIB代理，感興趣的伙伴可以自己去研究研究。

1. 什么是工廠模式

老規(guī)矩先用比較難理解的官方語言來表達(dá)，工廠模式是 Java 中最常用的設(shè)計模式之一。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。在工廠模式中，我們在創(chuàng)建對象時不會對客戶端暴露創(chuàng)建邏輯，并且是通過使用一個共同的接口來指向新創(chuàng)建的對象?，F(xiàn)在在以一個具體的例子來簡單簡化下工廠模式。假如我現(xiàn)在去餐館吃飯，餐館有回鍋肉，有魚，有烤鴨可供我選擇，然后我點(diǎn)餐餐館為我做出具體的菜。說完這個例子下面我也會用代碼來實(shí)現(xiàn)這個例子，給大家簡單理解下工廠模式。

首先我們來創(chuàng)建一個餐館的接口,因?yàn)檫@里只要有做菜就行，所以寫一個cook的方法。

public interface Resaurant {
 void cook();
}

接下來寫三個實(shí)現(xiàn)類，分別是做回鍋肉的，做魚的，做烤鴨的，用這三個實(shí)現(xiàn)類去實(shí)現(xiàn)餐館的接口。

public class Duck implements Resaurant{
 public void cook() {
 System.out.println("來一份烤鴨");
 }
}

public class Fish implements Resaurant{
 public void cook() {
 System.out.println("來一份紅燒魚");
 }
}

public class Meet implements Resaurant {
 public void cook() {
 System.out.println("來一份回鍋肉");
 }
}

現(xiàn)在餐館已經(jīng)具備了做回鍋肉，做魚，做烤鴨的功能，但是客人來了并不知道餐館有這些菜，這時候就需要我們來給餐館做一個菜單，客人來了就可以根據(jù)菜單點(diǎn)餐，這樣就省去了很多的麻煩對不對？

public class Wait {
 public static final int MEAN_MEET = 1;
 public static final int MEAN_FISH = 2;
 public static final int MEAN_DUCK = 3;
 public static Resaurant getMean(int meantype){
 switch (meantype){
 case MEAN_MEET :
 return new Meet();
 case MEAN_FISH :
 return new Fish();
 case MEAN_DUCK :
 return new Duck();
 default:
 return null;
 }
 }
}

菜單也有了，現(xiàn)在客人來了可以點(diǎn)餐了，假如客人根據(jù)菜單點(diǎn)了一份烤鴨，那餐館就可以直接給客人制作一份美味的烤鴨

public class Factory {
 public static void main(String[] args) {
 //簡單工廠模式
 Resaurant resaurant = Wait.getMean(Wait.MEAN_DUCK);
 resaurant.cook();
 }
}

來看看執(zhí)行結(jié)果

通過上面的例子就給大家簡單介紹了一下簡單工廠模式。但是工廠模式除了簡單工廠模式還有工廠方法模式和抽象工廠模式，下面我再已餐館這個例子給大家擴(kuò)展一下工廠方法模式。工廠方法模式就是把簡單工廠中具體的工廠類，劃分成兩層：抽象工廠層+具體的工廠子類層。

首先我們來創(chuàng)建一個抽象工廠類

public abstract class CookFactory {
 public abstract Resaurant createRestaurant();
}

創(chuàng)建兩個具體需要的產(chǎn)品實(shí)現(xiàn)類去繼承上面這個抽象類

public class DuckFactory extends CookFactory {
 @Override
 public Resaurant createRestaurant() {
 return new Duck();
 }
}

public class FishFactory extends CookFactory {
 public Resaurant createRestaurant() {
 return new Fish();
 }
}

烤鴨和魚都做好了，開始享用吧！

public class Cook {
 //工廠方法模式
 public static void main(String[] args) {
 Resaurant duck = new DuckFactory().createRestaurant();
 duck.cook();
 Resaurant fish = new FishFactory().createRestaurant();
 fish.cook();
 }
}

看下執(zhí)行結(jié)果

千呼萬喚始出來，紅燒魚和烤鴨出鍋咯！

2. 優(yōu)點(diǎn)和缺點(diǎn)

優(yōu)點(diǎn)：

• 一個調(diào)用者想創(chuàng)建一個對象，只要知道其名稱就可以了。
• 擴(kuò)展性高，如果想增加一個產(chǎn)品，只要擴(kuò)展一個工廠類就可以。
• 屏蔽產(chǎn)品的具體實(shí)現(xiàn)，調(diào)用者只關(guān)心產(chǎn)品的接口。

缺點(diǎn)：每次增加一個產(chǎn)品時，都需要增加一個具體類和對象實(shí)現(xiàn)工廠，使得系統(tǒng)中類的個數(shù)成倍增加，在一定程度上增加了系統(tǒng)的復(fù)雜度，同時也增加了系統(tǒng)具體類的依賴。這并不是什么好事。

1. 單例模式

所謂單例，通俗來說，就是天上只能有一個太陽，只能有一個月亮，所以結(jié)合到代碼中，就是我們不能每次創(chuàng)建對象都new一個新

的對象供我們使用。所以這個對象應(yīng)該被設(shè)計為共享對象，當(dāng)需要創(chuàng)建時，只需把這個共享對象的引用賦值給變量即可。所謂共享，

即對象被為static object，且共享對象參數(shù)改變時，應(yīng)考慮對其他使用對象的影響，一般不輕易改變共享對象的內(nèi)容。

設(shè)計單例方式并不唯一，應(yīng)該考慮線程安全、效率等，根據(jù)自己的業(yè)務(wù)需求來設(shè)計。下面展示簡單的設(shè)計思想。

2. 單例模式的幾種實(shí)現(xiàn)方式

單例模式的實(shí)現(xiàn)有多種方式，如下所示：

①. 懶漢式，線程不安全

• 是否 Lazy 初始化：是
• 是否多線程安全：否
• 實(shí)現(xiàn)難度：易

描述：這種方式是最基本的實(shí)現(xiàn)方式，這種實(shí)現(xiàn)最大的問題就是不支持多線程。因?yàn)闆]有加鎖 synchronized，所以嚴(yán)格意義上它并不算單例模式。 這種方式 lazy loading 很明顯，不要求線程安全，在多線程不能正常工作。

實(shí)例

public class Singleton {
 private static Singleton instance;
 private Singleton (){
 }
 public static Singleton getInstance() {
 if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
}

②. 懶漢式，線程安全

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實(shí)現(xiàn)難度：易

描述：這種方式具備很好的 lazy loading，能夠在多線程中很好的工作，但是，效率很低，99% 情況下不需要同步。 優(yōu)點(diǎn)：第一次調(diào)用才初始化，避免內(nèi)存浪費(fèi)。 缺點(diǎn)：必須加鎖 synchronized 才能保證單例，但加鎖會影響效率。 getInstance() 的性能對應(yīng)用程序不是很關(guān)鍵（該方法使用不太頻繁）。

實(shí)例

public class Singleton {
 private static Singleton instance;
 private Singleton (){
 }
 public static synchronized Singleton getInstance() {
 if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
}

③. 餓漢式

• 是否 Lazy 初始化：否
• 是否多線程安全：是
• 實(shí)現(xiàn)難度：易

描述：這種方式比較常用，但容易產(chǎn)生垃圾對象。

優(yōu)點(diǎn)：沒有加鎖，執(zhí)行效率會提高。

缺點(diǎn)：類加載時就初始化，浪費(fèi)內(nèi)存。

它基于 classloader 機(jī)制避免了多線程的同步問題，不過，instance 在類裝載時就實(shí)例化，雖然導(dǎo)致類裝載的原因有很多種，在單例模式中大多數(shù)都是調(diào)用 getInstance 方法， 但是也不能確定有其他的方式（或者其他的靜態(tài)方法）導(dǎo)致類裝載，這時候初始化 instance 顯然沒有達(dá)到 lazy loading 的效果。

實(shí)例

public class Singleton {
 private static Singleton instance = new Singleton();
 private Singleton (){
 }
 public static Singleton getInstance() {
 return instance;
 }
}

④. 雙檢鎖/雙重校驗(yàn)鎖（DCL，即 double-checked locking） JDK 版本：JDK1.5 起

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實(shí)現(xiàn)難度：較復(fù)雜

描述：這種方式采用雙鎖機(jī)制，安全且在多線程情況下能保持高性能。 getInstance() 的性能對應(yīng)用程序很關(guān)鍵。

實(shí)例

public class Singleton {
 private volatile static Singleton singleton;
 private Singleton (){
 }
 public static Singleton getSingleton() {
 if (singleton == null) {
 synchronized (Singleton.class) {
 if (singleton == null) {
 singleton = new Singleton();
 }
 }
 }
 return singleton;
 }
}

⑤. 登記式/靜態(tài)內(nèi)部類

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實(shí)現(xiàn)難度：一般

描述：這種方式能達(dá)到雙檢鎖方式一樣的功效，但實(shí)現(xiàn)更簡單。對靜態(tài)域使用延遲初始化，應(yīng)使用這種方式而不是雙檢鎖方式。

這種方式只適用于靜態(tài)域的情況，雙檢鎖方式可在實(shí)例域需要延遲初始化時使用。

這種方式同樣利用了 classloader 機(jī)制來保證初始化 instance 時只有一個線程，它跟第 3 種方式不同的是：第 3 種方式只要

Singleton 類被裝載了，那么 instance 就會被實(shí)例化（沒有達(dá)到 lazy loading 效果），而這種方式是 Singleton 類被裝載了，instance 不一定被初始化。因?yàn)?SingletonHolder 類沒有被主動使用，

只有通過顯式調(diào)用 getInstance 方法時，才會顯式裝載 SingletonHolder 類，從而實(shí)例化 instance。想象一下，如果實(shí)例化 instance 很消耗資源，所以想讓它延遲加載，另外一方面，又不希望在 Singleton 類加載時就實(shí)例化，

因?yàn)椴荒艽_保 Singleton 類還可能在其他的地方被主動使用從而被加載，那么這個時候?qū)嵗?instance 顯然是不合適的。這個時候，這種方式相比第 3 種方式就顯得很合理。

實(shí)例

public class Singleton {
 private static class SingletonHolder {
 private static final Singleton INSTANCE = new Singleton();
 }
 private Singleton (){
 }
 public static final Singleton getInstance() {
 return SingletonHolder.INSTANCE;
 }
}

⑥. 枚舉 JDK 版本：JDK1.5 起

• 是否 Lazy 初始化：否
• 是否多線程安全：是
• 實(shí)現(xiàn)難度：易

描述：這種實(shí)現(xiàn)方式還沒有被廣泛采用，但這是實(shí)現(xiàn)單例模式的最佳方法。它更簡潔，自動支持序列化機(jī)制，絕對防止多次實(shí)例化。

這種方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還自動支持序列化機(jī)制，

防止反序列化重新創(chuàng)建新的對象，絕對防止多次實(shí)例化。不過，由于 JDK1.5 之后才加入 enum 特性，用這種方式寫不免讓人感覺生疏，在實(shí)際工作中，也很少用。 不能通過 reflection attack 來調(diào)用私有構(gòu)造方法。

實(shí)例

public enum Singleton {
 INSTANCE;
 public void whateverMethod() {
 }
}

經(jīng)驗(yàn)之談：一般情況下，不建議使用第 1 種和第 2 種懶漢方式，建議使用第 3 種餓漢方式。只有在要明確實(shí)現(xiàn) lazy loading 效果

時，才會使用第 5 種登記方式。如果涉及到反序列化創(chuàng)建對象時，可以嘗試使用第 6 種枚舉方式。如果有其他特殊的需求，

可以考慮使用第 4 種雙檢鎖方式。

1. 什么是委派模式

這里我以一個簡單的例子來形容，公司有大boss和部門leader以及部門里的員工，現(xiàn)在大boss給部門leader下達(dá)了任務(wù)，而作為部門leader肯定是對任務(wù)進(jìn)行具體的規(guī)劃然后委派給部門里的員工去完成。這中間的關(guān)系就類似于委派模式。作為大boss他可以不知道任務(wù)具體是哪個員工做的，甚至可以不知道員工的存在，只要以結(jié)果為導(dǎo)向，最終能完成任務(wù)就可以。作為部門leader相當(dāng)于一個中介，全程跟進(jìn)員工的工作進(jìn)度，最終像大boss匯報工作。作為員工只要完成任務(wù)可以不知道任務(wù)最終是大boss 下達(dá)的。 接下來就以具體的代碼來實(shí)現(xiàn)這樣一個委派模式的關(guān)系

2. 創(chuàng)建一個員工干活的接口Target

public interface Target {
 public void dosomething(String commond);
}

3. 創(chuàng)建兩個員工類ATarget和BTarget

用這兩個員工去實(shí)現(xiàn)干活的接口，但是現(xiàn)在員工還不知道他具體需要干什么，因?yàn)槭遣块Tleader給他們分配任務(wù)。

A員工的工作類

public class ATarget implements Target {
 //A員工做具體的事情
 @Override
 public void dosomething(String commond) {
 System.out.println("A員工做具體的事情"+commond + "");
 }
}

B員工工作類

public class BTarget implements Target {
 //B員工需要做的事情
 @Override
 public void dosomething(String commond) {
 System.out.println("B員工做具體的事情"+commond);
 }
}

創(chuàng)建一個部門leader的類去實(shí)現(xiàn)Target，用這個leader去給員工分配具體的工作任務(wù)。

public class Leader implements Target {
 //領(lǐng)導(dǎo)委派員工做具體的事情
 private Map target = new HashMap();
 public Leader(){
 //領(lǐng)導(dǎo)委派員工A和員工B分別做不同的事情
 target.put("打印文件", new ATarget());
 target.put("測試項(xiàng)目", new BTarget());
 }
 @Override
 public void dosomething(String commond) {
 target.get(commond).dosomething(commond);
 }
}

接下來就是大boss上場，但是大boss不會去直接給做事的員工下達(dá)命令，而是給leader直接下達(dá)命令,比如下達(dá)一個打印文件的工作。

public class DelegateTest {
 public static void main(String[] args) {
 new Leader().dosomething("打印文件");
 }
}

可以看出來部門leader類是一個至關(guān)重要的類，起到了承上啟下的中介作用，這就是一個委派。然后我們來運(yùn)行程序，來看看大boss沒有給員工直接下達(dá)工作命令，員工能否完成任務(wù)。

可以清楚的看出A員工完成了大boss交給的打印文件的任務(wù)（順利完成任務(wù)，可以去申請加薪了）

從上面可以看出來委派模式就是靜態(tài)代理和策略模式的一種特殊組合，代理模式注重的是過程，委派模式注重的是結(jié)果。策略模式注重的是可擴(kuò)展（外部擴(kuò)展），委派模式注重的是內(nèi)部的靈活和復(fù)用（委派模式以結(jié)果為導(dǎo)向）。

1. 策略模式

策略模式定義了一系列的算法，并將每一個算法封裝起來，而且使他們之間可以相互替換，策略模式可以在不影響客戶端的情況下發(fā)生變化。 策略模式是處理算法不同變體的一種成熟模式，策略模式通過接口或抽象類封裝算法的標(biāo)識，即在接口中定義一個抽象方法，實(shí)現(xiàn)該接口的類將實(shí)現(xiàn)接口中的抽象方法。策略模式把針對一個算法標(biāo)識的一系列具體算法分別封裝在不同的類中，使得各個類給出的具體算法可以相互替換。

策略模式的結(jié)構(gòu)：

• 策略（Strategy）：策略是一個接口，該接口定義若干個算法標(biāo)識，即定義了若干個抽象方法。
• 具體策略（ConcreteStrategy）：具體策略是實(shí)現(xiàn)策略接口的類。具體策略實(shí)現(xiàn)策略接口所定義的抽象方法，即給出算法標(biāo)識的具體算法。
• 上下文（Context）：上下文是依賴于策略接口的類，即上下文包含有策略聲明的變量。上下文中提供了一個方法，該方法委托策略變量調(diào)用具體策略所實(shí)現(xiàn)的策略接口中的方法。

2. 舉例

假如某個游樂場有幾種購買門票的方式，普通的游客是不能享受優(yōu)惠，經(jīng)常來的游客可以辦理年卡享受8折優(yōu)惠，當(dāng)然對于身高在1米2以下的兒童給與了5折的優(yōu)惠。這是游樂場的一種營銷策略。對于這三種營銷策略我們可以使用if else的語句在一個類中就能實(shí)現(xiàn)，可是對于后續(xù)的維護(hù)可能就有其他的麻煩的地方了。如果后面又有更多的優(yōu)惠策略難道我們就不停的加 else語句嗎？這樣就會造成代碼看上去很復(fù)雜，且不容易維護(hù)。說了這些策略模式就可以解決這樣的問題。

3. 實(shí)戰(zhàn)

創(chuàng)建一個策略角色的接口，很簡單的一個接口，寫一個買票的方法。

public interface TicketStrategy {
 void BuyTicket();
}

接下來創(chuàng)建三個具體策略類，對應(yīng)的就是三種購票的方式。

普通的游客購票

public class Normal implements TicketStrategy {
 @Override
 public void BuyTicket() {
 System.out.println("普通游客沒有優(yōu)惠");
 }
}

辦理年卡的用戶購票

public class Vip implements TicketStrategy {
 @Override
 public void BuyTicket() {
 System.out.println("辦年卡游客享受8折優(yōu)惠");
 }
}

1米2以下兒童購票

public class Children implements TicketStrategy {
 @Override
 public void BuyTicket() {
 System.out.println("1米2以下兒童享受5折優(yōu)惠");
 }
}

創(chuàng)建上下文類。

public class Context {
 private TicketStrategy ticketStrategy;
 public Context(TicketStrategy strategy){
 this.ticketStrategy = strategy;
 }
 public void setTicketStrategy(TicketStrategy ticketStrategy) {
 this.ticketStrategy = ticketStrategy;
 }
 public void BuyTicket(){
 this.ticketStrategy.BuyTicket();
 }
}

4. 測試

public class StrategyTest {
 public static void main(String[] args) {
 System.out.println("普通游客策略：");
 Context context = new Context(new Normal());
 context.BuyTicket();
 System.out.println("年卡VIP游客策略：");
 context.setTicketStrategy(new Vip());
 context.BuyTicket();
 System.out.println("1米2以下兒童策略：");
 context.setTicketStrategy(new Children());
 context.BuyTicket();
 }
}

通過上面的例子可以看出這樣寫就能讓代碼很簡潔明了。后面如果有新的售票方式我們只需要創(chuàng)建具體策略類，然后調(diào)用就好了。

5. 優(yōu)點(diǎn)和缺點(diǎn)

優(yōu)點(diǎn)：

• 上下文和具體策略是松耦合關(guān)系。因此上下文只知道它要使用某個實(shí)現(xiàn)Strategy接口類的實(shí)例，但不需要知道具體是哪個類。
• 策略模式滿足“開-閉原則”。當(dāng)增加新的具體策略時，不需要修改上下文類的代碼，上下文就可以引用新的具體策略的實(shí)例。

缺點(diǎn)：通過上面Demo我們會發(fā)現(xiàn)調(diào)用者必須知道所有的策略類，并自行決定使用哪一個策略類。這就意味著客戶端必須理解這些算法的區(qū)別，以便適時選擇恰當(dāng)?shù)乃惴惒⑶矣捎诓呗阅Ｊ桨衙總€具體的策略實(shí)現(xiàn)都單獨(dú)封裝成為類，如果備選的策略很多的話，那么對象的數(shù)目就會很可觀。

1. 原型模式

原型模式是用于創(chuàng)建重復(fù)的對象，同時又能保證性能。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。這種模式是實(shí)現(xiàn)了一個原型接口，該接口用于創(chuàng)建當(dāng)前對象的克隆。當(dāng)直接創(chuàng)建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數(shù)據(jù)庫操作之后被創(chuàng)建。我們可以緩存該對象，在下一個請求時返回它的克隆，在需要的時候更新數(shù)據(jù)庫，以此來減少數(shù)據(jù)庫調(diào)用。 現(xiàn)在我們就用原型模式來模擬復(fù)制東西，來復(fù)制一份個人簡歷。

下面就是某某的求職簡歷

public class Resume implements Cloneable {
 private String name;
 private String birthday;
 private String sex;
 private String school;
 private String timearea;
 private String company;
 public Resume(String name) {
 this.name = name;
 }
 /**
 * @desc 設(shè)定個人基本信息
 * @param birthday 生日
 * @param sex 性別
 * @param school 畢業(yè)學(xué)校
 * @return void
 */
 public void setPersonInfo(String birthday,String sex,String school){
 this.birthday = birthday;
 this.sex = sex;
 this.school = school;
 }
 /**
 * @desc 設(shè)定工作經(jīng)歷
 * @param timearea 工作年限
 * @param company 所在公司
 * @return void
 */
 public void setWorkExperience(String timearea,String company){
 this.timearea = timearea;
 this.company = company;
 }
 /**
 * 克隆該實(shí)例
 */
 public Object clone(){
 Resume resume = null;
 try {
 resume = (Resume) super.clone();
 }
 catch (CloneNotSupportedException e) {
 e.printStackTrace();
 }
 return resume;
 }
 public void display(){
 System.out.println("姓名：" + name);
 System.out.println("生日:" + birthday + ",性別:" + sex + ",畢業(yè)學(xué)校：" + school);
 System.out.println("工作年限:" + timearea + ",公司:" + company);
 }
}

客戶端的驗(yàn)證測試操作

public static void main(String[] args) {
 //原型A對象
 Resume a = new Resume("James");
 a.setPersonInfo("2.16", "男", "家里蹲大學(xué)");
 a.setWorkExperience("2018.09.05", "搬磚工地");
 //克隆B對象
 Resume b = (Resume) a.clone();
 //輸出A和B對象
 System.out.println("----------------A--------------");
 a.display();
 System.out.println("----------------B--------------");
 b.display();
 /*
 * 測試A==B?
 * 對任何的對象x，都有x.clone() !=x，即克隆對象與原對象不是同一個對象
 */
 System.out.print("A==B?");
 System.out.println( a == b);
 /*
 * 對任何的對象x，都有x.clone().getClass()==x.getClass()，即克隆對象與原對象的類型一樣。
 */
 System.out.print("A.getClass()==B.getClass()?");
 System.out.println(a.getClass() == b.getClass());
}

執(zhí)行結(jié)果

2. 總結(jié)

優(yōu)點(diǎn)：

• 性能提高。
• 逃避構(gòu)造函數(shù)的約束。

缺點(diǎn)：

• 配備克隆方法需要對類的功能進(jìn)行通盤考慮，這對于全新的類不是很難，但對于已有的類不一定很容易，特別當(dāng)一個類引用不支持串行化的間接對象，或者引用含有循環(huán)結(jié)構(gòu)的時候。
• 必須實(shí)現(xiàn) Cloneable 接口。

1. 模板模式

定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。 模板方法使得子類可以不改變一個算法的結(jié)構(gòu)即可重定義該算法的某些特定步驟。通俗的說的就是有很多相同的步驟的，在某一些地方可能有一些差別適合于這種模式，如大話設(shè)計模式中說到的考試場景中，每個人的試卷都是一樣的，只有答案不一樣。這種場景就適合于模板方法模式。我這次自己寫的是一個汽車啟動的過程，每一種汽車啟動的過程都基本是一樣的流程，無非是這一過程中存在一些細(xì)小差別。 總的來說，模板模式就是通過抽象類來定義一個邏輯模板，邏輯框架、邏輯原型，然后將無法決定的部分抽象成抽象類交由子類來實(shí)現(xiàn)，一般這些抽象類的調(diào)用邏輯還是在抽象類中完成的。這么看來，模板就是定義一個框架，比如造車子，需要造車輪，車身，發(fā)動機(jī)，車燈等部分組成，不同的車的區(qū)別就在于這些部件的優(yōu)劣而已，但是總少不了這些東西。下面我就用一個例子來造一輛路虎越野車和一輛奧迪轎車。

2. 模板模式實(shí)戰(zhàn)

首先需要創(chuàng)建一個模板抽象父類，將造車需要的模塊創(chuàng)建好。

public abstract class CarTemplate {
 protected String name;
 protected CarTemplate(String name){
 this.name = name;
 }
 protected abstract void buildWheel();
 protected abstract void buildEngine();
 protected abstract void buildCarbody();
 protected abstract void buildCarlight();
 public final void buildCar(){
 buildWheel();
 buildEngine();
 buildCarbody();
 buildCarlight();
 }
}

然后創(chuàng)建一個造路虎車的子類，用這個子類去繼承造車的公有模塊類CarTemplate。然后在方法中完善造路虎車特有的功能，代碼如下：

public class LandRover extends CarTemplate{
 public LandRover(String name) {
 super(name);
 }
 @Override
 protected void buildWheel() {
 System.out.println(name + "越野車輪");
 }
 @Override
 protected void buildEngine() {
 System.out.println(name + "柴油發(fā)動機(jī)");
 }
 @Override
 protected void buildCarbody() {
 System.out.println(name + "SUV越野車型");
 }
 @Override
 protected void buildCarlight() {
 System.out.println(name + "普通車燈");
 }
}

再創(chuàng)建一個造奧迪的子類，同樣用這個子類繼承模板類，并完善造奧迪的方法，代碼如下：

public class Audi extends CarTemplate {
 public Audi(String name) {
 super(name);
 }
 @Override
 protected void buildWheel() {
 System.out.println(name + "的普通轎車車輪");
 }
 @Override
 protected void buildEngine() {
 System.out.println(name + "的汽油發(fā)動機(jī)");
 }
 @Override
 protected void buildCarbody() {
 System.out.println(name + "的豪華舒適性車身");
 }
 @Override
 protected void buildCarlight() {
 System.out.println(name + "的獨(dú)特魔力車燈");
 }
}

2. 測試

public class TemplateTest {
 public static void main(String[] args) {
 CarTemplate car1 = new LandRover("路虎");
 CarTemplate car2 = new Audi("奧迪");
 car1.buildCar();
 car2.buildCar();
 }
}

3. 執(zhí)行結(jié)果

所有步驟都已完成，奧迪和路虎車運(yùn)用統(tǒng)一模板，但是通過在子類中完善各自不同的方法而達(dá)到目的

1. 觀察者模式

觀察者模式也被稱為發(fā)布-訂閱（Publish/Subscribe）模式，它屬于行為型模式的一種。觀察者模式定義了一種一對多的依賴關(guān)系，一個主題對象可被多個觀察者對象同時監(jiān)聽。當(dāng)這個主題對象狀態(tài)變化時，會通知所有觀察者對象并作出相應(yīng)處理邏輯。

2. 觀察者模式包含四個角色

• 抽象被觀察者角色：也就是一個抽象主題，它把所有對觀察者對象的引用保存在一個集合中，每個主題都可以有任意數(shù)量的觀察者。抽象主題提供一個接口，可以增加和刪除觀察者角色。一般用一個抽象類和接口來實(shí)現(xiàn)。
• 抽象觀察者角色：為所有的具體觀察者定義一個接口，在得到主題通知時更新自己。
• 具體被觀察者角色：也就是一個具體的主題，在集體主題的內(nèi)部狀態(tài)改變時，所有登記過的觀察者發(fā)出通知。
• 具體觀察者角色：實(shí)現(xiàn)抽象觀察者角色所需要的更新接口，一邊使本身的狀態(tài)與制圖的狀態(tài)相協(xié)調(diào)。

前面說到觀察者模式也被稱為發(fā)布-訂閱模式，這里我就用一個微信公眾號發(fā)布文章和用戶訂閱公眾號接收文章的例子。用戶訂閱了公眾號就可以接收公眾號發(fā)布的信息文章，當(dāng)用戶對此類型公眾號不感興趣的時候就可以取消訂閱，這時候就接收不到公眾號發(fā)布的文章。用戶就是一個觀察者，公眾號就是被觀察者，被觀察者與觀察者之間的關(guān)系是一對多。接下來我將用具體代碼來實(shí)現(xiàn)這個demo。

3. 具體實(shí)現(xiàn)

①.首先創(chuàng)建一個被觀察者抽象接口,創(chuàng)建注冊觀察者，取消觀察者和提醒所有觀察者更新消息的方法，用途是用戶訂閱、取消訂閱和接收消息。

public interface Observable {
 //注冊觀察者
 void registerObserver(Observer observer);
 //取消觀察者
 void removeObserver(Observer observer);
 //通知所有觀察者更新消息
 void notifyObserver();
}

②.定義一個抽象觀察者接口

public interface Observer {
 void update(String message);
}

③.定義被觀察者，實(shí)現(xiàn)了Observable接口，對Observable接口的三個方法進(jìn)行了具體實(shí)現(xiàn)，同時有一個List集合，用以保存注冊的觀察者，等需要通知觀察者時，遍歷該集合即可。

public class WeChatServer implements Observable{
 private List list;
 private String message;
 public WeChatServer(){
 list = new ArrayList();
 }
 @Override
 public void registerObserver(Observer o) {
 list.add(o);
 }
 @Override
 public void removeObserver(Observer o) {
 if(!list.isEmpty()){
 list.remove(o);
 }
 }
 @Override
 public void notifyObserver() {
 for (int i = 0; i < list.size(); i++){
 Observer observer = list.get(i);
 observer.update(message);
 }
 }
 public void setInfomation(String s){
 this.message = s;
 System.out.println("公眾號推送消息是"+s);
 notifyObserver();
 }
}

④.創(chuàng)建具體的觀察者，這里具體的觀察者也就是用戶。

public class User implements Observer {
 private String name;
 private String message;
 public User(String name) {
 this.name = name;
 }
 @Override
 public void update(String message) {
 this.message = message;
 read();
 }
 public void read(){
 System.out.println(name + "接收到推送消息" + message);
 }
}

⑤.接下來就是具體的測試類，假設(shè)現(xiàn)在有三個用戶訂閱了公眾號，公眾號發(fā)布了一條信息是PHP是世界上最好的語言，此時java開發(fā)工程師李四接收到信息后頗為不滿，于是果斷取消訂閱。后來公眾號又發(fā)布了一條信息是：java是世界上最好的語言，此時取消訂閱的李四已經(jīng)接收不到這條信息了。

public class ObserverTest {
 public static void main(String[] args) {
 WeChatServer server = new WeChatServer();
 Observer userZhang = new User("ZhangSan");
 Observer userLi = new User("LiSi");
 Observer userWang = new User("WangWu");
 server.registerObserver(userZhang);
 server.registerObserver(userLi);
 server.registerObserver(userWang);
 server.setInfomation("PHP是世界上最好用的語言！");
 System.out.println("----------------------------------------------");
 //李四取消訂閱
 server.removeObserver(userLi);
 server.setInfomation("JAVA是世界上最好用的語言！");
 }
}

送個小福利，筆者最近整理了一些Java后端面試題，需要的朋友私信我 【888】 即可免費(fèi)領(lǐng)??！