java設計模式源碼

『壹』 java中常用的設計模式有哪些請詳細說明一下工廠模式。

1.單例模式（有的書上說叫單態模式其實都一樣）
該模式主要目的是使內存中保持1個對象
2.工廠模式
該模式主要功能是統一提供實例對象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
這個是最簡單的例子了，就是通過工廠方法通過介面獲取對象的引用
3.建造模式
該模式其實就是說，一個對象的組成可能有很多其他的對象一起組成的，比如說，一個對象的實現非常復雜，有很多的屬性，而這些屬性又是其他對象的引用，可能這些對象的引用又包括很多的對象引用。封裝這些復雜性，就可以使用建造模式。
4.門面模式
這個模式個人感覺像是Service層的一個翻版。比如Dao我們定義了很多持久化方法，我們通過Service層將Dao的原子方法組成業務邏輯，再通過方法向上層提供服務。門面模式道理其實是一樣的。
5.策略模式
這個模式是將行為的抽象，即當有幾個類有相似的方法，將其中通用的部分都提取出來，從而使擴展更容易。

『貳』 Java 23 種設計模式的通俗解釋，看完秒懂

以下是Java中23種設計模式的通俗解釋：

1. 工廠方法模式：

   • 解釋：就像請MM吃飯，你可以選擇麥當勞或肯德基，兩者都提供雞翅，但具體實現不同。顧客無需關心餐廳的內部細節，只需點餐，餐廳負責提供對應的產品。這實現了客戶與具體產品工廠的分離，產品修改隻影響工廠。

2. 建造者模式：

   • 解釋：使用翻譯機為MM翻譯「我愛你」，不同語言對應不同的按鍵組合。建造者模式就像這個翻譯過程，通過一步步構建，最終完成跨語言的情感表達，且構造過程清晰明了。

3. 抽象工廠模式：

   • 解釋：在麥當勞選擇漢堡時，顧客只需選擇想要的漢堡類型，無需記憶所有的漢堡選項和製作過程。工廠負責提供具體的漢堡產品，實現了客戶與具體產品的解耦。

4. 原型模式：

   • 解釋：就像用QQ上的情話原型快速復制深情話語，原型模式通過復制現有對象來創建新對象，從而簡化聊天內容的准備過程。

5. 單態模式：

   • 解釋：在婚姻關系中，一個老公對應多個稱呼，但身份本質上是唯一的。單態模式確保一個類只有一個實例，並提供全局訪問點。

6. 適配器模式：

   • 解釋：為MM翻譯粵語時，通過適配器將粵語翻譯成普通話，使雙方能夠順暢交流。適配器模式將一個類的介面轉換成客戶端期望的另一個介面，實現介面之間的兼容。

7. 橋梁模式：

   • 解釋：問候MM時，根據不同時間段和場合使用不同的語言表達，橋梁模式將問候語的外觀與實現解耦，使代碼更加靈活。

8. 合成模式：

   • 解釋：將T恤、裙子和包組合成一套搭配，合成模式允許將簡單對象組合成復雜對象，同時保持這些對象的一致性。

9. 裝飾模式：

   • 解釋：為手機預設常用句子，方便發送簡訊。裝飾模式在不改變對象自身的基礎上，給對象添加新的功能，實現功能的動態擴展。

10. 門面模式：

    • 解釋：相機設置為自動模式，簡化操作步驟，使不熟悉攝影的人也能輕松拍照。門面模式提供一個統一的介面，用來訪問子系統中的一群介面，簡化客戶端與子系統之間的交互。

11. 享元模式：

    • 解釋：在手機中存儲常用句子，根據上下文發送。享元模式通過共享對象來減少內存佔用，提高系統性能，特別適用於大量細粒度對象的場景。

12. 代理模式：

    • 解釋：編寫程序代理MM在網聊中回答常見問題，提高交互效率。代理模式為其他對象提供一種代理以控制對這個對象的訪問。

