相关疑难解决方法(0)

我知道有很多关于这两种模式之间差异的帖子,但有一些我找不到的东西.

从我一直在阅读的内容中,我看到工厂方法模式允许您定义如何创建单个具体产品,但是从客户端隐藏实现,因为他们将看到通用产品.我的第一个问题是抽象工厂.它的作用是允许您创建具体对象的族(可能取决于您使用的特定工厂)而不仅仅是单个具体对象？抽象工厂是否只返回一个非常大的对象或许多对象,具体取决于您调用的方法？

我的最后两个问题是关于我在很多地方看到过的单一引言,我无法完全理解:

两者之间的一个区别是,使用抽象工厂模式,类通过组合将对象实例化的责任委托给另一个对象,而工厂方法模式使用继承并依赖子类来处理所需的对象实例化.

我的理解是工厂方法模式有一个Creator接口,它将使ConcreteCreator负责知道要实例化的ConcreteProduct.这是通过使用继承来处理对象实例化的意思吗？

现在关于那个引用,抽象工厂模式究竟是如何通过合成将对象实例化的责任委托给另一个对象？这是什么意思？看起来抽象工厂模式也使用继承来完成构建过程,但是我仍然在学习这些模式.

任何帮助,尤其是最后一个问题,将不胜感激.

什么时候在对象中使用工厂方法而不是Factory类是个好主意？

我正在从网站上阅读设计模式

在那里我读到了有关工厂,工厂方法和抽象工厂的信息,但它们很混乱,我对定义并不清楚.根据定义

Factory - 创建对象而不将实例化逻辑暴露给客户端,并通过公共接口引用新创建的对象.是Factory Method的简化版本

工厂方法 - 定义用于创建对象的接口,但让子类决定实例化哪个类,并通过公共接口引用新创建的对象.

抽象工厂 - 提供用于创建相关对象族的界面,而无需明确指定其类.

我还查看了关于抽象工厂与工厂方法的其他stackoverflow线程,但是那里绘制的UML图使我的理解更加糟糕.

有谁能告诉我

1. 这三种模式如何相互不同？
2. 什么时候用哪个？
3. 如果可能的话,任何与这些模式相关的java示例？

注意:问题在帖子的末尾.

我已经阅读了有关Abstract Factory vs Factory Method的其他stackoverflow线程.我理解每个模式的意图.但是,我不清楚这个定义.

Factory方法定义了一个用于创建对象的接口,但是让子类决定实例化哪些接口.工厂方法允许类将实例化延迟到子类.

相比之下,抽象工厂提供了一个接口,用于创建相关或从属对象的族,而无需指定其具体类.

- John Feminella

该抽象工厂看起来非常相似的工厂方法.我已经绘制了一些UML类来说明我的观点.

注意:

• 该图来自www.yuml.com,因此它们并不完美.但它是免费服务:).
• 图表可能不完美.我还在学习GoF设计模式.

工厂方法:

抽象工厂(仅1名成员):

抽象工厂(更多成员):

问题:

1. 如果抽象工厂只有一个创建者和一个产品,它仍然是抽象工厂模式吗？(创建家庭的界面)
2. 可以从接口创建Factory Method具体创建者还是必须来自类？(类推迟实例化到子类)
3. 如果抽象工厂只能有一个创建者和一个产品,那么抽象工厂和工厂方法之间的唯一区别是前者的创建者是一个接口而后者的创建者是一个类？

大多数定义说:

抽象工厂提供了一个接口,用于创建相关对象的族,而无需指定其具体类

抽象工厂模式的用途是什么,因为我们可以通过创建具体类本身的对象来实现任务.为什么我们有一个工厂方法来创建Concrete类的对象？

请提供我必须实现abstractFactory模式的任何现实生活示例？

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

我的理解是:

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

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

是对的吗？

还有什么区别？

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

什么是工厂,为什么我要使用它？

我刚刚学习了BridgePattern及其意图:将抽象与其实现分离,以便两者可以独立变化.

但为什么不能AbstractFactory做同样的事情呢？

我知道一个AbstractFactory可以创建一个特定的桥梁,但我的问题涉及使用AbstractFactory而不是Bridge解耦抽象和实现.

你能解释一下AbstractFactory和BridgePattern 之间的真正区别吗？

我在 Python 中找到了这个抽象工厂模式的例子。我试图弄清楚为什么需要一个 DogFactory，难道只是调用 Dog 类的代码更少吗，有人可以解释一下这种模式在现实世界的应用程序中将如何有用

class Dog:

    def speak(self):
        return "Woof!"

    def __str__(self):
        return "Dog"


class DogFactory:

    def get_pet(self):
        return Dog()

    def get_food(self):
        return "Dog Food!"


class PetStore:

    def __init__(self, pet_factory=None):

        self._pet_factory = pet_factory


    def show_pet(self):

        pet = self._pet_factory.get_pet()
        pet_food = self._pet_factory.get_food()

        print("Our pet is '{}'!".format(pet))
        print("Our pet says hello by '{}'".format(pet.speak()))
        print("Its food is '{}'!".format(pet_food))

factory = DogFactory()

shop = PetStore(factory)

shop.show_pet()

我是设计模式的初学者.

我正在尝试使用抽象工厂模式,同时保持开放封闭原则.

Plz看下面的代码:

public interface IAbstractFormFactory
    {
        void ShowOSName();        
    }

public class VistaForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Vista");
        }
    }

public class WinXpForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Win XP");
        }
    }

public static class Application
    {
        public static void Run(IAbstractFormFactory factory)
        {
            factory.ShowOSName();
        }
    }

public class Program 
    {
        public static void Main() 
        {
            IAbstractFormFactory form;

            int sys = 0;

            if (sys == 0) 
            {
                form = new WinXpForm();
            } 
            else 
            {
                form = …

我试图理解抽象工厂模式，这是我的第一个近似值：

#include <iostream>
using namespace std;

class Soldier
{
    public:
    virtual void shoot()=0;
};

class Archer: public Soldier
{
    public:
    void shoot(){
        cout<<"Archer shoot"<<endl;
    }
};

class Rider: public Soldier
{
    public:
    void shoot(){
        cout<<"Rider shoot"<<endl;
    }
};

class AbstractFactory
{
    public:
    virtual Soldier* createArcher()=0;
    virtual Soldier* createRider()=0;
};

class OrcFactory: public AbstractFactory
{
    Soldier* createArcher()
    {
        return new Archer();
    };
    Soldier* createRider()
    {
        return new Rider();
    };
};

class HumanFactory: public AbstractFactory
{
    Soldier* createArcher()
    {
        return new Archer(); …