C++/C#/Java 设计模式之抽象工厂模式

抽象工厂模式是一种创建型设计模式，它提供了一种方式来封装一组具有共同主题的单独工厂。抽象工厂模式通过提供一个超级工厂创建其他工厂的接口，使得客户端使用抽象的接口操作具体对象，从而实现客户端与具体工厂类解耦。

使用C++实现抽象工厂模式（Abstract Factory）

下面是一个使用C++实现抽象工厂模式的例子：

c++ 复制代码

#include <iostream>
#include <string>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual std::string use() = 0;
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual std::string eat() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    std::string use() override {
        return "Using Product A1";
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    std::string use() override {
        return "Using Product A2";
    }
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    std::string eat() override {
        return "Eating Product B1";
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    std::string eat() override {
        return "Eating Product B2";
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂1
class Factory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ProductB1();
    }
};

// 具体工厂2
class Factory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA2();
    }
    AbstractProductB* createProductB() override {
        return new ProductB2();
    }
};

// 客户端代码
void clientCode(AbstractFactory* factory) {
    AbstractProductA* productA = factory->createProductA();
    AbstractProductB* productB = factory->createProductB();

    std::cout << productA->use() << std::endl;
    std::cout << productB->eat() << std::endl;

    delete productA;
    delete productB;
}

int main() {
    AbstractFactory* factory1 = new Factory1();
    AbstractFactory* factory2 = new Factory2();

    std::cout << "Using the products created by Factory 1:" << std::endl;
    clientCode(factory1);

    std::cout << "Using the products created by Factory 2:" << std::endl;
    clientCode(factory2);

    delete factory1;
    delete factory2;

    return 0;
}

运行结果如下所示：

在这个例子中，我们定义了两个抽象产品类AbstractProductA和AbstractProductB，以及两个具体产品类ProductA1和ProductA2、ProductB1和ProductB2。我们还定义了一个抽象工厂类AbstractFactory，以及两个具体工厂类Factory1和Factory2。

客户端代码使用抽象工厂接口来创建具体产品，并使用这些产品。通过使用抽象工厂模式，我们可以在不改变客户端代码的情况下，改变具体工厂类和具体产品类。

使用C#实现抽象工厂模式（Abstract Factory）

csharp 复制代码

namespace Abstract_Factory_Pattern
{
    internal class Program
    {
        public interface ILaptop
        {
            void ShowSpecs();
        }

        public interface IDesktop
        {
            void ShowSpecs();
        }

        // Apple 品牌的产品
        public class AppleLaptop : ILaptop
        {
            public void ShowSpecs()
            {
                Console.WriteLine("Apple Laptop Specifications");
            }
        }

        public class AppleDesktop : IDesktop
        {
            public void ShowSpecs()
            {
                Console.WriteLine("Apple Desktop Specifications");
            }
        }

        // Lenovo 品牌的产品
        public class LenovoLaptop : ILaptop
        {
            public void ShowSpecs()
            {
                Console.WriteLine("Lenovo Laptop Specifications");
            }
        }

        public class LenovoDesktop : IDesktop
        {
            public void ShowSpecs()
            {
                Console.WriteLine("Lenovo Desktop Specifications");
            }
        }

        public interface IComputerFactory
        {
            ILaptop CreateLaptop();
            IDesktop CreateDesktop();
        }

        public class AppleFactory : IComputerFactory
        {
            public ILaptop CreateLaptop()
            {
                return new AppleLaptop();
            }

            public IDesktop CreateDesktop()
            {
                return new AppleDesktop();
            }
        }

        public class LenovoFactory : IComputerFactory
        {
            public ILaptop CreateLaptop()
            {
                return new LenovoLaptop();
            }

            public IDesktop CreateDesktop()
            {
                return new LenovoDesktop();
            }
        }

        static void Main(string[] args)
        {

            // 创建工厂
            IComputerFactory appleFactory = new AppleFactory();
            IComputerFactory lenovoFactory = new LenovoFactory();

            // 创建 Apple 产品的笔记本和台式机
            ILaptop appleLaptop = appleFactory.CreateLaptop();
            IDesktop appleDesktop = appleFactory.CreateDesktop();
            appleLaptop.ShowSpecs();
            appleDesktop.ShowSpecs();

            // 创建 Lenovo 产品的笔记本和台式机
            ILaptop lenovoLaptop = lenovoFactory.CreateLaptop();
            IDesktop lenovoDesktop = lenovoFactory.CreateDesktop();
            lenovoLaptop.ShowSpecs();
            lenovoDesktop.ShowSpecs();
        }
    }
}

运行结果如下所示：

使用Java实现抽象工厂模式

java 复制代码

package src.Design_Patterns;

public class Abstract_Factory_Pattern 
{
    public interface Laptop 
    {
        void showSpecs();
    }
    
    public interface Desktop 
    {
        void showSpecs();
    }

    // Apple 品牌的产品
    public class AppleLaptop implements Laptop {
        @Override
        public void showSpecs() {
            System.out.println("Apple Laptop Specifications");
        }
    }

    public class AppleDesktop implements Desktop {
        @Override
        public void showSpecs() {
            System.out.println("Apple Desktop Specifications");
        }
    }

    // Lenovo 品牌的产品
    public class LenovoLaptop implements Laptop {
        @Override
        public void showSpecs() {
            System.out.println("Lenovo Laptop Specifications");
        }
    }

    public class LenovoDesktop implements Desktop {
        @Override
        public void showSpecs() {
            System.out.println("Lenovo Desktop Specifications");
        }
    }

    public interface ComputerFactory {
        Laptop createLaptop();
        Desktop createDesktop();
    }

    public class AppleFactory implements ComputerFactory {
        @Override
        public Laptop createLaptop() {
            return new AppleLaptop();
        }
    
        @Override
        public Desktop createDesktop() {
            return new AppleDesktop();
        }
    }
    
    public class LenovoFactory implements ComputerFactory {
        @Override
        public Laptop createLaptop() {
            return new LenovoLaptop();
        }
    
        @Override
        public Desktop createDesktop() {
            return new LenovoDesktop();
        }
    }

    public  void test()
    {
        // 创建工厂
        ComputerFactory appleFactory = new AppleFactory();
        ComputerFactory lenovoFactory = new LenovoFactory();

        // 创建 Apple 产品的笔记本和台式机
        Laptop appleLaptop = appleFactory.createLaptop();
        Desktop appleDesktop = appleFactory.createDesktop();
        appleLaptop.showSpecs();
        appleDesktop.showSpecs();

        // 创建 Lenovo 产品的笔记本和台式机
        Laptop lenovoLaptop = lenovoFactory.createLaptop();
        Desktop lenovoDesktop = lenovoFactory.createDesktop();
        lenovoLaptop.showSpecs();
        lenovoDesktop.showSpecs();
    }

    public static void main(String[] args) {
        Abstract_Factory_Pattern afp = new Abstract_Factory_Pattern();
        afp.test();
    }

}

运行结果如下所示：