设计模式六大原则

来源：cnblogs　　作者：冰乐　　时间：2019/9/19 9:14:22　　对本文有异议

设计模式六大原则：

　　1、单一职责原则（Single Responsibility Principle）

　　2、历史替换原则（Liskov Substitution Principle）

　　3、依赖倒置原则（Dependence Inversion Principle）

　　4、接口隔离原则（Interface Segregation Principle）

　　5、迪米特法则（Law Of Demeter）//最少知道原则

　　6、开闭原则（Open Closed Principle）

设计模式：

　　面向对象语言开发过程中，遇到种种的场景和问题，提出的解决方案和思路，沉淀下来，设计模式是解决具体问题的套路

设计模式六大原则：

　　面向对象语言开发过程中，推荐的一些指导性原则；没有明确的招数，而且也会经常被忽视/违背；也是前辈总结，也是为了站在前辈的肩膀上。

　　实际上真实项目很难全部遵循，更多的时候会有一些侧重性。设计模式六大原则要能灵活运用，离不开时间的锤炼和思考，把这个真的融入到骨子里，设计确实会不一样。

1、单一职责（Single Responsibility Principle）

　　类T负责两个不同的职责，职责P1和职责P2。由于职责P1需求发生改变需要修改T时，有可能会导致原本运行正常职责P2功能发生故障。

　　一个类只负责一件事，面向对象语言开发，类是一个基本单位，单一职责原则就是封装的粒度。

下面我们来看一个动物类：

public class Animal
{
    private string _Name = null;
    public Animal(string name)
    {
        this._Name = name;
    }
    /// <summary>
    /// 这个方法就挺不稳定，经常各种分支变化经常修改
    /// </summary>
    public void Breath()
    {
        if (this._Name.Equals("鸡"))
            Console.WriteLine($"{this._Name} 呼吸空气");
        else if (this._Name.Equals("牛"))
            Console.WriteLine($"{this._Name} 呼吸空气");
        else if (this._Name.Equals("鱼"))
            Console.WriteLine($"{this._Name} 呼吸水");
        else if (this._Name.Equals("蚯蚓"))
            Console.WriteLine($"{this._Name} 呼吸泥土");
    }
    //BreathChicken  BreathFish
    //应该拆分了
    public void Action()
    {
        if (this._Name.Equals("鸡"))
            Console.WriteLine($"{this._Name} flying");
        else if (this._Name.Equals("牛"))
            Console.WriteLine($"{this._Name} walking");
        else if (this._Name.Equals("鱼"))
            Console.WriteLine($"{this._Name} Swimming");
        else if (this._Name.Equals("蚯蚓"))
            Console.WriteLine($"{this._Name} Crawling");
    }
}

这样在不同动物过来时，只要在Animal的构造函数中传递动物的名字即可：

{
    Animal animal = new Animal("鸡");//呼吸空气
    animal.Breath();
    animal.Action();
}
{
    Animal animal = new Animal("牛");//呼吸空气
    animal.Breath();
    animal.Action();
}
{
    Animal animal = new Animal("鱼");//呼吸水
    animal.Breath();
    animal.Action();
}

　　但是这样不好，写了分支判断，然后执行不同的逻辑，其实这就违背了单一职责，但是功能是可以实现的。

　　需要拆分，拆分父类+子类，每个类很简单，意味着稳定，意味着强大。现在的东西没有以前警用，因为功能多了，这不坏就那坏了。

下面抽象出一个父类：

public abstract class AbstractAnimal
{
    protected string _Name = null;
    public AbstractAnimal(string name)
    {
        this._Name = name;
    }
    public abstract void Breath();
    public abstract void Action();
}

现在，有一种动物，只要继承这个父类，重写抽象类中的方法即可：

public class Chicken : AbstractAnimal
{
    public Chicken(string name) : base(name)
    {
    }
    public Chicken() : base("鸡")
    {
    }
    public override void Breath()
    {
        Console.WriteLine($"{base._Name} 呼吸空气");
    }
    public override void Action()
    {
        Console.WriteLine($"{base._Name} flying");
    }
}

