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("我哪错了啊");

      }

    }

    

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

05-23 05:44