SOLID原则（OOD&OOP）

SOLID原则是面向对象编程和面向对象设计的头五大原则。学习及应用这五大原则可以构建一个易于维护和扩展的应用程序，我们一起看看到底是那五大原则。

S--单一责任原则(SRP) --Single Responsibility Principle
O--开放封闭原则(OCP)-- Open-Closed Principle
L--里式替换原则(LSP)-- Liskov Substitution Principle
I –- 接口分离原则(ISP)--Interface Segregation Principle
D–-依赖倒置原则(DIP)-- Dependency Inversion Principle

一、单一责任原则(SRP)

单一责任原则指出当需要修改某个类的时候原因有且只有一个。也就是说一个类应该只负责一件事情。当这个类需要去做其他的事情的时候，就需要分解这个类。如果把多个功能放在一个类中要它负责，

那么各个功能之间会形成关联，改变其中一个功能可能会牵连其他的功能的改变，这样有需要花费时间和人力对其他功能的改变进行测试，保证其他功能的完整。

Ex：

一个有关长方形的类，长、宽、面积。后来需要增加正方形，就继续使用长方形的类，使用的时候长=宽。这一种情况违背了SRP原则，一个类只负责一件事情，这个时候应该新建一个正方形的类。

二、开放封闭原则(OCP)

开放封闭原则指的是程序模块应该遵循关闭修改，开放扩展。这里与单一责任原则很好的联系在了一起。一个类只负责一件事情。在程序模块中当业务更改或新增的时候不应该更改现有的代码行为，

应该转向开放扩展。其中一个方法是通过抽象方法，然后继承已达到扩展的想法。

Ex：

还是上面那个例子，最开始是计算长方形的面积，然后增加了正方形面积的计算。遵循关闭修改开放扩展的原则，不修改现有的代码行为。将计算方法抽象继承已扩展。新加正方形计算方法。

public interface Calculate
    {
         decimal CalculateArea(decimal longs, decimal wide=0);
    }

    public class Rectangle : Calculate
    {
        public   decimal CalculateArea(decimal  longs,decimal  wide)
        {
            decimal s = longs * wide;
            return s;
        }
    }

    public class Square : Calculate
    {
        public decimal CalculateArea(decimal longs, decimal wide)
        {
            decimal s = longs * longs;
            return s;
        }
    }

三、里氏替换原则(LSP)

子类型必须可替代其基类型 –一个对象出现的地方都可以由其子类代替并且不会出错，即是符合里氏替换原则的。

Ex：

狗和鸟同时都具备很多相同特征，可以走、跑、叫，以鸟作为基类，狗作为子类，会出现子类不能替换基类的情况，基类鸟可以飞，但是子类狗不能。这样不就符合里氏替换原则。可以考虑以狗走位基类，鸟作为子类，然后鸟扩展一个飞的属性。或者两者都作为子类，抽象出一个基类，动物类。满足子类可以任意替换基类的情况都是符合里氏替换原则的。

class Program
    {
        static void Main(string[] args)
        {
            Animal animal = new Dog();
            Console.WriteLine(animal.Walk());
            Console.WriteLine(animal.Run());
            Console.WriteLine(animal.Fly());
            Console.WriteLine(animal.MakeNoise());
            Console.ReadLine();
        }
    }
 

    public class Animal
    {
        public string Walk()
        {
            return "Move feet";
        }

 
        public string Run()
        {
            return "Move feet quickly";
        }
 

        public virtual string Fly()
        {
            return null;
        }

 
        public virtual string MakeNoise()
        {
            return null;
        }
    }

 
    public class Dog : Animal
    {
        public override string MakeNoise()
        {
            return "Bark";
        }
    }
 

    public class Bird : Animal
    {
        public override string MakeNoise()
        {
            return "Chirp";
        }

 
        public override string Fly()
        {
            return "Flag wings";
        }
    }

四、接口分离原则(ISP)

接口分离原则—client不应该被强迫依赖它不使用的方法，表明方法是分开或者隔离的。这个原则还强制实现高凝聚力，让您更好地理解，更强大的类和低耦合，更容易维护，更容易抵抗变化（即不太可能引入错误）。

Ex:

public interface Animal
    {
         string Run();
         string Fly();
    }

    public class Dog : Animal
    {
        public string Fly()
        {
            return string.Empty;
        }
 
        public string Run()
        {
            return "小狗，快跑";
        }
    }

 
    public class Bird : Animal
    {
        public string Fly()
        {
            return "小鸟，快飞";
        }
 

        public string Run()
        {
            return "小鸟，快跑";
        }
    }

在这段代码中，鸟和狗同时继承了动物，但是在狗实现接口的时候，Fly方法没有做任何操作。这里显然违背了接口分离原则，强迫了Dog类依赖了其Fly方法。

改进方法，可以将动物接口修改成两个接口，AnimalFly接口和AnimalRun接口。这样就遵循了其规则

五、依赖倒置原则(DIP)

依赖倒置原则-也是最后一个原则了。其原则指出—一个高级模块不应依赖于低级模块，两个都应该取决于抽象。抽象不应该依赖具体细节，细节应该依赖于抽象。

在这里可以发现依赖倒置原则和前几天讲过的依赖注入的原则十分相似。

六、总结

SRP	单一职责原则	一个类应只负责一件事情
OCP	开放封闭原则	封闭修改，开放扩展
LSP	里氏替换原则	一个对象可由其子类代替
ISP	接口分离原则	客户不应被强迫依赖它不使用的方法
DIP	依赖反转原则	抽象不依赖具体，具体依赖于抽象