精华内容
下载资源
问答
  • 代码设计应遵循的基本原则
    千次阅读
    2018-09-06 13:59:58

    1提高编码质量,代码可读性和可维护性。

    2代码编写规范

    2.1 删除所有无用代码
    2.2 必须给代码添加注释,一个类的注释字数不得小于代码的百分之20%
    2.3 建议遵循30秒原则。如果另一个程序员无法在三十秒内无法知道你的函数在做什么,如何做以及为什么要这样做,那么说明你的代码是难于维护的,需要得到提高。
    2.4 一个函数的代码长度不允许超过100行,超过一百行的函数建议在不破坏原子性的基础上进行拆分。
    2.5 变量都应在方法或者类的头部集中定义
    2.6 保证一行代码只做一件事
    2.7 使用括号来控制操作符的运算顺序,以免使用java默认的操作符优先级顺序。
    2.8 代码格式化:对代码进行格式化,再进行提交。
    2.9 接口不允许没有方法或者变量的声明

    1. 命名规范
      3.1 各种标识符的命名要使用有实际意义的英文单词或者英文单词缩写,缩写词及英文单词要收录在项目的简写词汇表中。切忌使用阿拉伯数字和拼音进行命名。
      3.2 类名:首字母大写,每个单词首字母都需要大写。
      3.3 方法名:首字母小写,其余单词首字母都需大写。
      3.4 全局变量,和常量名称要求全部字母大写。
      3.5 参数名称与局部变量基本相同,区别在于参数名称需要加上冠词a ,an 或者在单词结尾以s结束。

    2. 注释规范
      4.1 注释需要注意的事项:
      ★注释应该用中文清晰表达意思,应该是程序看起来更清晰,更容易理解
      ★注释要尽量简明,避免装饰性的注释。
      ★注释不但要说明做什么,还应当说明为什么要这样做。最好先写注释表明要做什么,再进行编码。

    4.2 类的注释
    ★类的用途,目的。包括其他人感兴趣的介绍。
    ★已知bug,当然最好是修改好所有的错误,但有时可能暂时没有办法修改,或者没有时间修改。
    ★开发和维护该类的历史列表,记录每一次修改的作者,日期,修改的内容。
    ★列举类的各种稳定状态,说明调用成员函数使类的状态产生的变迁(可选)。
    ★同步问题(可选)
    ★对主要的算法必须加以说明,主要流程必须给予引导性说明
    标准格式:
    如果对已经版本话的类进行了修改,需要按照如下格式为每一次修改附加修改历史记录:
    // 修改人 + 修改日期
    // 修改说明 范例:

    // 李四 2010/07/02
    // 添加错误数据修改后继续批量保存的处理函数 saveBatch(
    @Bind(key = “itemParams”, defaultValue = “”) String itemParams,
    @Bind(key = “pid”, defaultValue = “”) String pid)。
    // 王小二 2010/07/02

    4.3 接口注释:
    ★接口的注释风格基本与类的注释风格相同;
    ★在别人使用接口之前,必须了解接口所包含的概念。检验一个接口是否应该定义的简单方法是:你是否能★够容易的描述接口的用途;
    ★接口如何应当和不应当被使用。开发者需要知道该接口如何被使用,也希望知道该接口不能被怎样使用。

    4.4 函数的注释
    ★函数头注释必须包括:函数执行了什么功能,为什么要这样处理;函数处理过程中对对象的哪些属性
    ★可能进行更改;函数执行前后,对象的状态;
    ★比较、循环等控制结构加注释(可选);
    ★在代码的功能并非一目了然的情况下,应当说明为什么要这样做;
    ★局部变量必须加注释;
    ★复杂难写的代码必须加注释;

    4.5类属性的注释:
    ★描述域的用途。使别人知道如何去使用它;
    ★对于有着复杂事物规则的域,可以加入范例来说明。有时候一个简单的小例子,抵的上千言万语;

    更多相关内容
  • 代码设计原则

    2019-08-02 17:22:14
    单一原则 就一个类而言,应该仅有一个引起它变化的原因。具体说,在做编程的时候,很自然的回个一个类加上各种各样的功能。这样意味着,无论任何需求要来,都需要更改这个类,这样其实是很糟糕的,维护麻烦,复用不...

    单一原则

    就一个类而言,应该仅有一个引起它变化的原因。具体说,在做编程的时候,很自然的回个一个类加上各种各样的功能。这样意味着,无论任何需求要来,都需要更改这个类,这样其实是很糟糕的,维护麻烦,复用不可能,也缺乏灵活性。如果一个类承担的职责过多,就等于把这些职责耦合起来,一个职责变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致设计很脆弱,当变化发生时,设计会遭到很多意想不到的破坏。
    定义:一个类或者一个接口,最好只负责一项职责。
    代码实现:尽量避免一个方法里面写过多的 if 完成不同的操作导致逻辑过于复杂

    代替原则(里氏代换原则):

    派生类(子类)对象能够替换其基类(父类)对象被调用。这条原则主要是说,在程序中,任何调用基类对象实现的功能,都可以调用派生类对象来替换,当然,反过来是不行的。其实这里主要说的是继承问题,既然派生类继承基类,那它的对象也应该相应继承基类对象的实现,当然也就因该能替换基类对象。如果无法替换,就说明这个派生类继承有问题,需要修改设计。
    在使用基类的地方可以任意使用其子类,能保证子类完美替换基类;这一种精神其实是对继承机制约束规范的体现。在父类和子类的具体实现中,严格控制继承层次中的关系特征,以保证用子类替换基类时,程序行为不发生问题,且能正常进行下去。
    对于继承来说,父类定义了一系列的规范和契约,虽然不强制所有的子类必须遵从,但是如果子类对这些非抽象方法任意修改,就会对整个继承体系造成破环。
    定义:一段程序原本执行A类的方法,后面需要使用B类代替A类,则衍生出一个基类让A和B都继承此类,则B类可以完全替代A类
    代码实现

    • 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法;
    • 子类可以增加自己特有的方法;
    • 当子类的方法重载父类的方法时,方法的形参要比父类方法的输入参数更佳宽松;
    • 当子类的方法实现父类的抽象方法时,方法的返回值要比父类更加严格;

    依赖倒转原则:

    这条原则说的是程序设计应该依赖抽象接口,而不应该依赖具体实现。经常听到的接口编程思想,其实说的主要就是这个原则。道理也很简单,接口是稳定的,实现是不稳定的。这也要求,一旦接口确定,就不应该再进行修改了。而根据接口的实现,是可以根据具体问题和情况,采用不同的手段去实现。
    定义

    • 低层模块尽量都要有抽象类或者接口,或者两者都有;
    • 变量的声明类型尽量是抽象类或者接口;
    • 使用继承时遵循里氏替换原则;

    代码实现
    两个类同时继承一个基类,同时重写一个抽象方法
    写调用方法调用父(基)类,测试执行方法传入不同的子类得到不同的返回值

    接口隔离原则:

    接口隔离是说,使用多个隔离接口,比使用单个接口要好,还是一个降低类之间耦合度的意思。经常提到的降低耦合,降低依赖,主要也是通过这个原则来达到的。另外,这样设计接口也可以给使用者带来方便,因为,越小的接口,就越好实现,复用性也越高。
    定义

    • 一个接口只服务于一个子模块或业务逻辑,服务定制;
    • 通过业务逻辑压缩接口中的public方法,让接口看起来更加精悍;
    • 已经被污染了的接口,尽量修改,如果变更风险太大,则用适配器模式进行转化;
    • 根据具体的业务,深入了解逻辑,用心感知去控制设计思路;

    代码实现:当多个类实现一个庞杂的接口,每个类并不需要实现接口的每一个方法时,则拆分成多个接口,让每个类只继承所需实现方法的接口

    最少原则(迪米特法则)

    一个实体应当尽可能少的与其他实体之间发生相互作用。这样做的目的在于减少依赖,独立功能,以便更好的复用。
    合成/聚合复用原则:
    在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分,新的对象通过这些对象的委派达到复用已有功能的目的。设计原则是:尽量使用合成/聚合,尽量不要使用继承。
    定义:一个实体应当尽可能少的与其他实体之间发生相互作用。这样做的目的在于减少依赖,独立功能,以便更好的复用。
    代码实现:调用不是直接朋友(返回值,成员变量,参数)的类的方法时,要把该方法写在此直接朋友中

    开闭原则:

    程序的设计应该是不约束扩展,即扩展开放,但又不能修改已有功能,即修改关闭。因为在软件生命周期内,经常会出在原有功能基础上扩展新功能。这时,不能因为软件已经上线,不扩展新功能,但也不能直接修改旧的功能。正确的做法是,在原有功能上,扩展一个新的功能,新的需求依赖新的功能去实现。这样就既保证了老功能不受影响,有扩展了新功能。开闭原则一条非常重要的原则,可以说其它原则的基石。
    定义:一个软件实体如类、模版和函数应该对扩展,对修改关闭;

    解决方案:当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是修改已有的代码来实现变化;
    单一职责原则:实现类要职责单一;
    里氏替换原则:不要破坏继承体系;
    依赖倒置原则:面向接口编程;
    接口隔离原则:设计接口的时候要精简单一;
    迪米特法则:降低耦合;
    开闭原则:总纲,对扩展开放,对修改关闭;

    代码实现:在以上原则的基础上,只新加一个类继承基类,实现新方法

    额外知识
    类之间的关系:

    继承:指的是一个类(称为子类)继承另外的一个类(称为基类)的功能,并增加它自己的新功能的能力,继承是类与类之间最常见的关系。
    聚合:指的是整体与部分的关系,通常在定义一个整体类后,再去分析这个整体类的组成结构。从而找出一些组成类,该整体类和组成类之间就形成了聚合关系。
    组合:也表示类之间整体和部分的关系,但是组合关系中部分和整体具有统一的生存期。一旦整体对象不存在,部分对象也将不存在。部分对象与整体对象之间具有共生死的关系。
    关联:指的是模型元素之间的一种语义联系,是类之间的一种很弱的联系。关联可以有方向,可以是单向关联,也可以是双向关联。一般情况是一个类的方法参数是另一个类的实例对象。

    其关系强弱为 关联<聚合<组合<继承

    展开全文
  •  无论系统是采用电池供电还是由市电供电,应用需求将决定存储器的类型(易失性或非易失性)以及使用目的(存储代码、数据或者两者兼有)。另外,在选择过程中,存储器的尺寸和成本也是需要考虑的重要因素。对于较小...
  • 代码设计的六大原则

    万次阅读 2018-07-03 15:17:27
    现在主要针对的是代码设计原则,在设计代码的时候,不能总是想到哪就打到哪,还需要有个大致的流程,否则写出来的代码也是很繁冗,不够简洁。对于自己的代码编程还没达到一个期望的程度,对于代码的设计。主要注意...

    开了博客,为了能够更好的学习,对于自己不了解和还没有掌握的知识加以归类,巩固以及加强。

    现在主要针对的是代码设计的原则,在设计代码的时候,不能总是想到哪就打到哪,还需要有个大致的流程,否则写出来的代码也是很繁冗,不够简洁。对于自己的代码编程还没达到一个期望的程度,对于代码的设计。主要注意以下的六大原则:

    单一职责

    一个类或者一个接口,最好只负责一项职责。

    开闭原则

    一个软件实体如类、模版和函数应该对扩展,对修改关闭;

    里氏替换原则

    子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法; 
    * 子类可以增加自己特有的方法; 
    * 当子类的方法重载父类的方法时,方法的形参要比父类方法的输入参数更佳宽松; 
    * 当子类的方法实现父类的抽象方法时,方法的返回值要比父类更加严格;

    依赖倒置原则

     低层模块尽量都要有抽象类或者接口,或者两者都有; 
    * 变量的声明类型尽量是抽象类或者接口; 
    * 使用继承时遵循里氏替换原则;

    接口隔离原则

    * 一个接口只服务于一个子模块或业务逻辑,服务定制; 
    * 通过业务逻辑压缩接口中的public方法,让接口看起来更加精悍; 
    * 已经被污染了的接口,尽量修改,如果变更风险太大,则用适配器模式进行转化; 
    * 根据具体的业务,深入了解逻辑,用心感知去控制设计思路;

    迪米特原则

    定义:一个对象应该对其他对象保持最少的了解,其核心精神就是:不和陌生人说话,通俗之意就是一个对象对自己需要耦合关联调用的类应该知道的少;这会导致类之间的耦合度降低,每个类都尽量减少对其他类的依赖。

    展开全文
  • 代码设计的几个基本原则

    千次阅读 2017-04-06 17:32:14
    Software entities should be open for extension,but closed for modification,(在设计一个模块的时候,应当使这个模块可以在不被修改的前提下扩展)。 对扩展开放open,对修改关闭close。 如何实现?1,抽象化是...

    1、OCP(Open-Close Principle)开闭原则

     

    Software entities should be open for extension,but closed for modification,(在设计一个模块的时候,应当使这个模块可以在不被修改的前提下扩展)。

    对扩展开放open,对修改关闭close。

    如何实现?1,抽象化是关键,2对可变性的封装原则(Principle of Encapsulation of Variation EVP)。3.对可能的拓展预留接口

    备注:

    1) 对于抽象化, 我的理解是, 接口是相对稳定的, 实现是根据需求多变的。对于大多数可能预料的变化点, 我们可以抽取出共性或者常态点, 进行接口的封装, 而选择不同的实现类嵌入模块, 从而达到可扩展的作用。

    2) 对于某个业务点, 可能以后有多种介入处理的情况, 那么这时候可以将业务抽象成事件(event)接口和监听器(listener)接口, 不同的处理需求生成不同的listener, 接入模块的listener收集器, 从而得到业务点的介入机会。最后达到功能的扩展。

    典型容易理解的例子,工厂模式。当需要新增加一个类的时候,直接继承product接口就可以了 , 由工厂类来组装产生需要的product, 而不用大范围修改原有代码。OCP~

    2、Liskov Subsitution Principle(LSP)里氏代换原则

     

    就是子类可以代替父类出现的任何地方,在抽象的时候,重要的要理解的一个地方两个类之间是什么关系,是“has-A”?还是“Is-a”的关系。在 “has-a”的关系中,两个类存在的是依赖的关系(在类A里面存在类B的的变量);在“Is-a”的关系中,可以提取这两个类的“共同代码”放在抽象类 C中,然后A,B继承与C,这也是一种重构。

    3、Dependency Inversion Principle(DIP)依赖倒转原则

     

    就是在我们编程的时候方法的参数类型,变量,对于其他具体类的依赖,我们尽量的使用抽象类。

    就是说尽量依赖于抽象,而不是依赖于实现。

    在书中两种表述:

    (1)Abstraction should not depend on details.details should depend on abstraction。(抽象不应当依赖于细节,细节应当依赖于抽象)。

    Abstraction就像是建筑物的基础,而其实现类就是在基础上面一层一层的往上面走。你拆掉最上面 那层,和拿走最下面的基础,有什么不同了,这就是差异了。所以Abstraction是要相当的稳定,是维护的重点。也正是因为稳定,所以我们尽量的依赖 于Abstraction,既是稳定系统,也是灵活系统。

    (2)Program to an Interface,not an implementation(要针对接口编程,不要针对实现编程)

    应当使用java接口和抽象java类进行变量的类型声明,参数的类型声明,方法返回值的类型和数据类型的转换。

    备注:

    依赖倒转原则的作用在于多模块或者类间有统一的”知识”, 都知道有这个接口, 都知道这个接口是这样用,会返回什么数据。

    至于最初的实现类是什么, 只有提供该接口功能的实现类自己关心, 其他模块或者类只管用就行了。即使以后需求更改, 实现会换成别的一个, 其他模块和类也无需修改代码。

    例如A模块提供了一个接口是: List getProducts()

    而B和C会使用该模块, 他们只知道这个方法就会返回List , 他们知道List和Product代表什么.

    但他们不会管你的接口内部是使用List list = new ArrayList() , 还是List lis = new LinkedList()

    或者具体的Product是什么(可能是衣服,鞋子等)

    4、Interface Segregation Principle(ISP)接口隔离原则

     

    限制一个实体对另一个实体通信时候的宽度。

    就是一个类对另外一个类依赖的时候,应当是建立在最小的接口上面。对于接口隔离原则来说,有两种接口,一种是真正意义上面的“java 接口”Interface;另外一种是指一个类的方法的集合。对于这来两种有,两个接口隔离的原则,对于一个类里面的方法的集合的接口隔离,我们称作是 “角色隔离原则”;另外一种叫做“定制服务”。

    定制服务,就是一个类,我给你这个客户端一些方法,我放在一个java接口(Interface)里面。给另外一个客户端另外一些方法,放在另外一个接口(Interface)。

    角色隔离原则,是指客户端要多个不同的类的方法,我们就搞几个不同类别的接口(Interface),在书中,这么比喻的,就相当于电影剧本里面的人物,我们找人来演,这个人就是具体的类。这就叫做角色隔离原则。

    5、Composition/Aggregation Reuse Principle(CARP)组合/聚合复用原则

     

    就是说要尽量的使用合成和聚合,而不是继承关系达到复用的目的。

    其实这里最终要的地方就是区分“has-a”和“is-a”的区别。相对于合成和聚合,继承的缺点在于:父类的方法全部暴露给子类。父类如果发生变化,子类也得发生变化。聚合的复用的时候就对另外的类依赖的比较的少。

    6、Least Knowledge Principle(LKP)最少知识原则,又称为“Law of Demeter”迪米特原则

     

    和ISP接口隔离原则一样,限制类与类之间的通信。ISP限制的是宽度,而LoD迪米特原则限制的是通信的广度和深度。

    LoD在广度上面,尽量减少远距离类的关联,而使用与自己有关的类,并且也与远距离类有关的类。

    可是这种做法有一点麻烦。多个远距离类产生关联的时候,不怎么容易处理,所以增加一个远距离类的抽象类。所有的远距离类都是通过抽象类的形式来访问。

    在深度上面,控制权限是最重要的,对于类,一个是default 和public,尽量最小权限;对于成员,private,default,protected,public。往上面走,权限越小,依赖的耦合就越小。

    有几种描述:

    (a)Only talk to your immediate friends.

    (b)Don’t talk to strangers.

    设计模式“facade”,”调停者模式”。在这里是IoD的典型表现。

    备注:

    当一个系统比较大的时候, 如果所有的模块都自己去寻找与自己相关的类的时候, 那么引用关系就会变得极度复杂, 耦合度高。

    这个时候最好就设定一个为各个模块所熟悉的对象, 例如Context容器。

    另外,各个模块可以应用facade模式, 提供一个简单的对外接口, 并将其嵌入Context容器。

    这样, 模块间通过熟人Context来获取其他模块的Facade接口, 即符合依赖倒转原则, 接口隔离原则和迪米特原则。

    展开全文
  • 代码设计 六大原则

    万次阅读 2016-07-02 02:13:22
    单一职责原则 Single Responsibility Principle定义:一个类...解决方法:遵循单一职责原则。分别建立新的类来对应相应的职责;这样就能避免修改类时影响到其他的职责; 当遇到职责扩散的时候,在逻辑足够简单的时候,
  • 因此,高内聚、低耦合是一个软件系统设计中必须遵循基本原则。  所谓高内聚,是指一个软件模块内各个元素彼此结合的紧密程度要高,即一个软件模块是由相关性很强的代码组成,只负责一项任务,也就是常说的单一...
  • 1、保持简单和直接原则(KISS) KISS:Keep it simple,stupid。 在软件开发过程中,把简单作为主要目标,避免做一些没有必要的复杂工作。 2、不需要原则(YAGNI) YAGNI:You Aren’t Gonna Need It 不要写目前用不上,...
  • 需要我们在平时代码开发中注意代码设计模式和开发规范。总结了我们常用的java开发的规范的几个原则。 一.单一职责原则 单一原则定义为一个类最好只是负责一个功能领域中的相应职责,或者可以定义为:就一个类而言...
  • 面向对象设计六大基本原则

    千次阅读 2020-12-22 23:20:34
    面向对象设计模式六大基本原则 本篇开始介绍面向对象设计思想 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录面向对象设计模式六大基本原则前言一、pandas是什么?二、使用步骤1.引...
  • Java设计模式之七大设计原则

    千次阅读 2022-04-28 01:28:48
    Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍,提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的: 代码可重用性:相同功能的代码,不用多次编写。 ...
  • 代码设计的几个基本原则

    千次阅读 2014-06-27 18:52:16
    Software entities should be open for extension,but closed for modification,(在设计一个模块的时候,应当使这个模块可以在不被修改的前提下扩展)。 对扩展开放open,对修改关闭close。 如何实现?1,抽象化是...
  • 在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。 2...
  • 设计模式六大原则(1):单一职责原则 设计模式六大原则(2):里氏替换原则 设计模式六大原则(3):依赖倒置原则 设计模式六大原则(4):接口隔离原则 设计模式六大原则(5):迪米特法则 设计模式六大原则...
  • 软件设计的七大原则

    2022-01-27 16:30:52
    在实际开发过程中,并不是一定要求所有代码遵循设计原则,而是要综合考虑人力、时间、成本、质量,不刻意追求完美,要在适当的场景遵循设计原则。这体现的是一种平衡取舍,可以帮助我们设计出更加优雅的代码结构。...
  • 软件设计的七大原则——超详细

    千次阅读 2020-04-05 21:33:16
    设计原则是软件设计模式必须尽量遵循原则,各种原则要求的侧重点不同。其中: 开闭原则是总纲,它告诉我们要对扩展开放,对修改关闭; 里氏替换原则告诉我们不要破坏继承体系; 依赖倒置原则告诉我们要面向接口...
  • 工作至今没有认真读过什么书,觉得太浮躁,待业在家,希望自己可以珍惜这段时光,人生中最轻松愉快的时刻,当然还有个任务就是——毕业设计,=-=,无论如何,希望自己待业这段时间可以认真读几本书,好好做分享,...
  • 数据库设计遵循原则

    千次阅读 2019-10-07 17:29:37
    1NF 是关系模式具备的最起码的条件,如果数据库设计不能满足第一范式, 就不能称作是关系模式;关系数据库设计研究的关系规范化是在1NF基础之上进行的。 第二范式: (Second Normal Form) 概述  若...
  • 设计的五项基本原则

    千次阅读 2019-04-10 15:51:35
    设计的五项基本原则 面向对象设计(OOD)是面向对象编程(OOP)必不可少的一个环节,只有好的设计,才能保障程序的质量。面向对象设计的主要任务就是类的设计,不少面向对象(OO)的先驱和前辈已经提出了很多关于...
  • 1. 软件设计模式的概念 软件设计模式(Software Design Pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、...2. 软件开发设计过程中需要遵循原则 在软件开发中,为了提高软件系统...
  • 面向对象设计的五项基本原则

    千次阅读 2017-02-13 22:28:58
    面向对象设计的主要任务就是类的设计,不少面向对象(OO)的先驱和前辈已经提出了很多关于类的设计原则,用于指导OOP,其中就包括类设计的五项基本原则。1.单一职责原则(Single Resposibility Principle,SRP)专注...
  • 开闭原则:对外开放,对修改关闭。 里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立。 依赖倒置原则:要面向接口编程,不要面向实现编程。 单一职责原则:控制类的粒度大小,将对象解耦,提高其内聚...
  • 组件设计原则

    千次阅读 2021-03-10 18:40:28
    下面就结合面向对象设计原则,和开发中的实践经验,总结一部分组件开发需要注意的几个原则原则 1、保持简单 (KISS—Keep It Simple, Stupid,Straightforward) 代码足够简单,也意味着易读、易维护,bug 比较...
  • 设计模式所遵循基本原则共有单一职责原则,开闭原则,接口隔离原则,里氏替换原则,依赖倒置原则,避免重复性开发原则,将复杂问题拆分成简单问题原则,迪米特原则这八大原则。
  • 了解面向对象的思想时,之前仅仅了解了面向对象的三大特性,最近才发现原来面向对象在编程时还有五道金科玉律,这五大基本原则不必一定要遵守,但如《OOD启示录》中所说的:“你并不必严格遵守这些原则,违背它们也...
  • 设计模式之面向对象七大基本原则

    万次阅读 多人点赞 2015-04-27 16:25:48
    概述在运用面向对象的思想进行软件设计时,需要遵循原则一共有7个,他们是:1. 单一职责原则(Single Responsibility Principle)每一个类应该专注于做一件事情。2. 里氏替换原则(Liskov Substitution Principle...
  • 设计模式六大原则.doc

    2020-05-06 22:41:28
    设计模式六大原则(1):单一职责原则 设计模式六大原则(2):里氏替换原则 设计模式六大原则(3):依赖倒置原则 设计模式六大原则(4):接口隔离原则 设计模式六大原则(5):迪米特法则 设计模式六大原则...
  • 主要介绍了解析Java编程中设计模式的开闭原则的运用,开闭原则多应用于Java程序的扩展开发方面,需要的朋友可以参考下
  •  设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计 模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于...
  • 主要介绍了Java设计模式编程中的开闭原则,开闭原则的大意被作者总结为用抽象构建框架,用实现扩展细节,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,081
精华内容 43,632
关键字:

代码设计应遵循的基本原则