AbstractAnimal animal = new Chicken();
animal.Breath();
animal.Action();

拆分之后，也会造成代码量的增加，类多了，使用成本（理解成本）也高了。

那么，什么时候使用单一职责呢？

　　如果类型足够简单，方法够少，是可以在类级别去违背单一职责的；如果类型复杂了，方法多了，建议遵循单一职责原则。

方法级别的单一职责原则：一个方法只负责一件事

类级别的单一职责原则：一个类只负责一件事

类库级别的单一职责原则：一个类库职责要清晰

项目级别的单一职责：一个项目应该职责要清晰（客户端/管理后台/后台服务/定时任务/分布式引擎）

系统级别的单一职责：为通用功能拆分系统（IP定位/日志/在线统计）

2、里氏替换原则（Liskov Substitution Principle）

　　任何使用基类的地方，都可以透明（安全，不会出现行为不一致）的使用其子类

　　继承：子类拥有父类的一切属性和行为，任何父类出现的地方，都可以用子类来代替

　　a、父类有的，子类必须有，如果父类中出现了子类不应该有的东西，那么就应该断掉继承，再来一个父类，包含了都有的东西。

　　b、子类可以有自己的属性和行为，子类出现的地方，父类不一定能代替（白马非马）。

　　c、父类实现的东西，子类就不要再写了（就是不要new隐藏），有时候会出现意想不到的地方，行为不一致，如果想修改父类的行为，通过abstract或者virtual。声明属性、字段、变量，尽量声明为父类。

3、依赖倒置原则（Dependence Inversion Principle）

　　高层模块不应该依赖于低层模块，二者应该是通过抽象依赖，依赖抽象，而不是依赖细节。面向对象，尽量使用抽象，80%的设计模式都是跟抽象有关（接口也可以）。属性、字段、方法参数、返回值。。。。尽量都是抽象

　　抽象：接口/抽象类---可以包含没有实现的元素

　　细节：普通类（子类）---一切都是确定的

　　Student-------使用--------手机

　　高层--------------------------低层

就好像三层中：

　　BLL---------------------------DAL

如果在一开始，每个手机都定义通用的方法，学生在调用的时候，正常去调用，会出现高层依赖低层

 //Student-使用-手机
 //高层---------底层
 {
     iPhone phone = new iPhone();
     student.PlayiPhone(phone);
     student.PlayT(phone);
     student.Play(phone);
 }
 {
     Lumia phone = new Lumia();
     student.PlayLumia(phone);
     student.PlayT(phone);
     student.Play(phone);
 }
 {
     Honor phone = new Honor();
     student.PlayHonor(phone);
     student.PlayT(phone);
     student.Play(phone);
 }

解决上面出现的问题，定义一个手机的抽象父类，里面定义手机通用的功能。

/// <summary>
/// 定义一个手机抽象父类
/// </summary>
 
public abstract class AbstractPhone
{
    public int Id { get; set; }
    public string Branch { get; set; }
    public abstract void Call();
    public abstract void Text();
}

 /// <summary>
 /// 荣耀手机
 /// </summary>
 public class Honor : AbstractPhone
 {
     public override void Call()
     {
         Console.WriteLine("User {0} Call", this.GetType().Name);
     }
     public override void Text()
     {
         Console.WriteLine("User {0} Call", this.GetType().Name);
     }
 }

 /// <summary>
 /// iPhone
 /// </summary>
 public class iPhone : AbstractPhone
 {
     public override void Call()
     {
         Console.WriteLine("User {0} Call", this.GetType().Name);
     }
     public override void Text()
     {
         Console.WriteLine("User {0} Call", this.GetType().Name);
     }
 }

 /// <summary>
 /// 小米手机
 /// </summary>
 public class Mi : AbstractPhone
 {
     public override void Call()
     {
         Console.WriteLine("User {0} Call", this.GetType().Name);
     }
     public override void Text()
     {
         Console.WriteLine("User {0} Text", this.GetType().Name);
     }
     public void Bracelet()
     {
         Console.WriteLine("User {0} Bracelet", this.GetType().Name);
     }
 }

