面向对象设计原则-SOLID

SOLID的意思是：

• Single responsibility principle 单一职责原则
• Open/close principle 开放/封闭原则
• Liskov substitution principle 里氏替换原则
• Interface segregation principle 接口分离原则
• Dependency inversion principle 依赖倒置原则

简解：

　　单一职责原则：

　　　　一个类应该只有一个被改变的理由，也就是类应该只有一个职责。

　　开放/封闭原则：

　　　　类、方法、模块等应该对扩展开发，对修改封闭。

　　里氏替换原则：

　　　　子类可以扩展父类的功能，但不要去改变父类原有的功能。

　　接口分离原则：

　　　　创建更精细的接口供客户程序使用。

　　依赖倒置原则：

　　　　模块不依赖它需要的模块。而是依赖于抽象的定义。

详解：

　　单一职责原则：

　　　　在定义一个类时，让其只有一个职责就行了。

　　　　来举例说明，错误的示例：

　　　　Class A //供别人使用的低级功能类

　　　　{

　　　　　　Say(String s)

　　　　　　{

　　　　　　　　//具体实现

　　　　　　}

　　　　}

　　　　Class B //B类是重点，此类的实现违背了单一职责原则，它现在有两个职责，一是管理A的绳命周期，二是自己的业务逻辑。

　　　　{

　　　　　　A a;

　　　　　　 Public B()

　　　　　　{

　　　　　　　　a = new A();

　　　　　　}

　　　　　　

　　　　　   void SayWrong()

　　　　　　{

　　　　　　　　A.Say("老头子他又错了");

　　　　　　}

　　　　}

　　　　B类正确的设计：　　　　

　　　　Class B //B类这样就正确了，只有了自己的业务逻辑单一职责，管理A的绳命周期交给别的类去实现。

　　　　{

　　　　　　A a;

　　　　　　 Public B(A a)

　　　　　　{

　　　　　　　　this.a = a;

　　　　　　}

　　　　　　

　　　　　   void SayWrong()

　　　　　　{

　　　　　　　　A.Say("我哪错了啊");

　　　　　　}

　　　　}

　  开放/封闭原则：

　　　　平时我们使用控件时，如Button类，把它看做基类，利用继承可以制作自己特别功能的按钮（对扩展开放），但是不要直接修改Button类，即使你有Button类的源码也不要修改（对修改封闭）。这就是开闭原则的一个应用。

　　里氏替换原则：

　　　　里氏是个妇女的姓氏，替换的意思详看下面的例子　　　　

　　　　class Program
　　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　ISpeak iSpeak = new EnglishSpeak();//此处或是 new ChineseSpeak();
　　　　　　　　iSpeak.Say();//当调用Say方法时，iSpeak指向的是EnglishSpeak实例就显示“英国话”，同理，指向ChineseSpeak实例就显示“中国话”
　　　　　　　　Console.ReadKey();
　　　  　　}
　　　　}

　　　　interface ISpeak
　　　　{
　　　　　　void Say();
　　　　}

　　　　class ChineseSpeak:ISpeak
　　　　{
　　　　　　public void Say()
　　　　　　{
　　　　　　　　Console.WriteLine("中国话");
　　　　　　}
　　　　}

　　　　class EnglishSpeak : ISpeak
　　　　{
　　　　　　public void Say()
　　　　　　{
　　　　　　　　Console.WriteLine("英国话");
　　　　　　}

　　　　}

　　　　替换是利用多态实现的。ChineseSpeak和EnglishSpeak类都有ISpeak定义的Say方法，在客户端程序的Main中，你想替换成哪个具体实现类都成。里氏替换的约束是子类只是去实现父类的约束。如果父类是类不是接口的话，不要去覆盖父类已经实现的方法，可以覆盖父类的抽象方法。

　　接口分离原则：

　　　　举个列子：

　　　　interface A

　　　　{

　　　　　　a();

　　　　　　b();

　　　　　　c();//如果c不是客户端常用的方法　　

　　　　}

　　　　应该把接口A拆分成：　　　　

　　　　interface A

　　　　{

　　　　　　a();

　　　　　　b();

　　　　}

　　　　interface B

　　　　{

　　　　　　c();

　　　　}

　　　　这样的好处是，如果方法特别多，客户端使用时看到很多方法闹眼睛。

　　　　class clent()

{

　　　　　　B ib;

　　　　　　publc(B ib)

　　　　　　{

　　　　　　　　this.ib = ib;

}

　　　　　　public void clentC()

　　　　　　{

　　　　　　　　ib.C();

　　　　　  }

}

　　依赖倒置原则：

　　　　错误的示例：　　　　

　　　　Class A //供别人使用的低级功能类

　　　　{

　　　　　　Say(String s)

　　　　　　{

　　　　　　　　//具体实现

　　　　　　}

　　　　}

　　　　Class B //B类完全依赖A类，如果A类改了，B类就得改。

　　　　{

　　　　　　A a;

　　　　　　 Public B(A a)

　　　　　　{

　　　　　　　　this.a = a;

　　　　　　}

　　　　　　

　　　　　   void SayWrong()

　　　　　　{

　　　　　　　　A.Say("我哪错了啊");

　　　　　　}

　　　　}

　　　　正解：　　　　

　　　　interface iA

　　　　{

　　　　　　Say(String s);

　　　　}

　　　　Class A:iA //供别人使用的低级功能类

　　　　{

　　　　　　Say(String s)

　　　　　　{

　　　　　　　　//具体实现

　　　　　　}

　　　　}

　　　　Class B //B类现在依赖的是iA这个接口，A类的实现也得按照这个接口来。大家都遵循iA的约束。

　　　　{

　　　　　　iA a;

　　　　　　 Public B(iA a)

　　　　　　{

　　　　　　　　this.a = a;

　　　　　　}

　　　　　　

　　　　　   void SayWrong()

　　　　　　{

　　　　　　　　A.Say("我哪错了啊");

　　　　　　}

　　　　}

　　　　

　　初学咋练，如有错误，多指教。