Java 中的抽象工廠 - 如何擴展？

Question

我使用 java 庫， core ， AbstractFactory負責 UI 組件。 MyApplication 使用核心並自定義 UI。 因此，在 MyApplication 啟動期間，我將 MyFactory 設置為 AbstractFactory 的一個實例。

class AbstractFactory {
  ...
  public static AbstractFactory getInstance();
  public abstract JButon createButton();
  public abstract JLabel createLabel();
  ...
}

class MyFactory extends AbstractFactory {
   ...
}

MyApplication.startup() {
  AbstractFactory.setInstance(new MyFactory())
}

我的問題是，我需要在 MyApplication 中創建例如 JList，但我無法在 AbstractFactory 中添加public JList createJList() ，因為我無法修改核心庫。

我該怎么辦？

案例一：總是在 MyApplication 中調用MyFactory.getMyFactoryInstance() ，新增 static 字段。

class MyFactory extends AbstractFactory {
   private static MyFactory myInstance = new MyFactory();
   public static getMyFactoryInstance() { return myInstance }
   ...
}

案例二：在MyApplication中總是調用MyFactory.getMyFactoryInstance() ，使用cast

class MyFactory extends AbstractFactory {
   public static MyFactory getMyFactoryInstance() { 
       if (getInstance() instanceOf MyFactory) {
           return (MyFactory) getInstance();
       }
       throw Exception();
   }
   ...
}

案例三：使用兩個工廠。 對於 JButton 和 JLabels，使用 AbstractFactory，對於 JList，使用 SomeOtherFactory。

JButton button = AbstractFactory.getInstance().createButton();
JList list = SomeOtherFactory.getInstance.createList();

案例四：更好的東西？ 我覺得我忽略了一些東西。

Answer 1

我將創建AbstractFactory的抽象子類，它指定createJList()方法並覆蓋getInstance()方法，該方法返回新的抽象 class 類型。 然后，您可以在 MyFactory class 中實現邏輯，並遵循接口（在本例中為抽象）而不是實現的編程原則！

示例代碼：

public abstract class MyAbstractFactory extends AbstractFactory {
 //you could implement AbstractFactory's abstract methods here

 public abstract JList createJList();
}

public class MyFactory extends MyAbstractFactory {
 private static MyAbstractFactory instance;

 private MyFactory() {}

 public JList createJList() {
  //implementation of method here
 }
 public static MyAbstractFactory getInstance() {
  if (instance == null) instance = new MyFactory();
  return instance;
 }
}

上面的例子使用了惰性實例化，如果代碼不總是被使用並且沒有在多線程應用程序中使用，這是很好的。 但是，如果它以多線程方式使用，我將使用MyFactory的以下實現，它使用雙重檢查鎖定來處理多個線程。

public class MyFactory extends MyAbstractFactory {
 private volatile static MyAbstractFactory instance;

 private MyFactory() {}

 public JList createJList() {
  //implementation of method here
 }
 public static MyAbstractFactory getInstance() {
  if (instance == null) {
   syncronized(MyFactory.class) {
    if (instance == null) instance = new MyFactory();
   }
  }
  return instance;
 }
}    

無論哪種實現，使用都將保持不變。

用法：

MyAbstractFactory factory = MyFactory.getInstance();
factory.createJList();

Answer 2

既然你需要不同的工廠來建造不同的東西，你有沒有考慮過合並generics？

interface Factory<T> {
  ...
  T create();
  ...
}

只需為您需要創建的每種類型的事物創建一個類型化的工廠。 例如：

class JButtonFactory implements Factory<JButton> {
    public JButton create() {
        return new JButton();
    }
}