• 单一职责原则
• 开闭原则
• 里氏转换原则
• 接口隔离原则
• 依赖倒转原则

单一职责原则

简单点理解，类型应当只具有一种功能，功能要单一，例如操作数据库的类则不应该再有其他方法，比如对产品的管理之类的操作。不仅仅是类，方法也是如此，每个方法专注一件事。

开闭原则

扩展开放，更改关闭。即不修改来扩展类的行为。比如通过继承接口来实现开闭原则，简单工厂和工厂方法的一个区别就是这样。

简单工厂设计模式

即使用一个工厂类来创建其他类的实例，通过switch根据不同参数返回不同的实例，其他类都有一个共同的父类。

有三个要素：

工厂：负责创建实例

抽象：即我们要创建的对象的父类

具体对象：我们需要创建的对象，即具体类的实例

其中：

1. 抽象出来的父类定义子类共有的方法

2. 子类的不同实现由自己完成

3. 工厂类用于创建实例对象，具体要创建哪个由传入的参数决定，可以通过switch判断。在这一步中，就不符合了开闭原则了。

    class Program
    {
        static void Main(string[] args)
        {
            Factory f = new Factory();
            f.CreateGun("pistol");
            f.CreateGun("rifle");

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 父类枪
    /// </summary>
    public class Gun
    {

    }

    /// <summary>
    /// 步枪
    /// </summary>
    public class Rifle : Gun
    {
        public Rifle()
        {
            Console.WriteLine("步枪");
        }
    }

    /// <summary>
    /// 手枪
    /// </summary>
    public class Pistol : Gun
    {
        public Pistol()
        {
            Console.WriteLine("手枪");
        }
    }

    /// <summary>
    /// 工厂类
    /// </summary>
    public class Factory
    {
        public Gun CreateGun(string type)
        {
            // 因为这个switch使得简单工厂不符合开闭原则，很难扩展
            switch (type)
            {
                case "pistol":
                    return new Pistol();
                case "rifle":
                    return new Rifle();
                default:
                    throw new ArgumentException("暂无该项武器...");
            }
        }
    }

简单工厂主要问题就是扩展性很差，但需求改变时，比如增加具体的子类武器，我们需要创建一个新的子类并且继承父类，然后工厂类中也需要新增判断，这违背了开闭原则。业务简单或者需求变动少产品增加少的情况下简单工厂还是比较合适使用的，但是复杂的业务环境肯定就不是首选。

工厂方法模式

类的实例化由子类来决定。

和简单工厂不同：

1. 简单工厂只有一个工厂，实例化都在这个工厂中，通过传入参数判断，它可以创建所有的东西。而工厂方法有一个抽象的工厂和多个具体的工厂，每个具体的工厂创建对应的子类实例，实例化是在具体的工厂中实现的，所以扩展的时候很方便，不用修改switch里面的判断，只需要增加工厂即可。

2. 工厂方法符合开闭原则，简单工厂不符合。

要素：

1. 抽象产品

2. 具体产品

3. 抽象工厂（简单工厂没有抽象工厂）

4. 具体工厂

    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory f = new PistolFactory();
            f.Create();

            Console.ReadKey();
        }
    }
    /// <summary>
    /// 父类枪
    /// </summary>
    public class Gun
    {

    }

    /// <summary>
    /// 步枪
    /// </summary>
    public class Rifle : Gun
    {
        public Rifle()
        {
            Console.WriteLine("步枪");
        }
    }

    /// <summary>
    /// 手枪
    /// </summary>
    public class Pistol : Gun
    {
        public Pistol()
        {
            Console.WriteLine("手枪");
        }
    }

    /// <summary>
    /// 抽象工厂
    /// </summary>
    public interface AbstractFactory
    {
        /// <summary>
        /// 创建对象的接口方法
        /// </summary>
        /// <returns></returns>
        Gun Create();
    }

    /// <summary>
    /// 步枪的具体工厂
    /// </summary>
    public class RifleFactory : AbstractFactory
    {
        public Gun Create()
        {
            return new Rifle();
        }
    }

    /// <summary>
    /// 手枪的具体工厂
    /// </summary>
    public class PistolFactory : AbstractFactory
    {
        public Gun Create()
        {
            return new Pistol();
        }
    }

此时，如果增加了新的枪类，我们只需要增加具体的子类枪对象，继承抽象的父类，抽象工厂无需改动，再增加一个具体的工厂继承抽象工厂接口用来创建这个新产品即可。

说白了就是原有的代码无需修改，只需要添加，这一点符合开闭原则，引进新产品的时候非常的方便。

里氏转换原则

1)、子类可以赋值给父类（需要一个父类类型时，给一个子类类型的对象是可以的）

Person p1 = new Student();

2)、如果父类中装的是子类对象，那么可以将这个父类强转为这个子类对象。

Person p1 = new Student();
Student s1 = (Student)p1;

（不能把父类类型转换成子类对象）：

Chinese c = (Chinese)new Person();	//是错的

我们子类继承了父类，就希望子类可以做父类的所有行为，并且自己可以扩展父类不能做的行为，实际上，子类并不一定都能做到父类的所有行为，例如鸭有吃的动作，但是玩具鸭不能吃，这个方法就违反了里氏转换原则。解决方法是可以使用接口，这样所有的鸭继承Duck，有吃的动作的鸭继承接口IDuckEat，玩具鸭直接继承Duck即可。

接口隔离原则

客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。说白了，一个通用的庞大接口并不一定是好事，将行为细分，多个不同的接口反而更容易保证接口隔离。

例如集合都继承了IEnumerable或者它的泛型，但是并不是所有的方法都集成在了这个接口中，一些不通用的方法我们可以放到其他子接口中，这样选择性的继承父接口或者子接口来保证接口隔离。例如很多集合都可以Insert和RemoveAt，但是Stack和Queue不能随便插入删除的，这时Insert和RemoveAt定义在了IEnumerable的子类ICollection的子类IList中，这时如果还存在其他集合可以随便插入删除的继承自IList，而Stack和Queue继承自ICollection。

依赖倒转原则

将抽象的类定义为一组接口，具体的实现以来这些接口。即高层不依赖于底层，他们都依赖的是那一组接口，即抽象。

例如我们有一台计算机，计算机有显示器，键盘等，那我们将所有的显示器都继承自IDisplay接口，所有的键盘继承自IkeyBoard接口，这样构造函数Computer(IDisplay display, IKeyBoard keyboard)中，不同品牌电脑当有不同的显示器键盘时，传入他们特定的显示器键盘即可，这就时依赖一组抽象接口，底层的显示器键盘则依赖对应的接口，所以说两个依赖的都是接口，一组抽象。将具体类型的显示器键盘通过构造函数传入给一个具体类型的电脑就是构造函数依赖注入。倘若你电脑定义时依赖的是具体的显示器键盘，后期将无法更改显示器和键盘的类型了。

依赖注入对需求的改变，功能的扩展等都更加灵活，模块间的耦合程度降低。