Factory模式（工厂模式）

左手的ㄟ右手 2024-03-31 12:19 38阅读 0赞

#### 模式简介 ####

工厂模式主要是用于统一创建对象实例，将对象实例的创建以及一些实例创建过程中与当前访问者所实现的具体业务逻辑无关的工作（例如一些实例创建时默认的初始化）交给工厂来做，所有访问者都采用工厂来获取某个对象的实例则可以使得访问者更加专注于具体业务逻辑的实现，工厂模式通常分为简单工厂和抽象工厂。

#### 模式UML图 ####

![1c3b114ee00c40dfa6eea69f7a64ce13.jpeg][] 简单工厂模式

![e4ef4ce6924f4b6e87b5a31a7cf9e80c.jpeg][] 静态简单工厂模式

![7771e5f3abe045de980dd2b64c8f190f.jpeg][] 简单工厂模式改进

![f1554b6f62cf404fb8c70fc70359cf77.jpeg][] 静态简单工厂模式改进

![31ca52b5d7a0453eaa4c688d81c993a0.jpeg][] 抽象工厂模式

#### 代码示例（C\#） ####

**提示：**可在本栏目的资源篇“[设计模式代码示例合集][Link 1]”下载所有完整代码资源。

//武器静态简单工厂
        public class WeaponFactory
        {
            private WeaponFactory() { }
    
            public static Weapon CreateGun()
            {
                return new Gun();
            }
    
            public static Weapon CreateMagicBroom()
            {
                return new MagicWand();
            }
        }
    
        //交通工具简单工厂
        public class VehicleFactory
        {
            private VehicleFactory() { }
            private class VehicleFactoryHandler
            {
                public static readonly VehicleFactory instance = new VehicleFactory();
            }
    
            public static VehicleFactory GetInstance()
            {
                return VehicleFactoryHandler.instance;
            }
    
            public Car CreateCar()
            {
                return new Car();
            }
    
            public MagicBroom CreateMagicBroom()
            {
                return new MagicBroom();
            }
        }
    
        //抽象工厂————现代工厂，现代工厂用于生产现代世界的物品，继承AbstractFactory
        public class ModernFactory : AbstractFactory
        {
            private ModernFactory() { }
            private class ModernFactoryHandler
            {
                public static readonly ModernFactory instance = new ModernFactory();
            }
    
            public static ModernFactory GetInstance()
            {
                return ModernFactoryHandler.instance;
            }
    
            public override Vehicle CreateVehicle()
            {
                Console.WriteLine("Create one car.");
                return new Car();
            }
    
            public override Weapon CreateWeapon()
            {
                Console.WriteLine("Create one gun.");
                return new Gun();
            }
        }
    
        //抽象工厂————魔法工厂，魔法工厂用于生产魔法世界的物品，继承AbstractFactory
        public class MagicFactory : AbstractFactory
        {
            private MagicFactory() { }
            private class MagicFactoryHandler
            {
                public static readonly MagicFactory instance = new MagicFactory();
            }
    
            public static MagicFactory GetInstance()
            {
                return MagicFactoryHandler.instance;
            }
    
            public override Vehicle CreateVehicle()
            {
                Console.WriteLine("Create one magicbroom.");
                return new MagicBroom();
            }
    
            public override Weapon CreateWeapon()
            {
                Console.WriteLine("Create one magicwand.");
                return new MagicWand();
            }
        }
    
        //具体交通工具————汽车，继承Vehicle
        public class Car : Vehicle
        {
            public override void Start()
            {
                Console.WriteLine("The car started.");
            }
    
            public override void Stop()
            {
                Console.WriteLine("The car braked.");
            }
        }
    
        //具体武器————枪，继承Weapon
        public class Gun : Weapon
        {
            public override void Attack()
            {
                Console.WriteLine("I shoot you with a gun.");
            }
        }
    
        //具体交通工具————魔法扫帚，继承Vehicle
        public class MagicBroom : Vehicle
        {
            public override void Start()
            {
                Console.WriteLine("The magicbroom flight.");
            }
    
            public override void Stop()
            {
                Console.WriteLine("The magicbroom landed.");
            }
        }
    
        //具体武器————魔法棒，继承Weapon
        public class MagicWand : Weapon
        {
            public override void Attack()
            {
                Console.WriteLine("I attacked you with a magicwand.");
            }
        }
    
        //抽象工厂类，定义所有工厂都需要具备的产品线
        public abstract class AbstractFactory
        {
            public abstract Vehicle CreateVehicle();
            public abstract Weapon CreateWeapon();
        }
    
        //抽象类Vehicle，定义所有交通工具都具备的功能
        public abstract class Vehicle
        {
            public abstract void Start();
            public abstract void Stop();
        }
    
        //抽象类Weapon，定义所有武器都具备的功能
        public abstract class Weapon
        {
            public abstract void Attack();
        }
    
        //测试代码
        public void Test()
        {
            //1-1未使用抽象类
            //每一个交通工具需要自己手动创建出来
            Car c = new Car();
            c.Start();
            MagicBroom ap = new MagicBroom();
            ap.Start();
    
            //1-2使用抽象类
            //Car和MagicBroom都是交通工具
            Vehicle vehicle = new Car();
            vehicle.Start();
            vehicle = new MagicBroom();
            vehicle.Start();
    
            //1-3使用简单工厂来创建产品
            VehicleFactory factory = VehicleFactory.GetInstance();
            factory.CreateCar();
            factory.CreateMagicBroom();
    
            //1-4使用静态工厂来创建产品
            WeaponFactory.CreateGun();
            WeaponFactory.CreateMagicBroom();
            Type[] types = { typeof(MagicPower), typeof(Bread), typeof(MagicPower), typeof(Bread) };
            foreach (Type item in types)
            {
                var food = FoodFactory.CreateFood(item);
                if (food != null) food.Eat();
                else Console.WriteLine("Failure to create food.");
            }
    
            //1-5使用抽象工厂来创建产品族
            AbstractFactory absfactory = ModernFactory.GetInstance();
            List<Vehicle> vehicles = new List<Vehicle>();
            List<Weapon> weapons = new List<Weapon>();
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 5; j++)
                {
                    vehicles.Add(absfactory.CreateVehicle());
                    weapons.Add(absfactory.CreateWeapon());
                }
                for (int k = 0; k < vehicles.Count; k++)
                {
                    vehicles[k].Start();
                    weapons[k].Attack();
                    vehicles[k].Stop();
                }
                vehicles.Clear();
            }
        }

#### 代码解说 ####

示例代码中我们需要工厂能够生产武器和交通工具，首先我们采用简单工厂模式来生产交通工具，即上述代码中的交通工具简单工厂，然后我们采用静态简单工厂模式来生产武器，即上述代码中的武器静态简单工厂，二者都能够完成生产任务。但是现在我们又有新的要求，我们需要工厂既能生产现代的武器和交通工具，还要能够生产魔法时代的武器和交通工具，采用简单工厂模式只能够完成一种类型的产品生产，所以这就需要采用抽象工厂模式了。我们定义了抽象工厂类规定了每一个工厂都需要具备的生产线，即生产武器和生产交通工具，然后我们分别定义一个现代工厂和魔法时代工厂，二者继承抽象工厂类，进而使得两个工厂都能够生产武器和交通工具，当然这种工厂模式还存在扩展方面的不足，具体这里就不做探讨了，感兴趣的读者可以自己线下去研究一下。

**如果这篇文章对你有帮助，请给作者点个赞吧！**

[1c3b114ee00c40dfa6eea69f7a64ce13.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/41df8ead3ff649c7827b9652efa29e56.jpeg
[e4ef4ce6924f4b6e87b5a31a7cf9e80c.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/22c8af9621ab44c2910a67c2a7fb1c62.jpeg
[7771e5f3abe045de980dd2b64c8f190f.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a6acd015136740eb9bae9dbfc25d84f3.jpeg
[f1554b6f62cf404fb8c70fc70359cf77.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4dc54f5af9834d0fa1aeb2299234ceb8.jpeg
[31ca52b5d7a0453eaa4c688d81c993a0.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5d5dcf404a4e43d1ad5e8e6d57c526e9.jpeg
[Link 1]: https://blog.csdn.net/hgf1037882434/article/details/128394782