......只要是一部手机，只要继承了抽象父类，都可以重写父类中的抽象方法，实现通用的功能，也可以加上自己特有的功能（增加自己的功能，是不是很强大？后面就看出来了是否合理了）。

下面有两种方式去调用：泛型+父类约束=========》用抽象类，是等价的

public void PlayT<T>(T phone) where T : AbstractPhone
{
    Console.WriteLine("这里是{0}", this.Name);
    phone.Call();
    phone.Text();
}

public void Play(AbstractPhone phone)
{
    Console.WriteLine("这里是{0}", this.Name);
    phone.Call();
    phone.Text();
    //phone.Bracelet();
}

面向抽象有啥好处？

　　一个方法既满足不同类型的参数，只要是实现了这个抽象类，都可以用；还支持扩展，不用修改Student类；面向抽象后，不能使用子类特别的内容。

　　在调用的时候，studen.Play(phone);如果，这个phone是一个小Mi手机的子类呢？Bracelet（手环功能）是有的，但是方法不能用，编译器决定了是不能用Bracelet（dynamic/反射是可以调用的），不能常规调用，这个问题是解决不了的。

　　你这样想，如果小米手机都是自己特有的功能，那还用抽象父类干嘛？直接小米手机自己搞一个不就行了？因为面向对象不止一个类型，用的就是通用功能；非通用功能，那就不应该面向对象了。

　　面向对象语言开发，只要抽象不变，高层就不变。

　　面向对象语言开发，就是类与类之间进行交互，如果高层直接依赖低层的细节，细节是多变的，那么低层的变化就导致上层的变化；如果层数多了，低层的修改会直接水波效应传递到最上层，一点细微的改动，都会导致整个系统从下往上的修改（这就是大家经常加班的原因）。

　　面向抽象，如果高层和低层没有直接依赖，而是依赖于抽象，抽象一般是稳定的，低层细节的变化扩展就不会影响到高层，这样就能支持层内部的横向扩展，不会影响到其他地方，这样的程序架构就是稳定的。

　　依赖倒置原则（理论基础）------IOC控制反转（实践封装）-----DI依赖注入（实现IOC的手段）。

4、接口隔离原则（Interface Segregation Principle）

　　客户端不应该依赖它不需要的接口，一个类对另外一个类的依赖应该建立在最小的接口上，在工作中，80%都是用接口的。

　　AbstractPhone定义了Id、Branch、Call()、Text()，现在的智能手机，都有map、movie、online、game等功能，是否应该把这几个功能上升到AbstractPhone里面去？

　　答案是不应该的，OldManPhone也是手机，但是没有这些功能，AbstractPhone就只能放入任何手机都有的功能。

　　虽然这些东西不适合放在抽象类中，但是面向抽象编程，还有一个接口。抽象类 is a，接口 can do，面向对象编程中，是单继承多实现的。将这些东西定义在接口中，不局限产品。

　　接口是什么？　　

　　　　简单来说，接口就是，当一些东西都有相同的功能，但是有不能抽象出合理的父类的时候，这个时候就可以抽象为接口。

  public interface IExtend
  {
      void Photo();
      void Online();
      void Game();
      void Record();
      void Movie();
      void Map();//
      void Pay();
  }//都拆成一个方法一个接口

　　Camera能拍照，也能录像，既然面向抽象，那么有些功能的对象都能传递进来，那就让Camera也去实现IExtend接口？

