設計模式觀察者模式股票軟體

A. 10 Android常見設計模式：觀察者模式

觀察者模式是一個使用率非常高的模式，它最常用的地方是GUI系統、訂閱——發布系統。因為這個模式的一個重要作用就是解耦，將被觀察者和觀察者解耦，使得它們之間的依賴性更小，甚至做到毫無依賴。以GUI系統來說，應用的UI具有易變性，尤其是前期隨著業務的改變或者產品的需求修改，應用界面也會經常性變化，但是業務邏輯基本變化不大，此時，GUI系統需要一套機制來應對這種情況，使得UI層與具體的業務邏輯解耦，觀察者模式此時就派上用場了。

定義對象間一種一對多的依賴關系，使得每當一個對象改變狀態，則所有依賴於它的對象都會得到通知並被自動更新。

我們以上課鈴聲響起，學生老師上課為例進行說明。

觀察者模式主要的作用就是對象解耦，將觀察者與被觀察者完全隔離，只依賴於Observer和Observable抽象。例如，ListView就是運用了Adapter和觀察者模式使得它的可擴展性、靈活性非常強，而耦合度卻很低，這是設計模式在Android源碼中優秀運用的典範。

B. java 設計模式之 觀察者模式(Observer)

//Subject java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

* 察者模式屬於行為型模式 其意圖是定義對象間的一種一對多的依賴關系

* 當一個對象的狀態發生改變時 所有依賴於它的對象都得到通知並被自動更新

* 在製作系統的過程中 將一個系統分割成一系列相互協作的類有一個常見的副作用

* 需要維護相關對象間的一致性 我們不希望為了維持一致性而使各類緊密耦合

* 因為這樣降低了他們的可充用性 這一個模式的關鍵對象是目標（Subject）和觀察者（Observer）

* 一個目標可以有任意數目的依賴它的觀察者 一旦目標的狀態發生改變 所有的觀察者都得到通知

* 作為對這個通知的響應 每個觀察者都將查詢目標以使其狀態與目標的狀態同步 這種交互也稱為發布 訂閱模式

* 目標是通知的發布者 他發出通知時並不需要知道誰是他的觀察者 可以有任意數據的觀察者訂閱並接收通知

*/

/**

* subject

*目標介面

*/

public interface Subject {

public void addObserver(Observer o);

public void deletObserver(Observer o);

public void notice();

}

//Observer java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*觀察者介面

*/

public interface Observer {

public void update();

}

//Teacher java

package youngmaster model Observer;

import java util Vector;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*目標介面實現

*/

public class Teacher implements Subject {

private String phone;

@SuppressWarnings( unchecked )

private Vector students;

@SuppressWarnings( unchecked )

public Teacher() {

phone = ;

students = new Vector();

}

@SuppressWarnings( unchecked )

@Override

public void addObserver(Observer o) {

students add(o);

}

@Override

public void deletObserver(Observer o) {

students remove(o);

}

@Override

public void notice() {

for (int i = ; i < students size(); i++) { ((Observer) students get(i)) update();

}

}

public void setPhone(String phone) {

this phone = phone;

notice();

}

public String getPhone() {

return phone;

}

}

//Student java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*觀察者介面實現

*/

public class Student implements Observer {

private String name;

private String phone;

private Teacher teacher;

public Student(String name Teacher teacher) { this name = name; this teacher = teacher;

}

public void show() {

System out println( Name: + name + Teacher s phone: + phone);

}

@Override

public void update() {

phone = teacher getPhone();

}

}

//Client java

package youngmaster model Observer;

import java util Vector;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*測試類

*/

public class Client {

/**

* @param args

*/

@SuppressWarnings( unchecked )

public static void main(String[] args) {

Vector students = new Vector();

Teacher teacher = new Teacher();

for (int i = ; i < ; i++) {

Student student = new Student( student + i teacher); students add(student); teacher addObserver(student);

}

teacher setPhone( );

for (int i = ; i < ; i++)

((Student) students get(i)) show();

System out println( ============================ );

teacher setPhone( );

for (int i = ; i < ; i++)

((Student) students get(i)) show();

}

lishixin/Article/program/Java/gj/201311/27566

C. Python設計模式 - 觀察者模式

"""

觀察者模式：又叫發布-訂閱模式。

    它定義了一種一對多的依賴關系，讓多個觀察者對象同時鑒定某一個主題對象。這個主題對象在狀態發生變化時，

會通知所有的觀察者對象，使它們能夠自動更新自己。

觀察者模式所做的工作實際上就是解耦，根據「依賴倒轉原則」，讓耦合的雙方都依賴於抽象，而不是依賴於具體，

從而使得各自的變化都不會影響另一邊的變化。

實際場景中存在的問題：現實中實際觀察者不一定有實現觀察者的通知回調方法。

解決之道：

1、為其封裝一個觀察類出來，實現相應的介面。

2、修改通知類，讓具體觀察者的Notify函數直接去調用相應的介面。

"""

class Subject(object):

