标签: factory-pattern

我对这三个术语感到很困惑.

我的理解是:

• 在工厂模式中,没有混凝土工厂.工厂根据参数构建新对象.

• 在抽象工厂模式中,有多个混凝土工厂.客户必须明确地创建不同的具体工厂.

是对的吗？

还有什么区别？

此外,什么是工厂方法模式？它与工厂模式相同吗？

不是所有的工厂方法都是静态的吗？产生产品的东西需要状态吗？何时适合实例工厂或静态工厂方法？你能举例说明两者的区别吗？

我正在尝试实现我的第一个工厂设计模式,我不确定在将工厂制造的对象添加到列表时如何避免使用instanceof.这就是我想要做的:

for (ABluePrint bp : bluePrints) {
    AVehicle v = AVehicleFactory.buildVehicle(bp);
    allVehicles.add(v);

    // Can I accomplish this without using 'instanceof'?
    if (v instanceof ACar) {
        cars.add((ACar) v);
    } else if (v instanceof ABoat) {
        boats.add((ABoat) v);
    } else if (v instanceof APlane) {
        planes.add((APlane) v);
    }
}

从我在SO上看到的,使用'instanceof'是代码气味.有没有更好的方法来检查工厂创建的车辆类型而不使用'instanceof'？

我欢迎任何关于我的实施的反馈/建议,因为我不确定我是否正确地采用了这种方式.

完整示例如下:

import java.util.ArrayList;

class VehicleManager {

    public static void main(String[] args) {

        ArrayList<ABluePrint> bluePrints = new ArrayList<ABluePrint>();
        ArrayList<AVehicle> allVehicles = new ArrayList<AVehicle>();
        ArrayList<ACar> cars = new ArrayList<ACar>();
        ArrayList<ABoat> boats = new …

我熟悉这些模式,但仍然不知道如何处理以下情况:

public class CarFactory
{
     public CarFactory(Dep1,Dep2,Dep3,Dep4,Dep5,Dep6)
     {
     }

     public ICar CreateCar(type)
     {
            switch(type)
            {
               case A:
                   return new Car1(Dep1,Dep2,Dep3);
               break;

               case B:
                   return new Car2(Dep4,Dep5,Dep6);
               break;
            }
     }
}

通常,问题在于需要注入的引用量.当有更多的汽车时会更糟.

我想到的第一种方法是在工厂构造函数中注入Car1和Car2,但它违反工厂方法,因为工厂将始终返回相同的对象.第二种方法是注入servicelocator,但它的反模式到处都是.怎么解决？

编辑:

替代方式1:

public class CarFactory
{
     public CarFactory(IContainer container)
     {
        _container = container;
     }

     public ICar CreateCar(type)
     {
            switch(type)
            {
               case A:
                   return _container.Resolve<ICar1>();
               break;

               case B:
                     return _container.Resolve<ICar2>();
               break;
            }
     }
}

替代方式2(由于树中的依赖性过多而难以使用):

public class CarFactory
{
     public CarFactory()
     {
     }

     public ICar CreateCar(type)
     {
            switch(type)
            { …

这是关于工厂模式.我有点困惑.

我看到了createInstance()方法是静态的实现和一些非静态的实现.

有人说这取决于"风格"或"味道",有些人说它没有.维基百科说它应该是非静态的,并且http://www.dofactory.com/Patterns/PatternFactory.aspx也表示它应该是非静态的,根据Gang of Four的说法.

我的问题是:它是否依赖于风格和品味,或者它是否违反了工厂模式,如果它是以静态方式实现的？什么是对的？

我刚读了Factory Method.据我所知,它提供了一种将实例化委托给子类的方法.但我无法理解现实场景中的可能用途.

任何人都可以给出一个典型的例子,展示如何使用Factory方法模式,以便我可以与我所读到的内容相关联.

工厂方法模式是最佳解决方案的问题陈述足以使其清楚.

我目前正在用Python实现Factory设计模式,我有几个问题.

1. 有没有办法阻止实际具体类的直接实例化？例如,如果我有一个生成Vehicle的VehicleFactory,我希望用户只使用该工厂,并防止任何人直接意外地实例化Car()或Truck().我可以在init()中抛出异常,但这也意味着工厂无法创建它的实例......

2. 在我看来,工厂正在上瘾.似乎所有东西都应该成为工厂,这样当我改变内部实现时,客户端代码不会改变.我很想知道什么时候有实际需要使用工厂,什么时候不适合使用.例如,我可能有一个Window类,现在只有这种类型的一个(没有PlasticWindow,ReinforcedWindow或类似的东西).在这种情况下,我是否应该使用工厂为客户端生成Window,以防万一我以后可能会添加更多类型的Windows？

3. 我只是想知道是否有通常的方式来调用工厂.例如,现在我将我的车辆工厂称为车辆,因此代码将类似于Vehicles.create(...).我看到很多教程就像VehicleFactory一样,但我发现它太长了,它也暴露了实现.

编辑:我所说的"暴露实施"是因为它让人们知道它是一个工厂.我觉得客户不需要知道它是一个工厂,而是作为一个可以为你返回对象的类(当然这是一个工厂,但也许没有必要明确告诉客户那个？).我知道这些代码很容易暴露,所以我并不是说"暴露源代码中实现功能的方式".

谢谢!

采用以下经典工厂模式:

public interface IPizza
{
    decimal Price { get; }
}

public class HamAndMushroomPizza : IPizza
{
    decimal IPizza.Price
    {
        get
        {
            return 8.5m;
        }
    }
}
public abstract class PizzaFactory
{
    public abstract IPizza CreatePizza(ItalianPizzaFactory.PizzaType pizzaType);
}

public class ItalianPizzaFactory : PizzaFactory
{
    public enum PizzaType
    {
        HamMushroom,
        Deluxe,
        Hawaiian
    }

    public override IPizza CreatePizza(PizzaType pizzaType)
    {
        switch (pizzaType)
        {
            case PizzaType.HamMushroom:
                return new HamAndMushroomPizza();
            case PizzaType.Hawaiian:
                return new HawaiianPizza();
            default:
                throw new ArgumentException("The pizza type " + pizzaType …

首先请原谅我,如果它是一个非常愚蠢的问题,我只是想学习这种语言的核心.我正在阅读Effective Java,第一章讨论静态工厂方法与构造函数.他们的利弊.很少有令我困惑的事情是:

1. 静态工厂方法返回的对象的类是非公共的 - 这究竟是什么意思？
2. 与构造函数不同,静态工厂方法不需要在每次调用时创建新对象 - 这是如何发生的？我只是为了获取一个新对象而调用工厂方法,我们是否在工厂方法中检查对象是否已经存在？

谢谢.

我正在寻找一个如何实现工厂类的简单示例,但不使用Switch或If-Then语句.我能找到的所有例子都使用一个.例如,如何修改这个简单示例(如下所示),以便实际工厂不依赖于Switch？在我看来,这个例子违反了开/关原则.我希望能够添加具体的类('经理','文员','程序员'等),而无需修改工厂类.

谢谢!

class Program
{
    abstract class Position
    {
        public abstract string Title { get; }
    }

    class Manager : Position
    {
        public override string Title
        {
            get  { return "Manager"; }
        }
    }

    class Clerk : Position
    {
        public override string Title
        {
            get { return "Clerk"; }
        }
    }

    class Programmer : Position
    {
        public override string Title
        {
            get { return "Programmer"; }
        }
    }

    static class Factory
    {
        public static Position Get(int id)
        { …