精华内容
下载资源
问答
  • OO原则

    热门讨论 2015-10-08 20:55:50
    在看《HeadFirst》的过程中发现了OO原则和之前学过的《大话设计模式》有点不一样的的地方。总结一下,分享给大家。 首先我们来看《大话设计模式》里的六大原则。也可以访问之前的博客《23种设计模式》。 1...

    在看《HeadFirst》的过程中发现了OO原则和之前学过的《大话设计模式》有点不一样的的地方。总结一下,分享给大家。


    首先我们来看《大话设计模式》里的六大原则。也可以访问之前的博客《23种设计模式》


    1、开放-封闭原则,是说软件实体(类、模块、函数等等)应该可以扩展,但是不可修改。
    2、单一职责原则(SRP),就一个类而言,应该仅有一个引起它变化的原因。
    3、依赖倒转原则:A. 高层模块不应该依赖低层模块。两个都应该依赖抽象。B. 抽象不应该依赖细节。细节应该依赖抽象。
    4、里氏代换原则(LSP):子类型必须能够替换掉它们的父类型。
    5、合成/聚合复用原则(CARP),尽量使用合成/聚合,尽量不要使用类继承。
    6、迪米特法则(LoD),如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。



    再来看看《HeadFirst》中的原则,比《大话设计模式》多出了三个原则。


    1、找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
    2、针对接口编程,而不是针对实现编程
    3、多用组合,少用继承
    4、为交互对象之间的松耦合设计而努力
    5、开放-封闭原则:类应该对扩展开放,对修改关闭
    6、依赖倒置原则:依赖抽象,不要依赖具体类
    首先,这个原则听起来很像是“针对接口编程,不针对实现编程”,不是吗?的确很相似,然而这里更强调“抽象”。这个和原则说明了:不能让高层组件依赖低层组件,而且,不管高层或低层组件,“两者”都应该依赖于抽象。
    7、最少知识原则:只和你的密友谈话。
    最少原则告诉我们要减少对象之间的交互,只留下几个“密友”。希望我们在设计中,不要让太多的类耦合在一起,免得修改系统中的一部分,会影响到其他部分。如果许多类之间互相依赖,那么这个系统就会变成一个易碎的系统,它需要花许多成本维护,也会因为太复杂而不容易被其他人了解。
    8、好莱坞原则:别调用(打电话给)我们,我们会调用(打电话给)你。
    好莱坞原则可以给我们一种防止“依赖腐败"的方法。当高层组件依赖低层组件,而低层组件又依赖高层组件,而高层组件又依赖边侧组件,而边侧组件又依赖低层组件时,依赖腐败就发生了。在这种情况下,没有人可以轻易地搞懂系统是如何设计的。
    在好莱坞原则之下,我们允许低层组件将自己挂钩到系统上,但是高层组件会决定什么时候和怎样使用这些低层组件。换句话说,高层组件对待低层组件的方式是“别调用我们,我们会调用你”。
    9、一个类应该只有一个引起变化的原因。
    我们知道要避免类内的改变,因为修改代码很容易造成许多潜在的错误。如果有一个类具有两个改变的原因,那么这会使得将来该类的变化几率上升,而当它真的改变时,你的设计中同时有两个方面将会受到影响。为了解决这个问题,我们将一个责任只指派给一个类。


    小结:
                学设计模式的时候我们应该搞清楚设计模式和原则之前是什么样的关系。设计代码首先是要遵循这些原则的。那些牛人们通过用这些原则来设计代码总结出来的经验最终成了我们熟知的设计模式。

            

    展开全文
  • OO原则汇总

    2018-07-23 20:28:00
    OO原则汇总 SOLID原则:http://www.cnblogs.com/lanxuezaipiao/archive/2013/06/09/3128665.html https://www.cnblogs.com/adam/category/85782.html https://www.cnblogs.com/zhenyulu...

    SOLID原则:http://www.cnblogs.com/lanxuezaipiao/archive/2013/06/09/3128665.html

     

    https://www.cnblogs.com/adam/category/85782.html

     

    https://www.cnblogs.com/zhenyulu/category/6930.html

     

    http://www.cnblogs.com/shaosks/category/351488.html

    posted on 2018-07-23 20:28 marblemm 阅读( ...) 评论( ...) 编辑 收藏

    转载于:https://www.cnblogs.com/marblemm/p/9356708.html

    展开全文
  • OO原则概览 10.设计模式&OO原则概览 OO基本概念 抽象 封装 继承 多态 OO原则 封装变化 多用组合,少用继承 针对接口编程,不针对实现编程 为交互对象之间的松耦合而努力 设计原则 找出可能...

    10.设计模式&OO原则概览

    1. OO基本概念

      1. 抽象
      2. 封装
      3. 继承
      4. 多态
    2. OO原则

      1. 封装变化
      2. 多用组合,少用继承
      3. 针对接口编程,不针对实现编程
      4. 为交互对象之间的松耦合而努力
    3. 设计原则

      1. 找出可能变化的代码,把他独立封装,不要和那些不需要变化的代码混在一起
      2. 针对接口编程,而不是针对实现编程
    4. 良好的OO设计必须具备三个特性:

      1. 可复用
      2. 可以扩充
      3. 可维护
    5. OO原则是我们的目标,而设计模式是我们的做法

    6. 模式是被认为是历史验证的OO设计经验

    7. 大多数模式和原则,都着眼于软件变化的主题

    8. 知道抽象、继承、封装、多态并不会让你成为好的面向对象的设计者,设计应该更关注建立弹性的设计,可以维护,可以应对变化

    9. 举例

      1. 类图

      类图

      1. 代码

        1. Duck

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/17 上午8:11
           */
          public abstract class Duck {
              private Flyable flyable;
              private Quackable quackable;
          
              public Flyable getFlyable() {
                  return flyable;
              }
          
              public void setFlyable(Flyable flyable) {
                  this.flyable = flyable;
              }
          
              public Quackable getQuackable() {
                  return quackable;
              }
          
              public void setQuackable(Quackable quackable) {
                  this.quackable = quackable;
              }
          
              public void swim() {
                  System.out.println("swimming.");
              }
          
              public abstract void display();
          
              public void quack() {
                  System.out.println("original quack.");
              }
          
              public void fly() {
                  System.out.println("original fly.");
              }
          }
          
          
        2. MallrdDuck

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/17 上午8:12
           */
          public class MallrdDuck extends Duck {
              @Override
              public void display() {
                  System.out.println("green");
              }
          
              @Override
              public void quack() {
                  this.getQuackable().quack();
              }
          
              @Override
              public void fly() {
                  this.getFlyable().fly();
              }
          }
          
          
        3. RubberDuck

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/17 上午8:17
           */
          public class RubberDuck extends Duck {
              @Override
              public void display() {
                  System.out.println("yellow");
              }
          
              @Override
              public void quack() {
                  this.getQuackable().quack();
              }
          
              @Override
              public void swim() {
                  super.swim();
              }
          
              @Override
              public void fly() {
                  this.getFlyable().fly();
              }
          }
          
          
        4. Flyable

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * Created by presleyli on 2018/10/17.
           */
          public interface Flyable {
              void fly();
          }
          
          
        5. CanFly

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/19 上午7:32
           */
          public class CanFly implements Flyable {
              @Override
              public void fly() {
                  System.out.println("I can fly...");
              }
          }
          
          
        6. CannotFly

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/19 上午7:32
           */
          public class CannotFly implements Flyable {
              @Override
              public void fly() {
                  // do nothing.
              }
          }
          
          
        7. Quackable

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * Created by presleyli on 2018/10/17.
           */
          public interface Quackable {
              void quack();
          }
          
          
        8. CanQuack

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/19 上午7:33
           */
          public class CanQuack implements Quackable{
              @Override
              public void quack() {
                  System.out.println("I can quack...");
              }
          }
          
          
        9. CannotQuack

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/19 上午7:33
           */
          public class CannotQuack implements Quackable{
              @Override
              public void quack() {
                  // do nothing.
              }
          }
          
          
        10. Main

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/17 上午8:14
           */
          public class Main {
              public static void main(String[] args) {
                  MallrdDuck mallrdDuck = new MallrdDuck();
                  mallrdDuck.setFlyable(new CanFly());
                  mallrdDuck.setQuackable(new CannotQuack());
                  mallrdDuck.fly();
                  mallrdDuck.quack();
          
                  RubberDuck rubberDuck = new RubberDuck();
                  rubberDuck.setFlyable(new CanFly());
                  rubberDuck.setQuackable(new CanQuack());
                  rubberDuck.fly();
                  rubberDuck.quack();
          
              }
          }
          
          
        11. Output:

          I can fly...
          I can fly...
          I can quack...
          
    展开全文
  • OO原则总结

    2009-11-17 22:29:08
     基础的OO原则无非有三:  封装变化  多组合少继承  针对接口编程  封装变化:扩展开去,区分系统、子系统、类、方法中易变和不变部分,独立封装,从而从容应对以后的变化,也使系统后续扩展只影响到局部...

          开发设计,不分语言、系统类别,面向对象设计的原则是相通的。

          基础的OO原则无非有三:

    •       封装变化
    •       多组合少继承
    •        针对接口编程

          封装变化:扩展开去,区分系统、子系统、类、方法中易变和不变部分,独立封装,从而从容应对以后的变化,也使系统后续扩展只影响到局部;在系统设计中,把变化与不变的部分独立成类,可以提高类的内聚性,提高系统的应变性,同时也可以类实例的耦合度降低。

          组合:之所以组合由于继承,是因为组合可以轻易使用已有的类,来构建新的属性;组合元素的变化,只要接口不变,对整个系统基本没有影响,而继承,父类的变化直接作用于子类,而且很容易引入副作用,父类中一些冗余的元素也尽在子类中出现。

          接口编程:不仅仅是流行,更是智慧的结晶,接口可以使调用者不关心具体实现,只按照约定行事,避免过于依赖于具体实现而僵硬,而实现者可以透明的更新或优化,给两者一个很好的分界点和协调器;

          其实headfirst系列的设计模式中,也对上述原则列为重中之重,同时她引入更多的设计原则,有些在思路上有重复的,我们不妨认为作者的强调之用。其列出的更多的OO设计原则:

    •       为交互对象间的松耦合而努力;
    •       类应该对扩展开放,对修改关闭
    •       依赖于抽象,不依赖的具体类
    •       只和朋友交谈
    •       别找我,我会找你
    •       类应该只有一个改变的理由。

     

         

    展开全文
  • Flask-restful-api:遵循OO原则,使用SQLAlchemy,jwt身份验证进行简单的API REST
  • OO原则的核心就是把变化的部分取出并封装起来,让其他部分不受变化的影响。减少变化带来的风险。OO基础:抽象 、封装、多态、继承OO设计五大原则 :SRP:单一职责原则。一个类应仅有一个改变的理由。OCP:开闭原则。...
  • OO原则的五大原则

    千次阅读 2016-08-29 23:24:27
    现将近期整理的文档提供给大家,这里对LSP做重点的介绍,望对大家有帮助,在...OO设计的五大原则之间并不是相互孤立的。彼此间存在着一定关联,一个可以是另一个原则的加强或是基础。违反其中的某一个,可能同时违反了
  • OO原则演化

    2010-05-12 20:09:00
    单一职责原则(SRP)一个类,最好只做一件事,只有一个引起它变化的原因SRP由引起变化的原因决定,而不由功能职责决定。相关设计模式:Façade , Proxy专注里氏替换原则(LSP)子类必须能够替代基类在继承关系中,子类...
  • 设计模式之OO原则

    2014-04-04 14:54:17
    OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改关闭。我的理解是,对于一个已有的软件,如果需要扩展,应当在不需修改已有代码的基础上进行。 DIP(依赖倒转原则,Dependence ...
  • 水木上一个人问的关于OO原则的问题,其中涉及到高内聚与松耦合之间的细节区分的内容。发信人: jamen (*******), 信区: SoftEng标 题: 问个概念问题发信站: 水木社区 (Fri Feb 5 13:42:31 2010), 站内A team of ...
  • 一个优秀的程序员,所有的技术都是需要以OO为基础来开始。“OO”表示 “面向对象”。下面是口口相传的OO思想。大家借鉴一下 特性 封装 顾名思义,封装就好比一个小黑屋,内部被隐藏,只有几个接口与外界相连。具体...
  • OO六大设计原则 单一职责原则(SRP) 开放封闭原则(OCP) 里氏替换原则(LSP) 依赖倒置原则(DIP) 接口隔离原则(ISP) 迪米特法则(LOD) 面向对象(OO)的基本特征: 抽象,先不考虑细节 封装,隐藏内部实现 继承,复用现有...
  • 几条简单的OO原则

    2017-07-11 17:58:14
    几条简单的OO原则我们可以熟记于心,但是我们要在编程实践的过程中,不断的提醒自己,要多遵守这样的原则,这样我们写出来的代码才能足够的健壮,我们的代码水平才会不断的提高。这篇文章主要是为了提醒自己,要时刻...
  • 常见的OO原则

    2011-10-16 20:07:50
    封装变化多用组合,少用继承针对接口编程,不针对实现编程为交互对象之间的松耦合设计而努力类应该对扩展开放,对修改关闭只和朋友交谈别找我,我会找你类应该只有一个改变的理由...
  • 设计模式--OO原则

    2010-12-03 09:02:23
    最近在学习《Head First设计模式》,总结并笔记OO设计原则: 1,封装变化 2,多用组合,少用继承 3,针对接口编程,不针对实现编程 4,降低对象间的耦合度 5,为交互对象之间的松耦合设计而努力 6,对扩展开放...
  • 是面向对象的基本原则:1、单一职责一个类应该最多只能有一个因素能够给导致其变化,类中的方法应该都是相关性很高的,即“高内聚”2、里氏替换 利用多态特性,父类作用的地方可以使用其任意子类替代,反之不行3、...
  • 下面的指导方针,能帮你避免在OO设计中违反依赖倒置原则: 1、变量不可以持有具体类的引用。 如果使用new,就会持有具体类的引用。你可以改用工厂来避开这样的做法。 2、不要让类派生自具体类。 如果派生自...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,701
精华内容 9,880
关键字:

oo原则