    def __init__(self):

        self._observers = []

    def attach(self, observer):

        if observer not in self._observers:

            self._observers.append(observer)

    def detach(self, observer):

        try:

            self._observers.remove(observer)

        except ValueError:

            pass

    def notify(self, modifier=None):

        for observer in self._observers:

            if modifier != observer:

                observer.update(self)

#用法示例

class Data(Subject):

    def __init__(self, name=''):

        Subject.__init__(self)

        self.name = name

        self._data = 0

    @property

    def data(self):

        return self._data

    @data.setter

    def data(self, value):

        self._data = value

        self.notify()

class HexViewer:

    def update(self, subject):

        print('十六進制查看器: 主題 %s 有數據 0x%x' % (subject.name, subject.data))

class DecimalViewer:

    def update(self, subject):

        print('十進制查看器: 主題 %s 有數據 %d' %

              (subject.name, subject.data))

# 用法示例...

def main():

    data1 = Data('Data 1')

    data2 = Data('Data 2')

    view1 = DecimalViewer()

    view2 = HexViewer()

    data1.attach(view1)

    data1.attach(view2)

    data2.attach(view2)

    data2.attach(view1)

    print("設置數據1變數 = 10")

    data1.data = 10

    print("設置數據2變數 = 15")

    data2.data = 15

    print("設置數據1變數 = 3")

    data1.data = 3

    print("設置數據2變數 = 5")

    data2.data = 5

    print("從data1和data2分離HexViewer。")

    data1.detach(view2)

    data2.detach(view2)

    print("設置數據1變數 = 10")

    data1.data = 10

    print("設置數據2變數 = 15")

    data2.data = 15

if __name__ == '__main__':

