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

 

1、单一责任原则(SRP)

单一责任原则指出当须要修改某个类的时候缘由有且只有一个。也就是说一个类应该只负责一件事情。当这个类须要去作其余的事情的时候，就须要分解这个类。若是把多个功能放在一个类中要它负责，

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

Ex：

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

2、开放封闭原则(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;
        }
    }

 

3、里氏替换原则(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";
        }
    }

 

 

4、接口分离原则(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接口。这样就遵循了其规则

 

5、依赖倒置原则(DIP)

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

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

 

6、总结

      

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

 

S.O.L.I.D 原则是很是有价值的五大原则，在建立和设计一个应用的时候应用这些原则，你会建立一个很是优秀的项目。

 

---

 

　　欢迎你们扫描下方二维码，和我一块儿学习更多的知识😊