　　不可以的，实现了IExtend接口，Camera出现了很多自己没有的功能，不应该使用这种大而全的接口，所以要把接口的功能进一步拆分，因为接口是可以多实现的。

 public interface IExtend
 {
     //void Photo();
     //void Online();
     //void Game();
     void Record();
     //void Movie();
     void Map();//
     void Pay();
 }//都拆成一个方法一个接口
 //电视--上网 玩游戏
 public interface IExtendHappy : IExtendGame
 {
     void Online();
     //void Game();
 }
 //掌中游戏机：俄罗斯方块--玩游戏不能上网
 
 public interface IExtendGame
 {
     void Game();
 }
 public interface IExtendVideo
 {
     void Photo();
     void Movie();//打开相机--切换模式--start--Suspend--End
 }

这样拆分下去，都拆成一个方法一个接口了，肯定也不好。

在.Net中，有IList<T>，是索引相关；ICollection<T>，集合相关操作；IEnumerable<T>，迭代器foreach....

接口到底该怎么定义？

　　a、既不能是大而全，会强迫实现没有的东西，也会依赖自己不需要的东西

　　b、也不能一个方法一个接口，这样，面向抽象也没意义了。

　　　　按照功能的密不可分可定义接口，而且应该是动态的，随着业务发展会有变化的，但是在设计的时候，要留好提前量，避免抽象变化。这里没有标准答案，随着业务来调整的。

　　c、接口合并，Map----定位/导航/搜索，这种就属于固定步骤，业务细节，尽量的内聚，在接口也不要暴露太多细节。

5、迪米特法则（Law Of Demeter）最少知道原则：高内聚低耦合

　　一个对象应该对其他对象保持最少的了解，只与直接的朋友通信。

　　面向对象----万物皆对象-----类与类交互才能产生功能，这不就是耦合了吗？要高内聚低耦合

　　类与类之间的关系：

　　　　纵向：继承≈实现（最密切）

　　　　横向：聚合>组合>包含>依赖（出现在方法内部）

　　迪米特法则：降低类与类之间的耦合，只与直接的朋友通信，就是要尽量避免依赖更多类型。

　　基类库（BCL-系统/框架内置）的类型除外

　　迪米特，也会增加一些成本

　　工作中，会去早一个中介（中间层）

　　上层UI下订单-----订单系统&支付&支付系统&仓储&物流

　　门面模式----上层交互门面----门面依赖子系统

　　三层架构中：UI----BLL-----DAL

　　去掉内部依赖

　　降低访问修饰符权限，private、protected、internal、protected internal、public

　　迪米特，依赖别人更少，让别人了解更少

/// <summary>
/// 学生
/// </summary>
public class Student
{
    public int Id { get; set; }
    public string StudentName { get; set; }
    public int Height { private get; set; }
    public int Salay;
    public void ManageStudent()
    {
        Console.WriteLine(" {0}Manage {1} ", this.GetType().Name, this.StudentName);
    }
}

/// <summary>
/// 班级
/// </summary>
public class Class
{
    public int Id { get; set; }
    public string ClassName { get; set; }
    public List<Student> StudentList { get; set; }
    public void ManageClass()
    {
        Console.WriteLine(" {0}Manage {1} ", this.GetType().Name, this.ClassName);
        foreach (Student s in this.StudentList)
        {
            s.ManageStudent();
            //Console.WriteLine(" {0}Manage {1} ", s.GetType().Name, s.StudentName);
        }
    }
}

/// 学校
/// </summary>
public class School
{
    public int Id { get; set; }
    public string SchoolName { get; set; }
    public List<Class> ClassList { get; set; }
    public void Manage()
    {
        Console.WriteLine("Manage {0}", this.GetType().Name);
        foreach (Class c in this.ClassList)
        {
            //Console.WriteLine(" {0}Manage {1} ", c.GetType().Name, c.ClassName);
            c.ManageClass();//1 遵循了迪米特
            //List<Student> studentList = c.StudentList;
            //foreach (Student s in studentList)
            //{
            //    Console.WriteLine(" {0}Manage {1} ", s.GetType().Name, s.StudentName);
            //}//2 违背了迪米特法则
        }
    }
}