2

我使用 java 库，core负责AbstractFactoryUI 组件。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，但我无法public JList createJList()在 AbstractFactory 中添加，因为我无法修改核心库。

我该怎么办？

案例一： 总是MyFactory.getMyFactoryInstance()在 MyApplication 中调用，新的静态字段。

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

案例二： 总是MyFactory.getMyFactoryInstance()在 MyApplication 中调用，使用 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();

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

4

2 回答 2

1

我将创建一个抽象子类，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();
于 2011-07-20T09:44:12.260 回答
0

由于您需要不同的工厂来构建不同的东西，您是否考虑过合并泛型？

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

只需为您需要创建的每种类型的事物创建一个类型化的工厂。例如：

class JButtonFactory implements Factory<JButton> {
    public JButton create() {
        return new JButton();
    }
}
于 2011-07-20T13:51:50.520 回答