Question

我创建了工厂类，我想知道哪种方法更好。选项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语句，所以在构造函数中我将得到版本并将其保存在类成员上，而不是像

那样使用

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

那么更好的方式或其他想法是什么？

Answer 1

最干净的方法是将你所做的工作暴露为两个独立的工厂，如果他们有什么可分享的话，给他们一个共同的抽象基础或可重用的政策论据。一种工厂类型应该只创建一种特定对象（比如说只有塑料工具）。工厂公共配置通常只包含创建对象（供应商，专利的联系人）或正在创建的对象的静态属性（塑料类型，例如）的所需属性，但不包含对象的类型/类别。

此外，存储长寿命对象的内容（如示例＃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(); }
}

Answer 2

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

Answer 3

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

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

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

Answer 4

这取决于你的情况。

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

虽然第二种选择表明它们的版本可以彼此独立。

Answer 5

首先，您的Factory理想情况下应该static references 而不是non-static一个。它应该有static method到创建/获取 适当的实例。
其次，最好让两个不同的工厂用于不同的工作类型。
第三，我将您的方法命名为createProperty，而不是 getPropertyObject，因为该方法尚未返回创建实例，而不是创建实例。

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

（注意： - 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)

这是创建工厂类的更好方法

5 个答案: