0

我已经创建了工厂类，我想知道哪个是更好的实现方式。选项1

public class Factory {

    private IProperty prop;
    public IDoc doc;

    public Factory(int version) {
        switch (version) {
            case '1':   
                prop = new Prop();
                doc = new Docu();
        ...
            case '2':
            prop = new Prop1();
            doc = new Docu1();
        ...
        }
    }

    public IProperty getProperty() {
        return this.prop;
    }

    public IDoc getDoc() {
        return this.doc;
    }
}

我的问题是是否要这样做，即使用接口类型定义成员并打开构造函数，或者每个 get 方法都在构造函数上使用 switch 语句，所以在构造函数中我只会获取版本并保存它在类成员上，而不是例如使用 like

public IProperty getProperty() {
switch (version) {
  case '1':
    prop = new Prop();
  case '2':
    prop = new Prop1();
...

那么更好的方法是什么，或任何其他想法？

4

5 回答 5

5

最干净的方法是将您所做的事情公开为两个独立的工厂，如果它们有任何可共享的内容，则为它们提供一个共同的抽象基础或可重用的策略参数。一种工厂类型应该只创建一种类型的特定对象（比如只有塑料工具）。工厂公共配置通常只包含创建对象所需的属性（供应商的联系人、专利）或正在创建的对象的静态属性（比如说塑料的类型），而不是对象的类型/类别。

此外，在您的示例#1 中存储长寿命对象的东西可能应该称为“上下文”，而不是“工厂”。

下面的代码示例。

public interface IFactory {
  IDoc createDoc();
  IProp createProp();
}

public class Type1Factory implements IFactory {
  @Override public IDoc createDoc() { return new Doc1(); }
  @Override public IProp createProp() { return new Prop1(); }
}
于 2012-11-15T07:45:33.377 回答
0

您的第二种方式总是更好，因为您的get*方法的每个调用者都会收到一个新的对象实例。如果您在构造函数中创建这两个对象，您将不得不处理对象共享问题（如果您在不同的线程中使用这些对象，则更是如此）。

于 2012-11-15T07:25:52.270 回答
0

在您的第一个版本中创建工厂的想法比第二个版本好得多。

理想情况下，它不应该是工厂类的构造函数，而是静态方法。

public class Factory 
{
    public static IProperty getPropertyObject(char version)
    {
        switch (version)
        {
            case '1':
               return new Prop();

            case '2'
               return new Prop1();
        }
    }

    public static IDoc getDocObject(char version)
    {
        switch (version)
        {
            case '1':
               return new Doc();

            case '2'
               return new Doc1();
        }
    }
}
于 2012-11-15T07:26:07.890 回答
0

这取决于你的情况。

第一个选项表明您的IProperty和IDoc有不同的版本，但对于一个版本的每个版本，您都有另一个对应的版本。

而第二种选择表明这些版本可以相互独立。

于 2012-11-15T07:33:05.333 回答
0

  • 首先，理想情况下，您Factory应该拥有static references 而不是non-static一个。它应该有一个static method创建/获取 适当的实例。

  • 其次，最好有两个不同类型的工厂。

  • 第三，我将您的方法命名为createProperty，而不是 getPropertyObject，因为该方法没有返回已经创建的实例，而是它正在创建的实例。

当然，getPropertyObject('1'), 似乎它正在property从持久性存储中获取该版本的 a ，这不是它正在做的事情。它是基于版本创建一个实例。

（注意： -的名称static factory methods很重要。它们是优势之一，它们超过了constructors。因为有了name，你可以猜出它到底是factory method做什么的）

话虽如此，我会说，2nd option所有这些变化都会更好。让createProperty方法决定，它想如何创建instance.

所以，我会像这样修改你的代码： -

public class PropertyFactory {
    private static IProperty prop;

    public static createProperty(char version) {

        switch (version) {
            case '1':
                prop = new Prop();
                break;  // Don't forget a `break` here.
            case '2':
               prop = new Prop1();
               break;

            default:  // do have a default case
               prop = null;
        } 
        return prop;
    }
}

同样，您可以创建一个DocumentFactory来创建一个document object. 命名方法： -createDocument(char version)

于 2012-11-15T07:36:30.687 回答