Question

众所周知，AbstractFactory有助于在不了解创建过程的情况下创建对象。但是，当在工厂类中添加新工厂或进行大量修改时，模式的复杂性将会增加。这将需要对抽象工厂创建者类进行大量更改。

我以前使用AbstractFactory，但是我自己修改了＆amp;它是这样的：用空接口替换抽象工厂创建器类，这将由工厂类实现。然后将返回的对象从FactoryCreator类转换为我想要的实际工厂。这有效，但我想知道这是否打破了这种模式，或者这种模式是不好的做法，还是有任何缺点导致未来发展同样复杂？

以下是我从书中获得的模式的一个非常简单的实现。我的修改也是：

塑造工厂：

public interface Shape {
    void draw();
}
public class Circle implements Shape {
    @Override
    public void draw() {
        // Draw circle
    }
}
public class Rectangle implements Shape {
    @Override
    public void draw() {
        // Draw rectangle
    }
}
public class ShapeFactory implements IFactory {
    public Shape getShape(String shape) {
        if (shape.equalsIgnoreCase("CIRLE")) {
            return new Circle();
        } else if (shape.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }

        return null;
    }
}
//public class ShapeFactory extends AbstractFactory {
//    @Override
//    public Color getColor(...) {
//        //
//    }
//    @Override Shape getShape(...) {
//        //
//    }
//}

色彩工厂：

public interface Color {
    void fill();
}
public class Red implements Color {
    @Override
    public void fill() {
        // Fill red
    }
}
public class Green implements Color {
    @Override
    public void fill() {
        // Fill green
    }
}
public class ColorFactory implements IFactory {
    public Color getColor(String color) {
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("GREEN")) {
            return new Green();
        }
    }
}
//public class ColorFactory extends AbstractFactory {
//    @Override
//    public Color getColor(...) {
//        //
//    }
//    @Override Shape getShape(...) {
//        //
//    }
//}

工厂创建者界面：

public interface IFactory { }
//public abstract class AbstractFactory {
//   abstract Color getColor(String color);
//   abstract Shape getShape(String shape) ;
//}

工厂创建者：

public class FactoryCreator {
    public static IFactory getFactory(String factoryName) {
        if (factoryName.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (factoryName.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }

        return null;
    }
}

用法：

public class demo {
    ShapeFactory shapeFactory = (ShapeFactory)FactoryCreator.getFactory("SHAPE");
    ColorFactory colorFactory = (ColorFactory)FactoryCreator.getFactory("COLOR");

    shapeFactory.getShape("CIRCLE").draw();
    shapeFactory.getShape("RECTANGLE").draw();
    colorFactory.getColor("RED").fill();
    colorFactory.getColor("GREEN").fill();
}

Answer 1

设计模式不是对正确事物的保证......你必须首先使用你的头......

历史表明很多人在[xxx]中遇到了一些问题，很多人都可以通过Design-Pattern [yyy]解决问题。这就是desgin模式的演变以及如何定义它们。

你不能说我会实现这个（或那个）模式，无论如何我都没有问题。你必须思考，描述你的问题，看看这种模式是否有助于你设计你的架构。

显然：你的程序实现非常简单，以至于abstractFactory是开销的，你已经使用纯粹的接口解决了这个问题。

好吧，让我们说一下obvoius： AbstractFactory不是您问题的解决方案：

首先：定义你的问题：我想以简单的方式创建参数化对象。 a）参数化形状和颜色和b）简单方法

可能的解决方案：factory-methode（想想：你有两个实现的接口Shape和两个实现的接口Color

public ShapeFactory{
    public static Shape create(String shape){
         if ("CICRCLE".equals(shape)) //your code from above
    }
}

和一家彩色工厂

public ColorFactory{
    public static Color createColor(String color){
        if("GREEN".equals(color) ) // your code from above
    }
}

使用这些设计模式，您可以解决上面定义的问题...（如果您想让它更短，您可以创建一个工厂，为两个接口提供工厂方法）

Answer 2

所以这个问题实质上归结为抽象类和接口之间的区别。

这种观点有很多来源：

see here

您需要了解的模式是，它们被设计为模板用于解决方案。很少有人能够复制粘贴图案而不做任何修改，并期望完美地适应您的问题。

至于你的问题，你能用AbstractFactory接口而不是抽象类来实现FactoryCreator模式吗？

当然可以，这是一个实现细节，不会破坏模式的意图。

Abstract Factory提供了用于创建一系列相关对象的界面，而无需明确指定其类。

修改

您正在查看此模式的一个特定实现，其中作者决定使用抽象类实现模板。

Answer 3

根据我在上述问题中的理解，人们想要创建一个形状，然后在其中填充颜色。如果是这样的话，可以通过在工厂顶部添加Builder模式来使其更好。

class ShapeBuider
{
    private String color;

    private String shape;

    /**
     * @param color the color to set
     */
    public void setColor(String color) {
        this.color = color;
    }

    /**
     * @param shape the shape to set
     */
    public void setShape(String shape) {
        this.shape = shape;
    }

    public void build()
    {
        // create shape
        // create color
        // fill shape with color
    }

    public Object get()
    {
        // return the created object in build method here.
        return null;
    }
}

此构建器方法将确保将正确的颜色应用于正确的形状。

摘要现实生活中的工厂设计模式

3 个答案: