设计模式之简单工厂

一、简单工厂：为了客户类和服务类之间的解耦，把对象的创建任务交给第三方类，这个第三方类就充当工厂的作用，严格来说简单工厂不属于23种设计模式之一。

二、实现思路 ：创建一个简单工厂类，根据客户端要求（参数）调用类方法创建对象后返回给调用对象。

三、代码举例：

抽象类Human：

namespace SimpleFactory
{
    public abstract class Human
    {
        public abstract void Study();
        public abstract void Eat();
        public abstract void Sleep();
        public abstract void Play();   
    }
}

 

  实现了human抽象类的对象AmeriCan：

 namespace SimpleFactory
{
   public  class AmeriCan: Human
    {
        public override void Eat()
        {
            Console.WriteLine("美国人-吃东西");
        }

        public override void Play()
        {
            Console.WriteLine("美国人-玩游戏");
        }

        public override void Sleep()
        {
            Console.WriteLine("美国人-睡觉");
        }

        public override void Study()
        {
            Console.WriteLine("美国人-学习");
        }
    }
}

  实现了human抽象类的对象ChineseMan

namespace SimpleFactory
{
   public  class ChineseMan : Human
    {
        public override void Eat()
        {
            Console.WriteLine("中国人-吃东西");
        }

        public override void Play()
        {
            Console.WriteLine("中国人-玩游戏");
        }

        public override void Sleep()
        {
            Console.WriteLine("中国人-睡觉");
        }

        public override void Study()
        {
            Console.WriteLine("中国人-学习");
        }
    }
}

  实现了human抽象类的对象FrenchMan：

namespace SimpleFactory
{
   public  class FrenchMan : Human
    {
        public override void Eat()
        {
            Console.WriteLine("法国人-吃东西");
        }

        public override void Play()
        {
            Console.WriteLine("法国人-玩游戏");
        }

        public override void Sleep()
        {
            Console.WriteLine("法国人-睡觉");
        }

        public override void Study()
        {
            Console.WriteLine("法国人-学习");
        }
    }
}

 实现了human抽象类的对象Japanese：

namespace SimpleFactory
{
   public  class Japanese : Human
    {
        public override void Eat()
        {
            Console.WriteLine("日本人-吃东西");
        }

        public override void Play()
        {
            Console.WriteLine("日本人-玩游戏");
        }

        public override void Sleep()
        {
            Console.WriteLine("日本人-睡觉");
        }

        public override void Study()
        {
            Console.WriteLine("日本人-学习");
        }
    }
}

 定义枚举类如下，用于客户类传参数到工厂类

namespace SimpleFactory
{
    public enum HumanType
    {
        ChineseMan=1,
        Japanese = 2,
        American = 3,
        FrenchMan = 4
    }
}

 工厂类代码如下： 

namespace SimpleFactory
{
    public class Factory
    {
        public static Human CreateInstance(HumanType type)
        {
            Human resault = null;
            switch (type)
            {
                case HumanType.ChineseMan: resault = new ChineseMan(); break;
                case HumanType.American: resault = new AmeriCan(); break;
                case HumanType.FrenchMan: resault = new FrenchMan(); break;
                default: resault = new Japanese(); break;
            }
            return resault;
        }
    }
}

 客户端调用代码如下：

{
   //简单工厂，将创建对象的任务交给工厂类,将此类依赖的细节转移到工厂类中
   Human man0 = Factory.CreateInstance(HumanType.American);
   man0.Eat();
   Human man1 = Factory.CreateInstance(HumanType.Japanese);
   man1.Sleep();
   Human man2 = Factory.CreateInstance(HumanType.ChineseMan);
   man2.Study();
   Human man3 = Factory.CreateInstance(HumanType.FrenchMan);
   man3.Play();
   Console.ReadKey();
}

 运行结果：

四、简单工厂的优缺点及使用：简单工厂转移了客户类与服务类的依赖关系，但是同时自身依赖细节较多，且违背了单一职责原则，在扩展功能时需要修改工厂类，又违背了开闭原则，在考虑使用简单工厂时，应根据程序的扩展性来决定是否采用该方法。

 

标签：Console,Human,void,工厂,WriteLine,简单,override,设计模式,public
来源： https://www.cnblogs.com/zqhIndex/p/10279535.html