设计模式1-简单工厂模式与工厂方法模式

简单工厂模式：建立一个工厂类，由调用方传递参数给工厂类判断返回具体的实例。

先来上类图，PS：平常做代码搬运工的日子里，不需要画图，也不会画更不会画，所以从0开始学画，目的为加深理解。

namespace DesignModel.简单工厂模式
{


    public class AnimalFactory
    {
        internal static Animal GetAnimal(string name)
        {
            Animal animal = null;
            switch (name)
            {
                case "牛":
                    animal = new A();
                    break;
                case "鸡":
                    animal = new B();
                    break;
                default:
                    animal = new C();
                    break;
            }
            return animal;
        }
    }

    abstract class Animal
    {
        public int Weigtht { get; set; }
        public string Name { get; set; }
        public abstract void laugh();
    }
    internal class A : Animal
    {
        public override void laugh() { }
    }
    internal class B : Animal
    {
        public override void laugh() { }
    }
    internal class C : Animal
    {
        public override void laugh() { }
    }
}

        /// <summary>
        /// 使用
        /// </summary>
        static void 简单工厂模式()
        {
            var animal= AnimalFactory.GetAnimal("A");
            animal.laugh();

        }

优点：工厂类中包含逻辑判断，根据调用方选择去实例化相关的类。对于调用方来说，去除了与具体产品的依赖。

缺点：如果需要增加产品类，需要修改工厂类添加CASE分支。违背了开闭原则。

工厂方法模式：定义创建对象的接口，让接口的子类决定实例化具体类，把一个类的实例化延迟到其子类。

namespace DesignModel.工厂方法模式
{
    internal interface IFactory
    {
        Animal CreateAnimal();
    }


    class AFactory : IFactory
    {
        public Animal CreateAnimal()
        {
            return new A();
        }
    }
     class BFactory : IFactory
    {
        public Animal CreateAnimal()
        {
            return new B();
        }
    }

    abstract class Animal
    {
        public int Weigtht { get; set; }
        public string Name { get; set; }
        public abstract void laugh();
    }

    class A : Animal
    {
        public override void laugh() { }
    }
    class B : Animal
    {
        public override void laugh() { }
    }

}
static void 工厂方法模式()
     {
          IFactory If = new AFactory();
          var ani= If.CreateAnimal();
          ani.laugh();
     }

以上两个模式中工厂类均返回具体产品的父类，针对抽象编程。

 附上设计原则：

1 单一职责原则（不要存在多于一个导致类变更的原因，一个类只负责一项职责）

2 迪米特法则（对象之间松藕合，一个对象应该对其它对象最少关联，如要调用其它对象方法，可以通过第三者转发这个调用）

3 里氏替换原则（子类能够代替父类（意味着子类实现了父类），也就是父子无依赖，只依赖接口）

4 依赖倒转原则（高层模块不应依赖低层模块，都应依赖抽象，针对接口编程）

5 接口隔离原则（最小化接口，子类只依赖需要的接口）

6 开闭原则（对扩展开放，对修改关闭）