    main()

D. 設計模式——觀察者模式

在實際的項目開發中，觀察者模式是一個使用頻率非常高的模式，通過它的別名：發布——訂閱模式也能知道它的主要作用就是用來解耦，將觀察者和被觀察者解耦，使它們的依賴性更小。

觀察者模式定義了被觀察者和觀察者之間的一對多的依賴關系，使得每當被觀察者發生改變時，所有訂閱它的觀察者都接到通知並自動更新。

觀察者模式由四個角色組成：

在我們的Android開發中，我們通過監聽聯系人廣播，然後能及時獲得聯系人發出改變的通知，這個就是一個觀察者模式的案例。比如微信公眾號的推送，當微信公眾號的主題者發送一篇文章的時候，就會推送給所有的訂閱者。這里我們就以微信公眾號的例子來演示。

定義抽象訂閱者和具體訂閱者

在上面的抽象訂閱者中，定義了一個update方法用於更新訂閱者的狀態。

定義抽象被訂閱者

在被觀察者中我們定義了三個方法，注冊訂閱者、注銷訂閱者、通知訂閱者。這三個方法中組合進行管理訂閱者。

客戶端使用

運行結果

在上面的例子中， 其實按照我們的正常理解，應該是觀察者添加被觀察者，由觀察者覺得需要觀察誰？這樣的一個邏輯貌似才合理。如果要達成這樣的目的，UML圖就需要進行變動了。是否可以這樣呢？

在Java中通過Observable類和Observer介面實現了觀察者模式。一個Observer對象監視著一個Observable對象的變化，當Observable對象發生變化時，Observer得到通知，就可以進行相應的工作。

Observable被觀察者
Observable被觀察者中提供了setChange()、notifyObservers()兩個方法。

Observer觀察者
Observer通過Observable的addObserver()方法把自己添加到列表列表中。

同樣適用上面的案例，我們來實現以下。

創建觀察者

從上面可以看到，只要實現Observer介面即可完成一個訂閱者類的開發。

創建被觀察者

集成Observable類實現一個被觀察者，然後通過setChanged()設置狀態改變，通過notiflyObservers來通知觀察者改變。

客戶端

結果

使用場景

關聯行為場景，需要注意的是，關聯行為是可拆分的，而不是「組合」關系。事件多級觸發場景。跨系統的消息交換場景，如消息隊列、事件匯流排的處理機制。

優點

缺點

E. 軟體設計模式有哪些

問題一：軟體設計模式主要有哪幾種 創建型模式用來處理對象的創建過程，主要包含以下5種設計模式：
? 工廠方法模式（Factory Method Pattern）
? 抽象工廠模式（Abstract Factory Pattern）
? 建造者模式（Builder Pattern）
? 原型模式（Prototype Pattern）
? 單例模式（Singleton Pattern）
結構型模式用來處理類或者對象的組合，主要包含以下7種設計模式：
? 適配器模式（Adapter Pattern）
? 橋接模式（Bridge Pattern）
? 組合模式（posite Pattern）
? 裝飾者模式（Decorator Pattern）
? 外觀模式（Facade Pattern）
? 享元模式（Flyweight Pattern）
? 代理模式（Proxy Pattern）
行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述，主要包含以下11種設計模式：
? 責任鏈模式（Chain of Responsibility Pattern）
? 命令模式（mand Pattern）
? 解釋器模式（Interpreter Pattern）
? 迭代器模式（Iterator Pattern）
 中介者模式（Mediator Pattern）
? 備忘錄模式（Memento Pattern）
? 觀察者模式（Observer Pattern）
? 狀態模式（State Pattern）
? 策略模式（Strategy Pattern）
? 模板方法模式（Template Method Pattern）
? 訪問者模式（Visitor Pattern）

問題二：軟體開發的設計模式有哪些 最常用的是設計模式是工廠模式或者單例模式。

問題三：什麼是軟體設計模式 你好。
軟體設計模式就是Uml統一建模語言的技巧性概念。主要研究各個類模塊和介面之間的安排與搭配，也是為程序員提供亥流的一個很好的平台。
利用軟體設計模式您可以做出質量更高，代碼更少，擴充更容易的軟體。我個人理解它更像是一個工具箱，可以讓你生產出更漂亮、更簡潔的代碼。
我的回答您還滿意嗎？

問題四：常見的軟體開發模式和設計模式有哪些 MVC
這個是JAVA ee中就經常用到的模式
將數據模型、界面視圖和業務邏輯控制分開的模式在Android開發中體現的最明顯
數據模型一定單獨
界面視圖在布局中實現
業務控制單獨編寫，典型的MVC

問題五：軟體工程中的設計模式都有哪些 Builder模式：比如AlertDialog.Builder。
適配器模式：比如GridView、ListView與Adapter。
命令模式：比如Handler.post。
享元模式：比如Message.obtain。
單例模式：比如InputMethodManager.getInstance。
觀察者模式：比如ContentObserver。
這是一些經常用到的設計模式以及舉例。

問題六：列出幾種軟體開發中常見的設計模式並解釋 設計模式主要分三個類型:創建型、結構型和行為型。

其中創建型有：
一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點
二、Abstract Factory，抽象工廠：提供一個創建一系列相關或相互依賴對象的介面，而無須指定它們的具體類。
三、Factory Method，工廠方法：定義一個用於創建對象的介面，讓子類決定實例化哪一個類，Factory Method使一個類的實例化延遲到了子類。
四、Builder，建造模式：將一個復雜對象的構建與他的表示相分離，使得同樣的構建過程可以創建不同的表示。
五、Prototype，原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型來創建新的對象。

行為型有：

六、Iterator，迭代器模式：提供一個方法順序訪問一個聚合對象的各個元素，而又不需要暴露該對象的內部表示。
七、Observer，觀察者模式：定義對象間一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知自動更新。
八、Template Method，模板方法：定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中，TemplateMethod使得子類可以不改變一個演算法的結構即可以重定義該演算法得某些特定步驟。
九、mand，命令模式：將一個請求封裝為一個對象，從而使你可以用不同的請求對客戶進行參數化，對請求排隊和記錄請求日誌，以及支持可撤銷的操作。
十、State，狀態模式：允許對象在其內部狀態改變時改變他的行為。對象看起來似乎改變了他的類。
十一、Strategy，策略模式：定義一系列的演算法，把他們一個個封裝起來，並使他們可以互相替換，本模式使得演算法可以獨立於使用它們的客戶。
十二、China of Responsibility，職責鏈模式：使多個對象都有機會處理請求，從而避免請求的送發者和接收者之間的耦合關系

十三、Mediator，中介者模式：用一個中介對象封裝一些列的對象交互。
十四、Visitor，訪問者模式：表示一個作用於某對象結構中的各元素的操作，它使你可以在不改變各元素類的前提下定義作用於這個元素的新操作。
十五、Interpreter，解釋器模式：給定一個語言，定義他的文法的一個表示，並定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。
十六、Memento，備忘錄模式：在不破壞對象的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態。
結構型有：
十七、posite，組合模式：將對象組合成樹形結構以表示部分整體的關系，posite使得用戶對單個對象和組合對象的使用具有一致性。
十八、Facade，外觀模式：為子系統中的一組介面提供一致的界面，fa?ade提供了一高層介面，這個介面使得子系統更容易使用。
十九、Proxy，代理模式：為其他對象提供一種代理以控制對這個對象的訪問
二十、Adapter,適配器模式：將一類的介面轉換成客戶希望的另外一個介面，Adapter模式使得原本由於介面不兼容而不能一起工作那些類可以一起工作。
二十一、Decrator，裝飾頂式：動態地給一個對象增加一些額外的職責，就增加的功能來說，Decorator模式相比生成子類更加靈活。......>>

問題七：設計模式都有哪些? 設計模式主要分三個類型:創建型、結構型和行為型。
其中創建型有：
一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點
二、Abstract Factory，抽象工廠：提供一個創建一系列相關或相互依賴對象的介面，而無須指定它們的具體類。
三、Factory Method，工廠方法：定義一個用於創建對象的介面，讓子類決定實例化哪一個類，Factory Method使一個類的實例化延遲到了子類。
四、Builder，建造模式：將一個復雜對象的構建與他的表示相分離，使得同樣的構建過程可以創建不同的表示。
五、Prototype，原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型來創建新的對象。
行為型有：
六、Iterator，迭代器模式：提供一個方法順序訪問一個聚合對象的各個元素，而又不需要暴露該對象的內部表示。
七、Observer，觀察者模式：定義對象間一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知自動更新。
八、Template Method，模板方法：定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中，TemplateMethod使得子類可以不改變一個演算法的結構即可以重定義該演算法得某些特定步驟。
九、mand，命令模式：將一個請求封裝為一個對象，從而使你可以用不同的請求對客戶進行參數化，對請求排隊和記錄請求日誌，以及支持可撤銷的操作。
十、State，狀態模式：允許對象在其內部狀態改變時改變他的行為。對象看起來似乎改變了他的類。
十一、Strategy，策略模式：定義一系列的演算法，把他們一個個封裝起來，並使他們可以互相替換，本模式使得演算法可以獨立於使用它們的客戶。
十二、China of Responsibility，職責鏈模式：使多個對象都有機會處理請求，從而避免請求的送發者和接收者之間的耦合關系
十三、Mediator，中介者模式：用一個中介對象封裝一些列的對象交互。
十四、Visitor，訪問者模式：表示一個作用於某對象結構中的各元素的操作，它使你可以在不改變各元素類的前提下定義作用於這個元素的新操作。
十五、Interpreter，解釋器模式：給定一個語言，定義他的文法的一個表示，並定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。
十六、Memento，備忘錄模式：在不破壞對象的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態。
結構型有：
十七、posite，組合模式：將對象組合成樹形結構以表示部分整體的關系，posite使得用戶對單個對象和組合對象的使用具有一致性。
十八、Facade，外觀模式：為子系統中的一組介面提供一致的界面，fa?ade提供了一高層介面，這個介面使得子系統更容易使用。
十九、Proxy，代理模式：為其他對象提供一種代理以控制對這個對象的訪問
二十、Adapter,適配器模式：將一類的介面轉換成客戶希望的另外一個介面，Adapter模式使得原本由於介面不兼容而不能一起工作那些類可以一起工作。
二十一、Decrator，裝飾模式：動態地給一個對象增加一些額外的職責，就增加的功能來說，Decorator模式相比生成子類更加靈活。
二十二、Bridge，橋模式：將抽......>>

問題八：總共有幾種設計模式？？？ 共有23種
簡單工廠是設計模式中比較簡單的創建型模式
其原理就是創建一個工廠類（介面），客戶端調用的為介面的實現類，來實現代碼的復用與簡單恭耦，其實簡單工廠也是工廠方法模式的一種特殊實現。
推薦你看篇文章，你就會更好的理解。
blog.csdn/ai92/article/details/209198

問題九：軟體設計模式的四個要素 設計模式使人們可以更加簡單方便地復用成功的設計和體系結構。將已證實的技術表述成設計模式也會使新系統開發者更加容易理解其設計思路。模式名稱一個助記名，它用一兩個詞來描述模式的問題、解決方案和效果。命名一個新的模式增加了我們的設計詞彙。設計模式允許我們在較高的抽象層次上進行設計。基於一個模式詞彙表，我們自己以及同事之間就可以討論模式並在編寫文檔時使用它們。模式名可以幫助我們思考，便於我們與其他人交流設計思想及設計結果。找到恰當的模式名也是我們設計模式編目工作的難點之一。問題描述問題存在的前因後果，它可能描述了特定的設計問題，如怎樣用對象表示演算法等。也可能描述了導致不靈活設計的類或對象結構。有時候，問題部分會包括使用模式必須滿足的一系列先決條件。解決方案描述了設計的組成成分，它們之間的相互關系及各自的職責和協作方式。因為模式就像一個模板，可應用於多種不同場合，所以解決方案並不描述一個特定而具體的設計或實現，而是提供設計問題的抽象描述和怎樣用一個具有一般意義的元素組合（類或對象組合）來解決這個問題。效果描述了模式應用的效果及使用模式應權衡的問題。盡管我們描述設計決策時，並不總提到模式效果，但它們對於評價設計選擇和理解使用模式的代價及好處具有重要意義。軟體效果大多關注對時間和空間的衡量，它們也表述了語言和實現問題。因為復用是面向對象設計的要素之一，所以模式效果包括它對系統的靈活性、擴充性或可移植性的影響，顯式地列出這些效果對理解和評價這些模式很有幫助。

問題十：有哪些比較好的設計模式 單例模式：這個是必須會的
觀察者模式：這個最典型的應用就是mvc模式。
flyweight模式：這個也很常用
posite（組合）：這個很常見吧，
適配器模式：這個也很常用，比如我們一般會封裝一些類庫。然後成為我們用起來更方便的類。
其它的還很多的。總共23種。設計模式需要邊學邊用。很多不好理解。等以後覺得自己設計思路不太好了可以再翻翻。

F. 軟體設計模式主要有哪幾種

軟體設計模式主要有以下三大類共23種：

一、創建型模式：

1、工廠方法模式

工廠方法模式的創建是因為簡單工廠模式有一個問題，在簡單工廠模式中類的創建依賴工廠類，如果想要拓展程序，必須對工廠類進行修改，這違背了開閉原則，所以就出現了工廠方法模式，只需要創建一個工廠介面和多個工廠實現類。

子類可以自己決定實例化哪一個工廠類，client類針對抽象介面進行編程，如果需要增加新的功能，繼承工廠介面，直接增加新的工廠類就可以了，創建過程延遲到子類中進行，不需要修改之前的代碼，滿足了開閉原則，達到靈活地生產多種對象。

2、抽象工廠模式

抽象工廠模式是提供一個創建一系列相關或相互依賴對象的介面，而無需指定它們具體的類。區別於工廠方法模式的地方，工廠方法模式是創建一個工廠，可以實現多種對象；而抽象工廠模式是提供一個抽象工廠介面，裡面定義多種工廠，每個工廠可以生產多種對象。

前者的重點在於"怎麼生產"，後者的重點在於"生產哪些"；前者是一個抽象產品類，可以派生出多個具體產品類，後者是多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。

3、單例模式

單例模式能保證一個類僅有一個實例，並提供一個訪問它的全局訪問點，同時在類內部創造單一對象，通過設置許可權，使類外部無法再創造對象。單例對象能保證在一個JVM中，該對象只有一個實例存在。

在創建的時候，省去了new操作符，降低了系統內存的使用頻率，減輕了系統的壓力。同時單例模式保證在一個jvm中僅存在一個實例的好處就在於好比一個軍隊當中只會存在一個最高級別的軍官來指揮整個軍隊，這樣才能保證獨立控制整個過程，否則如果出現多個，肯定會雜亂無序。

4、建造者模式

建造者模式是將一個復雜的構建與其表示相分離，使得同樣的構建過程可以創建不同的表示。在程序當中就是將一些不會變的基本組件，通過builder來進行組合，構建復雜對象，實現分離。

這樣做的好處就在於客戶端不必知道產品內部組成的細節；同時具體的建造者類之間是相互獨立的，對系統的擴展非常有利，滿足開閉原則；由於具體的建造者類是獨立的，因此可以對建造過程逐步細化，而不對其他的模塊產生任何影響。

5、原型模式

原型模式是用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。其實就是將對象復制了一份並返還給調用者，對象需繼承Cloneable並重寫clone()方法。原型模式的思想就是將一個對象作為原型，對其進行復制、克隆，產生一個和原對象類似的新對象。

分為淺復制和深復制，前者是將一個對象復制後，基本數據類型的變數都會重新創建，而引用類型，指向的還是原對象所指向的；後者是將一個對象復制後，不論是基本數據類型還有引用類型，都是重新創建的。

二、結構型模式：

1、適配器模式

適配器模式是使得原本由於介面不兼容而不能一起工作的那些類可以一起工作，銜接兩個不兼容、獨立的介面的功能，使得它們能夠一起工作，適配器起到中介的作用。

2、裝飾模式

裝飾器模式是動態地給一個對象添加一些額外的職責，給一個對象增加一些新的功能，要求裝飾對象和被裝飾對象實現同一個介面，裝飾對象持有被裝飾對象的實例。除了動態的增加，也可以動態的撤銷，要做到動態的形式，不可以用繼承實現，因為繼承是靜態的。

3、代理模式

代理模式是為其他對象提供一種代理以控制對這個對象的訪問，也就是創建類的代理類，間接訪問被代理類的過程中，對其功能加以控制。

它和裝飾器模式的區別在於，裝飾器模式為了增強功能，而代理模式是為了加以控制。代理模式就是多一個代理類出來，替原對象進行一些操作，例如買火車票不一定在火車站買，也可以去代售點。再比如打官司需要請律師，因為律師在法律方面有專長，可以替我們進行操作。

4、外觀模式

外觀模式是為子系統中的一組介面提供一個一致的界面，外觀模式定義了一個高層介面，這個介面使得這一子系統更加容易使用。

在客戶端和復雜系統之間再加一層，提供一個容易使用的外觀層。外觀模式是為了解決類與類之家的依賴關系的，外觀模式就是將他們的關系放在一個Facade類中，降低了類類之間的耦合度，比如搜狐門戶網站，就利用了外觀模式。

5、橋接模式

橋接模式是將抽象部分與實現部分分離，使它們都可以獨立的變化。橋接模式就是把事物和其具體實現分開，使他們可以各自獨立的變化（突然聯想到了mvc模式）。

將抽象化與實現化解耦，使得二者可以獨立變化，就好比現在常說的mvc模式，view和model之間通過control來控制，達到高內聚低耦合來解耦的目的。

6、組合模式

組合模式是將對象組合成樹形結構以表示"部分-整體"的層次結構，組合模式使得用戶對單個對象和組合對象的使用具有一致性。

創建了一個包含自己對象組的類，並提供修改對象組的方法。在系統的文件和文件夾的問題上就使用了組合模式，文件下不可以有對象，而文件夾下可以有文件對象或者文件夾對象。

7、享元模式

享元模式是運用共享技術有效地支持大量細粒度的對象。享元模式的主要目的是實現對象的共享，即共享池，當系統中對象多的時候可以減少內存的開銷，重用現有的同類對象，若未找到匹配的對象，則創建新對象，這樣可以減少對象的創建，降低系統內存，提高效率。

三、行為型模式：

1、策略模式

策略模式是定義一系列的演算法,把它們一個個封裝起來,並且使它們可相互替換，且演算法的變化不會影響到使用演算法的客戶。

為了統一介面下的一系列演算法類（也就是多種策略），用一個類將其封裝起來，使這些策略可動態切換。策略模式屬於行為型模式，是為了使這些策略可以相互切換，是為了選擇不同的行為。

2、模版方法模式

模板方法模式是定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。該模式就是在一個抽象類中，有一個主方法，再定義1...n個方法，可以是抽象的，也可以是實際的方法，定義一個類，繼承該抽象類，重寫抽象方法，通過調用抽象類，實現對子類的調用。

模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟，將一些固定步驟、固定邏輯的方法封裝成模板方法。調用模板方法即可完成那些特定的步驟。

3、觀察者模式

觀察者模式是定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知並被自動更新。

也就是當被觀察者狀態變化時，通知所有觀察者，這種依賴方式具有雙向性，在QQ郵箱中的郵件訂閱和RSS訂閱，當用戶瀏覽一些博客時，經常會看到RSS圖標，簡單來說就是當訂閱了該文章，如果後續有更新，會及時通知用戶。這種現象即是典型的觀察者模式。

4、迭代器模式

迭代器模式是提供一種方法順序訪問一個聚合對象中各個元素,而又無須暴露該對象的內部表示。

在Java當中，將聚合類中遍歷各個元素的行為分離出來，封裝成迭代器，讓迭代器來處理遍歷的任務；使簡化聚合類，同時又不暴露聚合類的內部，在我們經常使用的JDK中各個類也都是這些基本的東西。

5、責任鏈模式

責任鏈模式是避免請求發送者與接收者耦合在一起，讓多個對象都有可能接收請求，將這些對象連接成一條鏈，並且沿著這條鏈傳遞請求，直到有對象處理它為止。有多個對象，每個對象持有對下一個對象的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一對象決定處理該請求。

但是發出者並不清楚到底最終那個對象會處理該請求。在生活中學生進行請假的過程中，會涉及到，學生請假會一級一級往上批，最終處理，具體由誰批准可能不清楚。在程序當中，現在使用的struts攔截器即用到了責任鏈模式。

6、命令模式

命令模式是將一個請求封裝成一個對象，從而使發出者可以用不同的請求對客戶進行參數化。模式當中存在調用者、接收者、命令三個對象，實現請求和執行分開；調用者選擇命令發布，命令指定接收者。

7、備忘錄模式

備忘錄模式是在不破壞封裝性的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態。創建一個備忘錄類，用來存儲原始類的信息；同時創建備忘錄倉庫類，用來存儲備忘錄類，主要目的是保存一個對象的某個狀態，以便在適當的時候恢復對象，也就是做個備份。

在系統當中使用的撤銷操作，即是使用了備忘錄模式，系統可以保存有限次數的文件狀態，用戶可以進行上幾個狀態的恢復，也就是用到了備忘錄模式。

8、狀態模式

狀態模式是允許對象在內部狀態發生改變時改變它的行為。對象具有多種狀態，且每種狀態具有特定的行為。

在網站的積分系統中，用戶具有不同的積分，也就對應了不同的狀態；還有QQ的用戶狀態有幾種狀態，在線、隱身、忙碌等，每個狀態對應不同的操作，而且你的好友也能看到你的狀態。

9、訪問者模式

訪問者模式主要是將數據結構與數據操作分離。在被訪問的類裡面加一個對外提供接待訪問者的介面，訪問者封裝了對被訪問者結構的一些雜亂操作，解耦結構與演算法，同時具有優秀的擴展性。通俗來講就是一種分離對象數據結構與行為的方法。

通過這種分離，可達到為一個被訪問者動態添加新的操作而無需做其它的修改的效果。訪問者模式的優點是增加操作很容易，因為增加操作意味著增加新的訪問者。訪問者模式將有關行為集中到一個訪問者對象中，其改變不影響系統數據結構。

10、中介者模式

中介者模式是用一個中介對象來封裝一系列的對象交互，中介者使各對象不需要顯式地相互引用，從而使其耦合鬆散，而且可以獨立地改變它們之間的交互。

例如，MVC模式中control就是model和view的中介者。與適配器區別在於，適配器是為了兼容不同的介面，而中介者是為了將顯示和操作分離。

11、解釋器模式

解釋器模式是給定一個語言，定義它的文法表示，並定義一個解釋器，這個解釋器使用該標識來解釋語言中的句子，基本也就用在這個范圍內，適用面較窄，例如：正則表達式的解釋等。

參考資料來源：網路-軟體設計模式

G. 你熟悉的設計模式有哪些寫出單例模式的實現代碼

23個設計模式：

根據目的設計模式可以分為創造模式，結構模式和行為模式，創建模式用於處理對象的創建。結構模式用於處理類或對象的組合。

行為模式用於描述類或對象如何交互以及如何分配職責，創建模式用於處理對象的創建。主要包括以下五種設計模式：

工廠方法模式（）

抽象工廠模式（AbstractFactoryPattern）

建造者模式（BuilderPattern）

原型模式（PrototypePattern）

單例模式（SingletonPattern）

結構模式用於處理類或對象的組合，包括以下七個設計模式：

適配器模式（AdapterPattern）

橋接模式（BridgePattern）

組合模式（CompositePattern）

裝飾者模式（DecoratorPattern）

外觀模式（FacadePattern）

享元模式（FlyweightPattern）

代理模式（ProxyPattern）

行為模式描述類或對象如何交互以及它們如何分配職責。它由以下11種設計模式組成：

責任鏈模式（Chain的ResponsibilityPattern）

命令模式（CommandPattern）

解釋器模式（InterpreterPattern）

迭代器模式（IteratorPattern）

中介者模式（MediatorPattern）

備忘錄模式（MementoPattern）

觀察者模式（ObserverPattern）

狀態模式（StatePattern）

策略模式（StrategyPattern）

模板方法模式（TemplateMethodPattern）

訪問者模式（VisitorPattern）

單例模式實現1：

公共類Singleton｛

類共享實例對象

私有靜態單例；單例＝零；

／／私有構造函數

私有Singleton（）｛

系統。出去了。這是單例！！）；

｝

／／獲取單例方法

公共同步靜態單例getInstance（）｛

／／確定共享對象是否為空，如何空一個新對象

If（singleton＝＝null）｛

singleton＝newsingleton（）；

｝

返回單例。

｝

｝

單例模式實現2：

公共類Singleton｛

類共享實例對象實例化

＝newSingleton（）；

／／私有構造函數

私有Singleton（）｛

系統：出去了，這是單例！！）；

｝

／／獲取單例方法

公共靜態單例getInstance（）｛

直接返回共享對象

返回單例。

｝

｝

(7)設計模式觀察者模式股票軟體擴展閱讀：

注意事項：

設計模式主要分三個類型：創建型和行為型。

Singleton：確保一個類只有一個實例，並為其提供一個全局訪問點

AbstractFactory：提供一個介面，用於創建一系列相關或相互依賴的對象，而無需指定它們的具體類。

FactoryMethod：定義一個用於創建對象的介面，並讓子類決定實例化哪個類。工廠方法將類的實例化延遲到子類。

Builder：將復雜對象的構造與其表示分離，使相同的構造過程可以創建不同的表示。

Prototype：指定要使用Prototype實例創建的對象的類型，並復制該原型來創建一個新對象。

Composite：將對象組合成樹狀結構，以表示整體各部分之間的關系。組合使用戶一致地使用單個對象和組合對象。

Facade：為子系統fa中的一組介面提供一致的介面。Ade提供了一個高級介面，使子系統更易於使用。

Proxy：為其他對象提供一個代理，以控制對該對象的訪問

Adapter：將一個介面類轉換為客戶想要的另一個介面類。適配器模式使那些由於介面不兼容而無法一起工作的類一起工作。

Decrator：式比子類化更靈活，可以為對象動態添加一些額外的職責。

Bridge：模式將抽象部分與其實現部分分離，以便它們可以獨立地更改。

Flyweight：享元模式

H. 列出幾種軟體開發中常見的設計模式並解釋

列出幾種軟體開發中常見的設計模式並解釋

設計模式主要分三個類型:創建型、結構型和行為型。

其中創建型有：
一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點
二、Abstract Factory，抽象工廠：提供一個創建一系列相關或相互依賴對象的介面，而無須指定它們的具體類。
三、Factory Method，工廠方法：定義一個用於創建對象的介面，讓子類決定實例化哪一個類，Factory Method使一個類的實例化延遲到了子類。
四、Builder，建造模式：將一個復雜對象的構建與他的表示相分離，使得同樣的構建過程可以創建不同的表示。
五、Prototype，原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型來創建新的對象。

行為型有：

六、Iterator，迭代器模式：提供一個方法順序訪問一個聚合對象的各個元素，而又不需要暴露該對象的內部表示。
七、Observer，觀察者模式：定義對象間一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知自動更新。
八、Template Method，模板方法：定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中，TemplateMethod使得子類可以不改變一個演算法的結構即可以重定義該演算法得某些特定步驟。
九、Command，命令模式：將一個請求封裝為一個對象，從而使你可以用不同的請求對客戶進行參數化，對請求排隊和記錄請求日誌，以及支持可撤銷的操作。
十、State，狀態模式：允許對象在其內部狀態改變時改變他的行為。對象看起來似乎改變了他的類。
十一、Strategy，策略模式：定義一系列的演算法，把他們一個個封裝起來，並使他們可以互相替換，本模式使得演算法可以獨立於使用它們的客戶。
十二、China of Responsibility，職責鏈模式：使多個對象都有機會處理請求，從而避免請求的送發者和接收者之間的耦合關系

十三、Mediator，中介者模式：用一個中介對象封裝一些列的對象交互。
十四、Visitor，訪問者模式：表示一個作用於某對象結構中的各元素的操作，它使你可以在不改變各元素類的前提下定義作用於這個元素的新操作。
十五、Interpreter，解釋器模式：給定一個語言，定義他的文法的一個表示，並定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。
十六、Memento，備忘錄模式：在不破壞對象的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態。
結構型有：
十七、Composite，組合模式：將對象組合成樹形結構以表示部分整體的關系，Composite使得用戶對單個對象和組合對象的使用具有一致性。
十八、Facade，外觀模式：為子系統中的一組介面提供一致的界面，fa?ade提供了一高層介面，這個介面使得子系統更容易使用。
十九、Proxy，代理模式：為其他對象提供一種代理以控制對這個對象的訪問
二十、Adapter,適配器模式：將一類的介面轉換成客戶希望的另外一個介面，Adapter模式使得原本由於介面不兼容而不能一起工作那些類可以一起工作。
二十一、Decrator，裝飾模式：動態地給一個對象增加一些額外的職責，就增加的功能來說，Decorator模式相比生成子類更加靈活。

二十二、Bridge，橋模式：將抽象部分與它的實現部分相分離，使他們可以獨立的變化。
二十三、Flyweight，享元模式
23種設計模式要在這里詳細的都說一遍內容實在太多了啊，推薦你一本好書《軟體秘笈：設計模式那點事》，裡面講解的23中設計模式例子很生動，容易理解，還有JDK中設計模式應用情況，看了收獲挺大的！網路裡面搜「設計模式」，第一條中設計模式網路中就有首推該圖書，瀏覽量在20幾萬以上的，不會錯的。
祝你早日學會設計模式！

軟體設計師 uml分析與設計中常見的設計模式有哪幾種

常用的設計模式有10多種，你可以參考trufun UML2建模工具，有詳細的每一種設計模式的支持，可以直接生成設計模式的相關類圖。官網上有工具免費下載使用。

請說出幾種軟體開發時的設計模式(面試題)

策略模式
代理模式
抽象工廠模式
代理模式之動態代理
單態模式和簡單工廠模式
工廠方法模式
建造模式
門面模式
.......

設計模式是軟體開發中一種常用的方法嗎

是的，設計模式可以極大的減輕代碼的工作量，增加代碼的可維護性、可復用性、靈活性、可擴展性

有哪些在游戲開發中常用到的設計模式

MVC
這個是JAVA ee中就經常用到的模式
將數據模型、界面視圖和業務邏輯控制分開的模式
在Android開發中體現的最明顯
數據模型一定單獨
界面視圖在布局中實現
業務控制單獨編寫，典型的MVC

不要可以強調設計模式，設計模式也不是萬能的，代碼寫多了你就了解了。不要刻意追求用設計模式，選擇合適的方式才是最好的。設計模式也有缺陷，也不是完美的，不要被設計模式所束縛思維。
游戲中常用的設計模式：工廠、單例、代理、觀察者、策略、狀態

方便修改！如果你要我回答你這個問題 我會首先問你一個問題 你的編程基礎有多少？
熟悉或接觸過哪些OO語言 java? C?
對面向對象基礎知識理解有多少了 封裝 繼承 多態等知道多少 它們的通俗意義和根本意義是什麼
最後建議你去學習一下設計模式，深層次的東就是為了組織源碼，建議直接上 《大話設計模式》 《head first設計模式》 《設計模式之禪》 三本，如果沒基礎，建議先看《大話設計模式》
最後！
上面已經問過你了 你是否有java c基礎 如果有，OO思想必定有所提高！，只要你耐心啃得下來，設計模式是一種學習面向對象編程的很好的工具，23種設計模式只是學習的基礎，更重要的是有這個知識後，去看第三方的開源框架的源碼
如pureMVC WeeMVC之類，使用設計模式的知識去理解別人整個框架的架構 從中學習面向對象深層的知識
面向對象表層無非就是封裝對象

erp軟體開發用什麼設計模式比較好

觀辰ERP採用C++ 語言 、SQL資料庫 構建而成，以自主研發的智能平台為核心技術，已形成自主知識產權、獨家、完整、成熟的平台產品及技術體系，為各行業企業提供快捷靈活、隨需應變的信息化定製解決方案。

Android中常用的幾種設計模式

一.單例模式，二.建造者模式，三.觀察者模式 Observer（觀察者），Observable(被觀察者)四.工廠者模式：Factory