精华内容
下载资源
问答
  • Java设计模式——单一职责模式

    千次阅读 2018-05-23 10:22:20
    今天和大家聊一聊单一职责模式,大家从名字应该就能想到这个设计模式的核心思想就是降低耦合性,强调一个类/整体只做一件事。今天就不给大家代码举例子了,因为这个会很好理解,你只要写一个类,强调一个方法,方法...

    今天和大家聊一聊单一职责模式,大家从名字应该就能想到这个设计模式的核心思想就是降低耦合性,强调一个类/整体只做一件事。今天就不给大家代码举例子了,因为这个会很好理解,你只要写一个类,强调一个方法,方法只实现一种功能举行啦!

    单一职责模式:就一个类而言,应该仅有一个引起它变化的原因。

    有的同学会问,一个类如果只是有且仅有一个因素来引起他的变化,岂不是我们的程序的代码会非常臃肿?这个情况我们要视情况而定,其实在生活中也是,我们如果做到一件事情的专精,那就要舍弃一些其他方面的功能。例如我们的手机可以照相,但是他的专业程度不如数码摄像机,再比如我们的交通工具,汽车负责马路,轮船负责大海,飞机负责天空一样,我们要做到一件事情让他专精一个功能。

    在一些特定的情况下,一个类我们只让他承担一个特定的职责,如果一个类承担的职责过多,就等于把这些职责耦合在一起,这是我们编程思想中所忌讳的,程序员一直都再致力于使我们的代码简洁化,我们常说的就是让代码高内聚低耦合,降低代码的耦合性,这样我们在如果对代码中的一个功能模块进行修改时,我们只需要修改特定功能的类即可,从而不会影响其他功能的代码。如果我们提高功能代码的耦合性,那我们设计的代码就会非常脆弱,当一个功能代码发生变化时,我们的代码设计就会招到破坏,影响是非常大的。

    我们在实际开发中,会发现软件的功能是非常多的,我们不能盲目的去分离代码和职能,我们一定要去判断这些功能是否需要分离,我们的分离原则就是相同功能的类我们提取使用工厂和策略模式,如果功能不同我们可以让这个类职责单一化,即分离出来。

    还有一个就是如果这个类有很多的动机或者因素来改变它,我们就需要考虑分离它,使它的功能单一化。

    今天的单一职责模式不太好写代码或者太容易写出代码,我们要根据我们的项目区思考,什么时候会去用到它,什么时候是不需要分离类的。作为一个程序员,我们一定要加入自己的思考,而不只是作为一个代码的搬运工。

     示例代码如下:

    class Animal{
        public void breathe(String animal){
            System.out.println(animal+"呼吸空气");
        }
    
        public void breathe2(String animal){
            System.out.println(animal+"呼吸水");
        }
    }
    
    public class Client{
        public static void main(String[] args){
            Animal animal = new Animal();
            animal.breathe("牛");
            animal.breathe("羊");
            animal.breathe("猪");
            animal.breathe2("鱼");
        }
    }





    Good luck!

    Write by Jimmy.li





    展开全文
  • Java设计模式-单一职责原则

    千次阅读 2019-03-01 16:27:11
    单一职责原则 定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。 问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行...

    单一职责原则 【Single Responsibility Principle】

      定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。
    问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责P2功能发生故障。

      解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。

      说到单一职责原则,很多人都会不屑一顾。因为它太简单了。稍有经验的程序员即使从来没有读过设计模式、从来没有听说过单一职责原则,在设计软件时也会自觉的遵守这一重要原则,因为这是常识。在软件编程中,谁也不希望因为修改了一个功能导致其他的功能发生故障。而避免出现这一问题的方法便是遵循单一职责原则。虽然单一职责原则如此简单,并且被认为是常识,但是即便是经验丰富的程序员写出的程序,也会有违背这一原则的代码存在。为什么会出现这种现象呢?因为有职责扩散。所谓职责扩散,就是因为某种原因,职责P被分化为粒度更细的职责P1和P2。

      举例说明:只要做过项目,肯定要接触到用户、机构、角色管理这个模块,我们今天要讲的是用户管理,管理用户的信息,增加机构(一个人属于多个机构),增加角色等,用户有这么的信息和行为要维护,我们就把这些写到一个接口中,都是用户管理类嘛,我们先来看类图:
    在这里插入图片描述
      太easy的类图了,我相信即使一个初级的程序员也可以看出这个接口设计的有问题,用户的属性(Properties)和用户的行为(Behavior)没有分开,这是一个严重的错误!非常正确,确实是这个接口设计的一团糟,应该把用户的信息抽取成一个业务对象(BussinessObject,简称B0),把行为抽取成另外一个接口中,我们把这个类图重新画一下:

    在这里插入图片描述
      这个类图看起来完全满足了类和接口的单一职责要求,非常符合标准,但是我相信你在设计的时候肯定不会采用这种方式,一个用户类要把把两个IUserB0和IUserBiz组合在一块才能使用,组合是一种强耦合关系,你和我都是有共同的生命期,这样的强耦合关系还不如使用接口实现的方式呢,而且还增加了类的复杂性,多了两个类呀,我们修改一下类图:
    在这里插入图片描述  重新拆封成两个接口,IUserB0负责用户的属性,简单的说就是IUserB0的职责是收集和反馈用户的属性信息;IUserBiz负责用户的行为,完成用户的信息的维护和变更。各位可能要问了,这个和我实际的工作中用到的User类还是有差别的呀,别着急,我们先来想一想分拆成两个接口怎么使用,想清楚了,我们看是面向的接口编程,所有呀你产生了这个UserInfo对象之后,你当然可以把它当IUserB0接口使用,当然也可以当IUserBiz接口使用,这要看你在怎么地方使用了,你要获得用户想信息,你就当时IUserB0的实现类;你要是想维护用户的信息,就当是IUserBiz的实现类就成了,类似于如下代码:

    IUserBiz userInfo=new UserInfo();
    //我要赋值了,我就认为它是一个纯粹的
    BO IUserBO userB0=(IUserBO)userInfo;
    userBO.setPassword("abc");
    //我要执行动作了,我就认为是一个业务逻辑类
    IUserBiz userBiz=(IUserBiz)userInfo;
    userBiz.deleteUser();
    

      这样的设计,一个用户实现了两个接口,把两个职责融合一个类中,你会觉得这个UserInfo有两个原因引起变化了呀,是的是的,但是别忘记了我们是面向接口编程,我们对外公布的是接口而不是实现类;而且如果真要实现类的单一职责的话,这个就必须使用了上面组合的方式了,那这个会引起类间耦合过重的问题(我们等会再说明这个问题,继续往下看)。那使用了单一职责原则有什么好处呢?

      单一职责使用于接口、类,同时也使用方法,什么意思呢?一个方法尽可能做一件事情,比如一个方法修改用户密码,别把这个方法放到“修改用户信息”方法中,这个方法的颗粒度很粗,比如这个一个方法:
    在这里插入图片描述

      在IUserManager中定义了一个方法叫changeuser,根据传递的type不同,把可变长度参数changeOptions修改到userBo这个对象上,并调用持久层的方法保存到数据库中。
    这种方式要简单的多。但是却存在着隐患:每次新增、移除某个type都需要对原有代码进行修改啊;进而可能影响到其他type的操作,这种修改方式直接在代码级别上违背了单一职责原则,虽然修改起来最简单,但方法职责不清晰,不单一,隐患却是最大的。一般方法设计成这样的:

    在这里插入图片描述

      你要修改用户名称,就调用changeUserNane方法,你要修改家庭地址就调用changellomeAddress,你要修改单位单户就调用changeofficeTel方法,每个方法的职责就非常清晰,这也是一个良好的设计习惯。

      对于接口,我们在设计的时候一定要做到单一,但是对于实现类就需要多方面考虑了,考虑项目环境,考虑工作量,考虑人员的技术水平,考虑硬件的资源情况等等,最终融合的结果是经常违背这一单一原则。生搬硬套单一职责原则会引起类的剧增,给维护带来非常多的麻烦;而且过分的细分类的职责也为人为的制造系统的负责性,本来一个类可以实现的行为非要拆成两个,然后使用聚合或组合的方式再耦合在一起,这个是人为制造了系统的复杂性,所以原则是死的,人是活的,这句话是非常好的。但是我相信随着技术的深入,单一职责原则必然会深入到项目的设计中去,而且这个原则是那么的简单,简单的我都不知道该怎么更加详细的去描述,单从字面上大家都应该知道是什么意思,单一职责嘛!

      遵循单一职责原的优点有:
      可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定要比负责多项职责简单的多;
      提高类的可读性,提高系统的可维护性;
      变更引起的风险降低,变更是必然的,如果单一职责原则遵守的好,当修改一个功能时,可以显著降低对其他功能的影响。
      需要说明的一点是单一职责原则不只是面向对象编程思想所特有的,只要是模块化的程序设计,都适用单一职责原则。

    展开全文
  • 设计模式单一职责原则学习

    千次阅读 多人点赞 2012-05-03 11:07:20
    单一职责原则:就一个类而言应该仅有一个引起它变化的原因。 比如写一个窗口应用程序。我们会创建一个类,将各种各样的代码,如某种算法的代码或是访问数据库的代码,都放在这个类中。以后一旦需求有所更改就必须...

    单一职责原则:就一个类而言应该仅有一个引起它变化的原因。

    比如写一个窗口应用程序。我们会创建一个类,将各种各样的代码,如某种算法的代码或是访问数据库的代码,都放在这个类中。以后一旦需求有所更改就必须修改这个类。各个功能的耦合性太大,牵一发而动全身。维护很麻烦,复用不可能,也缺乏灵活性。

    由于c语言是我的第一门编程语言,这么多年的使用,面向过程的思想早已根深蒂固。短时间很难培养起使用面向对象开发的习惯。看来任何东西都有两面性,在学C++之前先学习C语言可能对入门有帮助,但也有一些弊端。世上很多东西都是矛盾的,重要的是要从这些矛盾中找到一个平衡点。

    如果一个类承担的功能过多,就等于把这些职责偶合在一起,一个职责的变化可能会削弱或抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计,当变化发生时,设计会遭到意想不到的破坏。

    俄罗斯方块游戏的设计

    应该考虑将程序至少分为两个类:一个是窗口类,用于处理界面交互。另一个是游戏逻辑类。当有一天要改变界面或是移植到其他平台上就不涉及游戏逻辑的改变。

    对于游戏逻辑设计,方块的可移动区域,可以用一个二维数组进行表示。对方块的各种操作就是对二维数组值进行的操作。。我觉得也需要两个大类,首先是各种图形的表示类,比如口型,L型,1型。给出它的各个成员在二维数组的坐标。它们应该从一个共同的基类继承。另外一个是对图形类进行操作的操作类。比如左移、右移、变形以及碰撞检测、消行等。可以考虑使用策略模式来对各个图形类进行管理。

        代码稍后奉上。。。。。
    
    


          软件设计真正要做的内容,就是发现职责并把那些指职责分离。如果能找出多于一个动机去改变一个类,这个类就具有多个职责,此时就应该考虑职责分离。

     

    展开全文
  • 设计模式系列:单一职责原则

    千次阅读 2016-06-10 11:38:33
      解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。  但是即便是...

    问题由来

      问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责P2功能发生故障。

      解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。

      但是即便是经验丰富的程序员写出的程序,也会有违背这一原则的代码存在。为什么会出现这种现象呢?因为有职责扩散。所谓职责扩散,就是因为某种原因,职责P被分化为粒度更细的职责P1和P2。

      比如:类T只负责一个职责P,这样设计是符合单一职责原则的。后来由于某种原因,也许是需求变更了,也许是程序的设计者境界提高了,需要将职责P细分为粒度更细的职责P1,P2,这时如果要使程序遵循单一职责原则,需要将类T也分解为两个类T1和T2,分别负责P1、P2两个职责。但是在程序已经写好的情况下,这样做简直太费时间了。所以,简单的修改类T,用它来负责两个职责是一个比较不错的选择,虽然这样做有悖于单一职责原则。(这样做的风险在于职责扩散的不确定性,因为我们不会想到这个职责P,在未来可能会扩散为P1,P2,P3,P4……Pn。所以记住,在职责扩散到我们无法控制的程度之前,立刻对代码进行重构。)

    定义

    一个类只负责一个功能领域中的相应职责,或者说可以定义为:就一个类而言,应该只有一个引起它变化的原因。

    • 单一职责原则的核心思想是:一个类不能太累,在操作系统中,一个类(大到模块,小到方法)承担的责任越多,它被复用的可能性也就越小,而且一个类承担的职责过多,就相当于将这些职责耦合在一起,当其中一个职责变化时,可能会影响其他职责的运作,因此要将这些职责进行分离,将不同的职责封装在不同的类中,即将不同的变化原因封装在不同的类中,如果多个职责总是同时发生改变则可将它们封装在同一类中。
    • 单一职责适用于接口、类,同时也适用于方法。即一个方法尽可能做一件事情。
    • 接口、方法一定要做到单一职责原则,类的设计尽量做到只有一个原因引起变化。
    • 其实在软件设计中,要真正用好单一职责原则并不简单,因为遵循这一原则最关键的地方在于职责的划分,重点是职责的划分!重点是职责的划分!重点是职责的划分!重要的事情说三遍。而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验。下面会给出一个案例来分析如何划分职责。

    对职责的解释

    • 什么是职责?行为;功能;角色;

    • 职责的实现:由类的属性和方法来承担

    • 单一职责:一个类只扮演一个角色,只做一件事情(精细分工是现代社会的标志之一)

    • 使用SRP的目的:高内聚;低耦合

    • 多个职责有什么不好?职责之间会相互影响;为使用某一功能而引入其他不需要的功能;对类的修改会牵涉太多(尽可能保持小、窄、轻、快;适当的粒度更利于复用)

    • 如何区分不同的职责?
      有些显而易见;更多的需要积累经验,很难较好划分。
      (我们面对更多的是较为明确的需求;而职责的划分涉及了实现)

    • 单一职责:完全做一件事、做好这件事、只做这件事

    • 经验之谈(Rule of thumb)
      能用25个字就描述清楚一个类。
      如果试图去做太多的事情,类、接口、函数总倾向于膨胀
      保持代码简洁有效。onlyAndOnlyOnce,Do the simplest thing that could possibly work.

    如何识别破坏了单一职责原则?

    • 类有太多依赖
    类的构造器有太多参数,意味着测试有太多依赖,需要制造mock太多测试输入参数,通常意味着已经破坏SRP了。

    • 方法有太多参数
    类似类的构造器,方法参数意味着依赖。

    • 测试类变得复杂
    如果测试有太多变量,意味着这个类有太多职责。

    • 类或方法太长
    如果方法太长,意味着内容太多,职责过多。一个类不超过 200-250

    • 描述性名称
    如果你需要描述你的类 方法或包,比如使用”xxx和xxx”这种语句,意味着可能破坏了SRP.

    • 低聚合Cohesion的类
    聚合Cohesion是一个很重要的概念,虽然聚合是有关结构概念,但是聚合和SRP非常相关,如前面论坛案例,如果一个类不代表一个高聚合,意味着低凝聚low Cohesion,它就可能意味破坏SRP。一个低凝聚的特点:一个类有两个字段,其中一个字段被一些方法使用;另外一个字段被其他方法使用。

    • 在一个地方改动影响另外一个地方
    如果在一个代码地方加入新功能或只是简单重构,却影响了其他不相关的地方,意味着这个地方代码可能破坏了SRP.

    • 猎枪效果Shotgun Effect
    如果一个小的改变引起一发动全身,这意味SRP被破坏了。

    • 不能够封装模块
    比如使用Spring框架,你使用@Configuration or XML 配置,如果你不能在一个配置中封装一个Bean。意味着它有太多职责,Spring配置应该隐藏内部bean,暴露最少接口,如果你因为多个原因需要改变Spring配置,可能破坏了SRP.

    优缺点

    优点:
    可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定要比负责多项职责简单的多;
    提高类的可读性,提高系统的可维护性、可扩展性;
    变更引起的风险降低,变更是必然的,如果单一职责原则遵守的好,当修改一个功能时,可以显著降低对其他功能的影响。
    一个非常大的优点是:便于类和方法的重用。

    缺点:
    单一职责原则提出了一个编写程序的标准,用”职责“或”变化原因“来衡量接口或类设计是否优良,但是”职责“和”变化原因“都是不可度量的,因项目、环境而已。
    多数工业代码的类都是违反单一职责原则的。因为类的单一职责受多种因素的影响。

    案例

    例1:

    举例说明,用一个类描述动物呼吸这个场景:

    class Animal{
            public void breathe(String animal){
                    System.out.println(animal+"呼吸空气");
            }
    }
    public class Client{
            public static void main(String[] args){
                    Animal animal = new Animal();
                    animal.breathe("牛");
                    animal.breathe("羊");
                    animal.breathe("猪");
            }
    } 
    运行结果:
    牛呼吸空气
    羊呼吸空气
    猪呼吸空气

      程序上线后,发现问题了,并不是所有的动物都呼吸空气的,比如鱼就是呼吸水的。修改时如果遵循单一职责原则,需要将Animal类细分为陆生动物类Terrestrial,水生动物Aquatic,代码如下:

    class Terrestrial{
            public void breathe(String animal){
                    System.out.println(animal+"呼吸空气");
            }
    }
    class Aquatic{
            public void breathe(String animal){
                    System.out.println(animal+"呼吸水");
            }
    }
    public class Client{
            public static void main(String[] args){
                    Terrestrial terrestrial = new Terrestrial();
                    terrestrial.breathe("牛");
                    terrestrial.breathe("羊");
                    terrestrial.breathe("猪");
    
                    Aquatic aquatic = new Aquatic();
                    aquatic.breathe("鱼");
            }
    }
    运行结果:
    牛呼吸空气
    羊呼吸空气
    猪呼吸空气
    鱼呼吸水

      我们会发现如果这样修改花销是很大的,除了将原来的类分解之外,还需要修改客户端。而直接修改类Animal来达成目的虽然违背了单一职责原则,但花销却小的多,代码如下:

    class Animal{
            public void breathe(String animal){
                    if("鱼".equals(animal)){
                            System.out.println(animal+"呼吸水");
                    }else{
                            System.out.println(animal+"呼吸空气");
                    }
            }
    }
    public class Client{
            public static void main(String[] args){
                    Animal animal = new Animal();
                    animal.breathe("牛");
                    animal.breathe("羊");
                    animal.breathe("猪");
                    animal.breathe("鱼");
            }
    } 

      可以看到,这种修改方式要简单的多。但是却存在着隐患:有一天需要将鱼分为呼吸淡水的鱼和呼吸海水的鱼,则又需要修改Animal类的breathe方法,而对原有代码的修改会对调用“猪”“牛”“羊”等相关功能带来风险,也许某一天你会发现程序运行的结果变为“牛呼吸水”了。这种修改方式直接在代码级别上违背了单一职责原则,虽然修改起来最简单,但隐患却是最大的。还有一种修改方式:

    class Animal{
            public void breathe(String animal){
                    System.out.println(animal+"呼吸空气");
            }
    public void breathe2(String animal){
                    System.out.println(animal+"呼吸水");
            }
    }
    public class Client{
            public static void main(String[] args){
                    Animal animal = new Animal();
                    animal.breathe("牛");
                    animal.breathe("羊");
                    animal.breathe("猪");
                    animal.breathe2("鱼");
            }
    } 

      可以看到,这种修改方式没有改动原来的方法,而是在类中新加了一个方法,这样虽然也违背了单一职责原则,但在方法级别上却是符合单一职责原则的,因为它并没有动原来方法的代码。这三种方式各有优缺点,那么在实际编程中,采用哪一中呢?其实这真的比较难说,需要根据实际情况来确定。
      例如本文所举的这个例子,它太简单了,它只有一个方法,所以,无论是在代码级别上违反单一职责原则,还是在方法级别上违反,都不会造成太大的影响。实际应用中的类都要复杂的多,一旦发生职责扩散而需要修改类时,除非这个类本身非常简单,否则还是遵循单一职责原则的好。

    例2:

    男生一般是站着尿尿,所以代码是:
        function Male (name, age) {
            this.name = name;
            this.age = age;
            this.sex = 'male';
        }
    Male.prototype = {
            coustructor: Male,
    //尿尿的行为
            pee: function () {
                console.log('站着尿尿');
            }
        };
    女生一般是蹲着尿尿,所以代码是:
        function FeMale (name, age) {
            this.name = name;
            this.age = age;
            this.sex = 'female';
        }
    FeMale.prototype = {
            coustructor: FeMale,
    //尿尿的行为
            pee: function () {
                console.log('蹲着尿尿');
            }
        };

    所以结果男生lilei是站着尿尿的,女生hanmeimei是蹲着尿尿的

     var lilei = new Male('lilei', 20);
        //站着尿尿
        lilei.pee();
    var hanmeimei = new FeMale('hanmeimei', 20);
    //蹲着尿尿
        hanmeimei.pee();

    这一切是不是看起来好像很完美? 但是lilei虽然是男生,但是他却喜欢蹲着尿尿(或者都喜欢女生行为),这时候lilei的行为就与自己的性别产生了耦合,其实性别与行为分别负责不同的职责

      /**
        *   人类的基类
        *   @param person: 人类的各种属性,包括姓名、年龄、性别等
        *          behavior: 人类的行为
        */
        var Human = function (person, behavior) {
            this.person = person;
            this.behavior = behavior;
        }
    //人的属性
        var Person = function (name, age, sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    //行为类
        var Behavior = function () {
        }
    Behavior.prototype = {
            courstructor: Behavior,
    //尿尿的行为
            pee: function () {
            }
        };
    //一般男生的行为
        var MaleBehaior = function (){
        }
    MaleBehaior.prototype = Object.create(Behavior.prototype, {
            pee: { 
                    writable:true, 
                    configurable:true, 
                    value: function () {
                        console.log('站着尿尿');
                    } 
                }
        });
    //一般女生的行为
        var FeMaleBehaior = function (){
        }
    FeMaleBehaior.prototype = Object.create(Behavior.prototype, {
            pee: { 
                    writable:true, 
                    configurable:true, 
                    value: function () {
                        console.log('蹲着尿尿');
                    } 
                }
        });

    基本类都构造完毕了,现在看下lilei是怎么实例出来的:

       var lilei = new Human(new Person('lilei', 20, 'male'), new FeMaleBehaior());
    //此时,lilei就是蹲着尿尿的,lilei虽然是男生,但是他喜欢女生的各种行为。
        lilei.behavior.pee();
    var hanleilei = new Human(new Person('lilei', 20, 'female'), new FeMaleBehaior());
    //hanleilei是萌妹子
        hanleilei.behavior.pee();
    var peter = new Human(new Person('lilei', 20, 'female'), new MaleBehaior());
    //perter是纯爷们
        perter.behavior.pee();

    此时,职责就分明了,Person负责个人的基本属性,Behaior负责行为,各自直接就完全解耦了。

    虽然上面例子解耦了属性与行为,但是如果粗粒度来分析,Male类与Female类其实也符合单一职责原则,Male负责男性个体,Female负责女性个体,并没有违反单一职责原则,所以我们在开发的时候,单一职责原则不能死搬书上的例子,要根据项目的大小与计算以后维护成本来衡量是否要更细粒度的解耦,实现粒度更细的单一职责。

    展开全文
  • 设计模式个人总结,单一职责原则总结。近期自学Unity引擎,学到了关于设计模式这一块,以前学习Java多次接触设计模式,也在应用的开发过程中频繁使用。虽然开发过程中没有特意去强调使用设计模式,但设计模式的使用...
  • 设计模式概述见: http://blog.csdn.net/chijiandi/article/details/78839305单一职责原则的基本概念不要存在多于一个导致类变更的原因。 概念很简单,理解起来就是:一个类只负责一个功能。为什么要遵守单一职责...
  • 设计模式思想

    千次阅读 2011-04-16 22:41:00
    1.单一职责:就一个类而言,应该仅有一个引起它变化的原因。职责要单一。否则如果一个代码块完成了超过一件的事情,意味着这段代码的移植性受到了影响,因为一次移植就打包移动了两段逻辑。而且不稳定,因为可能任何...
  • 面向对象思想设计原则 单一职责原则 开闭原则 里氏替换原则 依赖注入原则 接口分离原则 迪米特原则 设计模式的分类 简单工厂模式 简单工厂模式概述 工厂方法模式 工厂方法模式概述 单例设计模式 单例设计模式概述 ...
  • 解读设计模式--单一职责原则

    千次阅读 多人点赞 2011-07-01 08:43:00
    认识单一职责原则  单一职责原则是面向对象设计中最重要的原则之一,而面向对象最基础的东西就是类和对象的使用,而单一职责可以说是对类和对象的一种要求,也就是要求类应该有且仅有一个引起它变化的原因。  开...
  • 设计模式六大原则(1):单一职责原则

    万次阅读 多人点赞 2012-02-21 09:52:56
    定义:不要存在多于一个导致类变更的原因。...解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也
  • 如何通俗理解设计模式及其思想

    万次阅读 多人点赞 2018-07-08 20:36:52
    本文由 玉刚说写作平台 提供写作赞助 原作者:却把清梅嗅 ... 版权声明:本文版权归微信公众号 玉刚...数据结构,算法,设计模式被认为是程序员必备技能的三叉戟,如果说编程语言的语法特性和业务编码能力是【术】,...
  • 当我们在软件设计中想应用设计模式时,往往是凭借设计模式的名字和需求有点类似,之后就尝试着将模式生搬硬套到其中。而真正去理解设计模式往往变得比较困难,很多书籍也仅仅是用不同方法来降低模式记忆的强度。难道...
  • 设计模式之6大原则(1)-单一职责原则

    千次阅读 2014-04-04 11:41:16
    现在回过头来总结一下,争取降低模块之间的耦合,体现“高内聚 低耦合”的原则,在这里就抛砖引玉,引出设计模式的6大设计原则,该六大原则源自《设计模式之禅》一书,笔者刚毕业那会简直看不懂,现在看起来感觉说...
  • 1、单一职责原则 ( SRP ) 2、开闭原则 ( OCP ) 3、里氏替换原则 ( LSP ) 4、依赖倒置原则 ( DIP ) 5、接口隔离原则 ( ISP ) 6、最少知道原则(迪米特原则) 7、合成/聚合复用(CARP) 三、创建型模式 ( 5种 ) ...
  • 一、什么是单一职责原则单一职责原则(SRP:Single responsibility principle)又称单一功能原则,其定义为:一个类,应该只有一个可以导致变化的原因。光看概念会让人很头疼,我先讲点小例子吧:二、单一职责原则能...
  • 设计模式思想摘要

    千次阅读 2015-01-06 16:29:05
    模式是人们根据以往的经验总结出来的,可以重复使用的设计方案。也就是说,模式是一种记录在案的、经过实践检验过的设计经验,可以为在特定设计背景下的类似的问题提供一种通用解决方案。 在软件工程领域,根据开发...
  • 定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。 遵循单一职责原的优点有: 1、可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定...单一职责原则不只是面向对象编程思想所特有
  • 【设计模式单一职责原则 & 开放封闭原则

    千次阅读 热门讨论 2016-04-17 21:21:14
    *拍UFO~~单一职责原则 故事背景:智能手机功能强大,但是当生活就敲到遇到了传说的UFO,手机相机却掉链子了。 并没有摄像机照相机那么好的像素,拍照功能不是最佳。 定义:就一个类而言,应有一个引起它的变化 ...
  • 定义:不要存在多于一个导致类变更的原因。...**解决方案:**遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当...
  • 设计模式的顶层设计思想分析

    千次阅读 2018-09-28 13:37:10
     五是单一职责原则(Single Responsibility Principle),强调一个类只负责一个功能领域中的相应职责,应用场景是一个类是一组相关性很高的函数、数据的封装,比如单例模式可以降低内存的开销。  六是迪米特...
  • 定义:不要存在多于一个导致类变更的原因。...解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2
  • 面向对象思想设计原则 •在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则 •单一职责原则 •开闭原则 •里氏替换原则 •依赖注入原则 •接口分离原则 •...
  • 现在的软件行业已经烂了,干了一两年,学了点23种设计模式,就是在简历上写上精通软件设计模式,深入了解SOA、OOP和OOD等编程思想,针对这个问题面试中我就提到既然精通设计模式了那设计模式的设计原则有几种分别是...
  • 第4章 设计模式思想前面一章通过一个简单的需求的变化过程完整地介绍了软件重构的过程,重构所引入的设计思路,设计模式的引入,以及最终解决方案的实现过程。还是按照那位名人的说法:了解设计模式的演化过程远比...
  • 设计模式六大原则1—单一职责原则

    千次阅读 2012-08-10 13:12:47
    单一职责原则(SingleResponsibility Principle ,SRP) 定义:应该有且只有一个原因引起类的变更。 问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致...
  • 设计模式原则之一:单一职责原则

    千次阅读 2013-05-06 11:03:30
    一个优良的系统设计,强调模块间保持低耦合、高内聚的关系,在面向对象设计中这条规则同样适用,所以面向对象的第一个设计原则就是:单一职责原则(SRP,Single Responsibility Principle)。  单一职责,强调的是...
  • 单一的日志文件可能会增长到很大,并且在程序启动时读取从而成为性能瓶颈。老的日志需要定时清理,但是对于一个大文件进行清理操作很费劲。 解决方案 将单一日志切分为多个,日志在达到一定大小时,会切换到新文件...
  • 一、什么是单一职责原则 单一职责原则(SRP:Single responsibility principle)又称单一功能原则,其定义为:一个类,应该只有一个可以导致变化的原因。光看概念会让人很头疼,我先讲点小例子吧: 二、单一职责...
  • 定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。 问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改...解决方案:遵循单一职责原则。分别建立两

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,879
精华内容 27,951
关键字:

思想模式单一