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


依赖反转原则


抽象不依赖具体,具体依赖于抽象

 

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

原文地址:https://www.cnblogs.com/hulizhong/p/10785646.html

时间: 2024-10-01 02:27:03

SOLID原则(OOD&OOP)的相关文章

面向对象设计的SOLID原则

S.O.L.I.D是面向对象设计和编程(OOD&OOP)中几个重要编码原则(Programming Priciple)的首字母缩写. SRP The Single Responsibility Principle 单一责任原则 OCP The Open Closed Principle  开放封闭原则 LSP The Liskov Substitution Principle 里氏替换原则 DIP The Dependency Inversion Principle 依赖倒置原则 ISP The

【转】面向对象设计的SOLID原则

面向对象设计的SOLID原则 http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html S.O.L.I.D是面向对象设计和编程(OOD&OOP)中几个重要编码原则(Programming Priciple)的首字母缩写. SRP The Single Responsibility Principle 单一责任原则 OCP The Open Closed Principle  开放封闭原则 LSP The Liskov Subst

SOLID原则 【转】

S.O.L.I.D 是面向对象设计(OOD)和面向对象编程(OOP)中的几个重要编码原则(Programming Priciple)的首字母缩写. 面向对象设计的原则 SRP  The Single Responsibility Principle 单一职责原则 OCP   The Open Closed Principle 开放封闭原则 LSP  The Liskov Substitution Principle 里氏替换原则 ISP   The Interface Segregation P

OOA/OOD/OOP

Object-Oriented Analysis:面向对象分析方法 是在一个系统的开发过程中进行了系统业务调查以后,按照面向对象的思想来分析问题.OOA与结构化分析有较大的区别.OOA所强调的是在系统调查资料的基础上,针对OO方法所需要的素材进行的归类分析和整理,而不是对管理业务现状和方法的分析. OOA(面向对象的分析)模型由5个层次(主题层.对象类层.结构层.属性层和服务层)和5个活动(标识对象类.标识结构.定义主题.定义属性和定义服 务)组成.在这种方法中定义了两种对象类之间的结构,一种称

OOA - OOD - OOP 简介

OOA - OOD - OOP 简介 一. OOA OOA : (Object-Oriented Analysis, 面向对象分析方法) . 是在一个系统的开发过程中进行了系统业务调查以后,按照面向对象的思想来分析问题.OOA与结构化分析有较大的区别.OOA所强调的是在系统调查资料的基础上,针对OO方法所需要的素材进行的归类分析和整理,而不是对管理业务现状和方法的分析. OOA(面向对象的分析)模型由5个层次(主题层.对象类层.结构层.属性层和服务层)和5个活动(标识对象类.标识结构.定义主题.

SOLID原则

S.O.L.I.D是面向对象设计和编程(OOD&OOP)中几个重要编码原则(Programming Priciple)的首字母缩写. 单一责任原则: 当需要修改某个类的时候原因有且只有一个(THERE SHOULD NEVER BE MORE THAN ONE REASON FOR A CLASS TO CHANGE).换句话说就是让一个类只做一种类型责任,当这个类需要承当其他类型的责任的时候,就需要分解这个类. 开放封闭原则: 软件实体应该是可扩展,而不可修改的.也就是说,对扩展是开放的,而对

SOLID原则都不知道,还敢说自己是搞开发的!

面向对象编程(OOP)给软件开发领域带来了新的设计思想.很多开发人员在进行面向对象编程过程中,往往会在一个类中将具有相同目的/功能的代码放在一起,力求以最快的方式解决当下的问题.但是,这种编程方式会导致程序代码混乱和难以维护.因此,Robert C. Martin制定了面向对象编程的五项原则.这五个原则使得开发人员可以轻松创建可读性好且易于维护的程序. 这五个原则被称为SOLID原则. S:单一职责原则 O:开闭原理 L:里氏替换原则 I:接口隔离原理 D:依赖反转原理 我们下面将详细地展开来讨

设计模式之SOLID原则再回首

    本科阶段学过设计模式,那时对设计模式的五大原则--SOLID原则的概念与理解还是比较模糊,此时过去了2年时间,在学习<高级软件工程>课程中老师又提到了设计模式,课程中还详细讨论了五大原则的过程,这次SOLID原则再回首作者提出了一些更通俗的理解吧~ 一. 什么是设计模式?     那么,什么是设计模式呢? 从广义角度讲设计模式是可解决一类软件问题并能重复使用的设计方案; 从狭义角度讲设计模式是对被用来在特定场景下解决一般设计问题的类和相互通信的对象的描述,是在类和对象的层次描述的可重复

类设计的SOLID原则

SOLID原则是面向对象范式的核心 单一职责原则(Single Responsible Principle, SRP):对于一个类,应该仅有一个引起它变化的原因.其基础是内聚,表示类完成单一功能的程度. 开放—封闭原则(Open Closed Principle,OCP):类应该对扩展开放,对修改关闭.是SOLID原则中最重要的一个.OCP 的一个原则就是将类之间的耦合到抽象级别. Liskov替换原则(Liskov Substitution Principle,LSP):子类型应该能够替换它们