13. 責任鏈模式：

    • 解釋：傳遞紙條提出求婚條件，直至找到願意處理的人。責任鏈模式將請求沿著處理者鏈進行傳遞，直到有一個處理者處理該請求。

14. 命令模式：

    • 解釋：通過紙條傳遞求婚指令，確保指令的獨立性和可撤消性。命令模式將請求封裝成對象，以便使用不同的請求、隊列或者日誌請求來參數化客戶端。

15. 解釋器模式：

    • 解釋：《泡MM真經》作為腳本，解釋泡MM的策略。解釋器模式給定一個語言，定義它的文法的一種表示，並定義一個解釋器，該解釋器使用該表示來解釋語言中的句子。

16. 迭代模式：

    • 解釋：求婚時逐步提出條件，通過迭代的方式簡化決策過程。迭代模式是一種遍歷訪問集合元素的模式，能夠順序訪問一個集合中的各個元素，而不暴露該對象的內部表示。

17. 調停者模式：

    • 解釋：在MM之間調解財務糾紛，確保公平分配。調停者模式用一個中介對象來封裝一系列對象的交互，使這些對象不需要顯式地相互引用。

18. 備忘錄模式：

    • 解釋：記錄與MM的對話，方便日後查閱，避免誤解。備忘錄模式在不破壞封裝性的前提下，捕獲並保存對象的內部狀態，以便將來可以恢復到這個狀態。

19. 觀察者模式：

    • 解釋：加入公司MM情報組，實時接收信息。觀察者模式定義對象間的一種一對多的依賴關系，當一個對象改變狀態時，其所有依賴者都會收到通知並自動更新。

20. 狀態模式：

    • 解釋：根據MM的不同狀態調整約會策略。狀態模式允許對象在內部狀態改變時改變它的行為，對象看起來似乎修改了它的類。

21. 策略模式：

    • 解釋：為不同類型的MM准備不同策略。策略模式定義了一系列的演算法，並將每一個演算法封裝起來，使它們可以互換，策略模式讓演算法獨立於使用它的客戶端而變化。

22. 模板方法模式：

    • 解釋：約會過程遵循經典步驟，但具體實現根據情況調整。模板方法模式在一個方法中定義一個演算法的骨架，而將一些步驟延遲到子類中實現。

23. 訪問者模式：

    • 解釋：為每個MM准備個性化的禮物。訪問者模式使得在不修改對象結構的情況下，可以擴展操作集合。它為復雜對象結構中的元素提供了一種機制，通過訪問者介面，可以針對對象結構中的元素執行不同的操作。

這些解釋旨在以通俗易懂的方式闡述Java中的設計模式，希望能幫助讀者快速理解這些概念。

『叄』 java中設計模式中Control、View之間的調用

我覺得你弄錯了C和V的關系，應該是這樣的：
Control a=new Control();
View b=new View();
b.setSomeListenner(a);
然後，視圖b在觸發某些事件的時候，比如某個按鈕被點擊的時候，去調用a的相關方法。

另外樓上說的也行得通，把view當做參數傳回去就行嘛。

『肆』 java中的單例模式的代碼怎麼寫

單例模式(Singleton) ,屬於最常見的設計模式之一，大部分系統都會用到，目的是為了維護系統中唯一的一個實例。
可分為eager模式，示例代碼如下：
Java代碼
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代碼如下：
Java代碼
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源碼中，Runtime.getRuntime()就是單例的一個例子。
單例模式的精神就是整個系統中維護一個實例，推廣開來，如果在一個系統中需要維護多個示例，那麼就產生了多例模式(multiton)。
多例模式(Multiton) ,通過聚集對象了保留自身的多個示例，根據客戶端的參數返回所需要的實例。
示例代碼如下：
Java代碼
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一個實用的例子就是KeyGenerator, 示例代碼如下：
Java代碼
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}