/* 抽象产品 */ public abstract class Product { public abstract void show(); } ProductA.java： /* 具体产品A：外卖 */ public class ProductA extends Product { @Override public void show() { System.out.println("外卖制作出来了"); } } ProductB.java： /* 具体产品B：烤外卖 */ public class ProductB extends Product { @Override public void show() { System.out.println("烤外卖做出来了"); } }为什么要用简单工厂模式

使用简单工厂模式有以下几个优点：

1. 将对象的创建和使用分离，客户端无需知道具体的产品类，只需要知道对应的产品类型即可。

2. 简化了客户端的使用，客户端不再需要负责对象的创建，只需要调用工厂方法即可。

3. 可以对产品类的实现进行封装，客户端只需要知道产品的抽象类或接口即可，无需关心具体实现细节。

4. 可以根据需要动态地改变产品类的创建方式，只需要修改工厂类即可，而客户端代码不需要做任何修改。

综上所述，使用简单工厂模式可以提高代码的可维护性、可扩展性和可重用性，是一种非常实用的设计模式。

相关问题

public class TofuShop { private static volatile TofuShop tofuShop; /** * 构造器私有化 */ private TofuShop() { } /* 静态内部类，该类中有一个静态属性Factory */ private static class TofuShopInstance { private static final TofuShop TOFU_SHOP = new TofuShop(); } /** * 提供一个静态的公有方法 * * @return 直接返回FactoryInstance.factory */ public static synchronized TofuShop getTofuShop() { return TofuShopInstance.TOFU_SHOP; } /** * 工厂加工 * */ public Product make(String ProductName) { switch (ProductName) { case "A": return new ProductA(); case "B": return new ProductB(); default: return null; } } }为什么要用单例模式

单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在某些情况下，我们需要确保一个类只有一个实例存在，例如数据库连接池、线程池等资源池。如果我们使用多个实例，则会浪费系统资源，降低系统性能。此外，单例模式还可以用来控制某些全局变量的访问和修改，保证系统的安全性和稳定性。在上面的代码中，TofuShop类是一个工厂类，通过getTofuShop()方法获取TofuShop的唯一实例，然后通过make()方法生产不同种类的产品。通过单例模式，我们可以确保TofuShop类在整个系统中只有一个实例存在，避免了资源的浪费和系统性能的下降。

优化代码#include <iostream> #include<memory> #include<string> using namespace std; class Factory { public: virtual void makeProduct(string st) = 0; protected: Product* product; }; class Factory1 : public Factory { public: void makeProduct(string st) { cout << "工厂1创建"+st; } }; class Factory2 : public Factory { public: void makeProduct(string st) { cout << "工厂2创建"+st; } }; class Product{ public: void setFactory(Factory* fac) { this->factory = fac; }; virtual void Show() = 0; protected: Factory* factory; }; class ProductA : public Product { public: void Show() { string st="产品A"; this->factory->makeProduct(st); }; }; class ProductB : public Product { public: void Show() { string st = "产品B"; this->factory->makeProduct(st); } }; int main() { Factory* factory1; Product* productA; productA = new ProductA; factory1 = new Factory1; productA->setFactory(factory1); return 0; }

这段代码看起来已经是一个比较完整的工厂模式了，不过还有一些可以优化的地方。

1. 使用工厂函数代替工厂类

工厂类在这里只有一个纯虚函数，可以直接使用函数来代替。

2. 使用智能指针避免内存泄漏

在代码中使用了 new 操作符来分配内存，需要手动释放，容易造成内存泄漏。可以使用智能指针来自动管理内存，避免这个问题。

3. 将 string 字符串传参改为 const 引用

在代码中，每次传递 string 字符串时都会进行复制，可以使用 const 引用来避免这个问题。

下面是优化后的代码：

#include <iostream>
#include <memory>

using namespace std;

class Product {
public:
    virtual void Show() = 0;
};

class ProductA : public Product {
public:
    void Show() override {
        cout << "产品A" << endl;
    }
};

class ProductB : public Product {
public:
    void Show() override {
        cout << "产品B" << endl;
    }
};

using FactoryFunction = unique_ptr<Product> (*)();

unique_ptr<Product> Factory1() {
    return make_unique<ProductA>();
}

unique_ptr<Product> Factory2() {
    return make_unique<ProductB>();
}

int main() {
    auto productA = Factory1();
    auto productB = Factory2();
    productA->Show();
    productB->Show();
    return 0;
}

在优化后的代码中，使用了智能指针来管理内存，使用了工厂函数来代替工厂类，并且将传递字符串的方式改为了 const 引用。这样可以更好地提高代码的可读性和可维护性。