AbstractFactory設計模式

Question

我創建了以下示例。這是否遵循AbstractFactory設計模式？

ButtonType.java

public enum ButtonType { 
    WIN, LINUX, MAC 
} 

Button.java

public interface Button { 
    ButtonType getButtonType(); 

    void actionListener(); 
} 

LinuxButton.java

public class LinuxButton implements Button { 

    @Override 
    public ButtonType getButtonType() { 
     return ButtonType.LINUX; 
    } 

    @Override 
    public void actionListener() { 
     System.out.println("Linux Button created"); 

    } 

} 

WinButton.java

public class WinButton implements Button { 

    @Override 
    public ButtonType getButtonType() { 
     return ButtonType.WIN; 
    } 

    @Override 
    public void actionListener() { 
     System.out.println("Window Button Created"); 

    } 

} 

MacButton.java

public class MacButton implements Button { 

    @Override 
    public ButtonType getButtonType() { 
     return ButtonType.MAC; 
    } 

    @Override 
    public void actionListener() { 
     System.out.println("Mac Button Created"); 

    } 

} 

ButtonFactory.java

public interface ButtonFactory { 

    Button createButton(); 
} 

LinuxButtonFactory.java

public class LinuxButtonFactory implements ButtonFactory { 

    @Override 
    public Button createButton() { 
     System.out.println("creating Linux Button"); 
     return new LinuxButton(); 
    } 

} 

WinButtonFactory.java

public class WinButtonFactory implements ButtonFactory { 

    @Override 
    public Button createButton() { 
     System.out.println("creating window Button"); 
     return new WinButton(); 
    } 

} 

MacButtonFactory.java

public class MacButtonFactory implements ButtonFactory { 

    @Override 
    public Button createButton() { 
     System.out.println("Creating MAC Button"); 
     return new MacButton(); 
    } 

} 

AbstractButtonFactory.java

public abstract class AbstractButtonFactory { 

    public static ButtonFactory getButtonFactory(ButtonType bt) { 
     ButtonFactory btnFactory = null; 
     switch (bt) { 
     case WIN: 
      btnFactory = new WinButtonFactory(); 
      break; 
     case LINUX: 
      btnFactory = new LinuxButtonFactory(); 
      break; 
     default: 
      btnFactory = new MacButtonFactory(); 
     } 
     return btnFactory; 
    } 

} 

終於主要CALSS

public class AbstractFactoryObjectDemo { 

    public static void main(String[] args) { 

     ButtonFactory factory = AbstractButtonFactory.getButtonFactory(ButtonType.LINUX); 
     Button linuxButton = factory.createButton(); 
     System.out.println(linuxButton.getButtonType().toString()); 
    } 

} 

我想確認是這種模式遵循AbstractFactory設計模式，如果它不應該怎樣進行的更改？

Answer 1

執行就可以了。你已經抽象出了按鈕和工廠，這是該模式的主要目標。

在實現方面注意：工廠上的getButtonFactory方法非常沒用，您可以簡單地將它從實際工廠中移除所有實現。

當用戶調用抽象工廠的靜態方法時，他已經獲得了工廠的一個實例，並且不必調用該工廠的一個方法，該方法只會返回自己。所以放下這個方法:)

Answer 2

你應該拆分接口

public interface ButtonFactory { 
    ButtonFactory getButtonFactory(ButtonType bt); 
    Button createButton(); 
} 

進入2周不同的人

public interface ButtonFactory { 
    ButtonCreator getButtonFactory(ButtonType bt); 
} 

和

public Button ButtonCreator { 
    Button createButton(); 
} 

第一個創建ButtonCreator（取決於型）和ButtonCreator保持裏面的類型並創建類型爲

的按鈕

：更新

Answer 3

抽象工廠的目的是提供一個接口，用於創建相關對象的族，而不指定具體的類。您現在不需要抽象工廠設計模式，因爲您目前只有一個創建按鈕，但它可能會改變（顯然）。

如果您根據傳遞給getFactory方法的內容創建了其他東西，則此模式會很有用。

要回答你的問題，根據source making，慣用的方式來做到這一點是：

首先，你應該不必每次實施ButtonFactory的getFactory方法。

您可以簡單地從ButtonFactory接口中刪除getButtonFactory方法，但我認爲這個接口是無用的。

我看到兩種可能性，有一個慣用抽象工廠設計模式：

• 讓你的抽象工廠的
  接口（見下面的例子）。

• 使用靜態類是這樣的：
  https://sourcemaking.com/design_patterns/abstract_factory/java/2

MacButtonToolKit：

public class MacButtonToolkit extends AbstractButtonFactory { 
    public Button createButton() { 
     System.out.println("Creating MAC Button"); 
     return new MacButton(); 
    } 

    public SomethingElse createSomethingElse() { 
     return new SomethingElse(); 
    } 
} 

AbstractButtonFactory：

public abstract class AbstractButtonFactory { 
    private static final MacButtonToolkit macButtonToolkit = new MacButtonToolkit(); 
    public static ButtonFactory getFactory(ButtonType bt) { 
     switch (bt) { 
     case MAC: 
      return macButtonToolkit; 
     default: 
      return macButtonToolkit; 
     } 
    } 

    public abstract Button createButton(); 
    public abstract SomethingElse createButton(); 
} 

如果你沒有一個家庭對象來創建，你應該只使用工廠設計模式：

public class ButtonFactory { 
    public Button createButton(ButtonType buttonType) { 
     switch (buttonType) { 
      case MAC: 
      return new MacButton(); 
      default: 
      return new MacButton(); 
     } 
    } 

} 

Answer 4

也許你可以考慮在Bridge和Abstract Factory之間的組合。

想象一下，除了按鈕說ComboBox之外，還需要添加新的圖形項目，或者除Win/Linux/Mac外還有其他平臺。
然後，純抽象工廠將不會靈活，因此可以使用Bridge模式來分離抽象（Button，ComboBox，...）和平臺特定的實現（Win/Linux/Mac）。