c#设计模式-创建性模式-1.简单工厂、工厂方法、抽象工厂模式

简单工厂模式

现实中的工厂负责生产产品，顾名思义，编程中的简单工厂就是一个生产对象的类，它的主要作用是创建具体的产品类实例。我们以一个生产鼠标为例来分析简单工厂的作用，鼠标有两种：戴尔鼠标和惠普鼠标，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂模式
{
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个Dell鼠标！");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标！");
        }
    }
    public class MouseFactory
    {
        //这里应该从配置文件从读取
        private static readonly string brand = "dell";
        private Mouse mouse = null;
        public Mouse CreateMouse()
        {
            switch (brand)
            {
                case "dell":
                    mouse = new DellMouse();
                    break;
                case "hp":
                    mouse = new HpMouse();
                    break;
                default:
                    break;
            }
            return mouse;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个工厂类
            MouseFactory mouseFactory = new MouseFactory();
            //通过工厂类创建鼠标
            Mouse mouse1 = mouseFactory.CreateMouse();
            Mouse mouse2 = mouseFactory.CreateMouse();
            Mouse mouse3 = mouseFactory.CreateMouse();
            Mouse mouse4 = mouseFactory.CreateMouse();
            Mouse mouse5 = mouseFactory.CreateMouse();
            mouse1.Print();
            Console.ReadKey();
        }
    }
}

很明显简单工厂模式只有一个具体工厂，当厂家有很多时，就办法用了，下面的工厂方法模式可以解决这个问题

工厂方法模式

就是在简单工厂模式上，抽象一个工厂类，把具体生产产品的方法放在子类中实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    //抽象产品类
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个Dell鼠标！");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标！");
        }
    }
    //抽象工厂类
    public abstract class MouseFactory
    {
        public abstract Mouse CreateMouse();
    }
    public class DellMouseFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new DellMouse();
        }
    }
    public class HpMouseFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new HpMouse();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个戴尔工厂类
            MouseFactory dellMouseFactory = new DellMouseFactory();
            Mouse dellMouse = dellMouseFactory.CreateMouse();
            dellMouse.Print();

            //实例化一个惠普工厂类
            MouseFactory HpMouseFactory = new HpMouseFactory();
            Mouse hpMouse = HpMouseFactory.CreateMouse();
            hpMouse.Print();
            Console.ReadKey();
        }
    }
}

如果增加一个苹果厂家生产的鼠标也是比较方便的，如下：

public class AppleMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个苹果鼠标！");
        }
    }
    public class AppleFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new AppleMouse();
        }
    }
    static void Main(string[] args)
        {        
            MouseFactory appleFactory = new AppleFactory();
            Mouse appleMouse = appleFactory.CreateMouse();
            appleMouse.Print();

            Console.ReadKey();
        }

当然工厂方法模式解决了简单模式的问题，但每个工厂不可能只生产一个产品吧，抽象工厂模式可以解决这个问题

抽象工厂模式

抽象工厂模式是为了解决系列产品的问题

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂模式
{
    //抽象产品类
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个戴尔鼠标！");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标！");
        }
    }
    //键盘抽象类
    public abstract class Keybo
    {
        public abstract void Print();
    }

    //戴尔键盘类
    public class DellKeybo : Keybo
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个戴尔键盘！");
        }
    }

    //惠普键盘
    public class HpKeybo : Keybo
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普键盘！");
        }
    }
    //抽象工厂类
    public abstract class AbstractFactory
    {
        public abstract Mouse CreateMouse();
        public abstract Keybo CreateKeybo();
    }
    public class DellFactory : AbstractFactory
    {
        public override Keybo CreateKeybo()
        {
            return new DellKeybo();
        }

        public override Mouse CreateMouse()
        {
            return new DellMouse();
        }
    }
    public class HpFactory : AbstractFactory
    {
        public override Keybo CreateKeybo()
        {
            return new HpKeybo();
        }

        public override Mouse CreateMouse()
        {
            return new HpMouse();
        }
    }   

    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个戴尔工厂类
            AbstractFactory dellFactory = new DellFactory();
            Mouse dellMouse = dellFactory.CreateMouse();
            Keybo dellKeybo = dellFactory.CreateKeybo();
            dellMouse.Print();
            dellKeybo.Print();
            //实例化一个惠普工厂类
            AbstractFactory HpFactory = new HpFactory();
            Mouse hpMouse = HpFactory.CreateMouse();
            Keybo hpKeybo = HpFactory.CreateKeybo();
            hpMouse.Print();
            hpKeybo.Print();

            Console.ReadKey();
        }
    }
}

生产了一个戴尔鼠标！
生产了一个戴尔键盘！
生产了一个惠普鼠标！
生产了一个惠普键盘！

我们可以看出抽象工厂和工厂模式的区别在于：抽象工厂可以生产多种产品（两种：鼠标和键盘），而工厂模式只生产一种产品（键盘），抽象工厂主要时解决生产系列产品的问题。思考一下：如果抽象工厂中只有一种产品是什么情况呢？只有一种产品的抽象工厂其实就是工厂模式，我们可以把工厂模式看作是抽象工厂的一个特例。

抽象工厂模式缺点：在增加新产品时，是不满足开闭原则的。因为我们需要在父类AbstractFactory增加新方法而它的子类也要重写该方法

总结：
简单工厂模式：1个抽象产品类，1个具体工厂类.，1个产品
工厂方法模式：1个抽象产品类，1个抽象工厂类，1个产品
抽象工厂模式：1个抽象产品类，1个抽象工厂类，多个产品

转载：https://www.cnblogs.com/wyy1234/p/9986575.html