java - Java抽象工厂-如何扩展？

我使用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()。

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

案例二：
始终在MyApplication中调用MyFactory.getMyFactoryInstance()，使用强制转换

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

案例三：
使用两个工厂。对于JButton和JLabel，请使用AbstractFactory；对于JList，请使用SomeOtherFactory。

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

案例四：有更好的东西吗？我觉得我忽略了一些东西。

最佳答案

我将创建AbstractFactory的抽象子类，该子类指定createJList()方法并覆盖getInstance()方法，该方法返回新的抽象类类型。然后，您可以在MyFactory类中实现逻辑，并遵守对接口进行编程（在本例中为抽象）而不是实现的原理！

示例代码：

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();

关于java - Java抽象工厂-如何扩展？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/6759485/