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

    2020-09-23 14:17:06
    OOP设计原则: OCP(Open-Closed Principle),开放封闭原则:软件实体应该扩展开放、修改封闭。 实现:合理划分构件,一种可变性不应当散落在代码的很多角落里,而应当被封装到一个对象里;一种可变性不应当与另一...

    OOP设计原则

    OCP(Open-Closed Principle),开放封闭原则:软件实体应该扩展开放、修改封闭。
    实现:合理划分构件,一种可变性不应当散落在代码的很多角落里,而应当被封装到一个对象里;一种可变性不应当与另一个可变性混合在一起。

    **DIP(Dependency Inversion Principle),依赖倒置原则:**摆脱面向过程编程思想中高层模块依赖于低层实现,抽象依赖于具体细节。OOP中要做到的是,高层模块不依赖于低层模块实现,二者都依赖于抽象;抽象不依赖于具体实现细节,细节依赖于抽象。
    实现:应该通过抽象耦合的方式,使具体类最大可能的仅与其抽象类(接口)发生耦合;程序在需要引用一个对象时,应当尽可能的使用抽象类型作为变量的静态类型,这就是针对接口编程的含义。

    **LSP(Liskov Substitution Principle),Liskov替换原则:**继承思想的基础。“只有当衍生类可以替换掉基类,软件单位的功能不会受到影响时,基类才真正被复用,而衍生类也才能够在基类的基础上增加新的行为。”

    **ISP(Interface Insolation Principle),接口隔离原则:**接口功能单一,避免接口污染。
    实现:一个类对另外一个类的依赖性应当是建立在最小的接口上的。使用多个专门的接口比使用单一的总接口要好。

    **SRP(Single Resposibility Principle),单一职责原则:**就一个类而言,应该仅有一个引起它变化的原因。 如果一个类的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能会抑止这个类完成其他职责的能力。

    **CARP(Composite/Aggregate Reuse Principle),合成/聚合复用原则:**设计模式告诉我们对象委托优于类继承,从UML的角度讲,就是关联关系优于继承关系。尽量使用合成/聚合、尽量不使用继承。
    实现:在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分,以整合其功能。

    **LoD(Law Of Demeter or Principle of Least Knowledge),迪米特原则或最少知识原则:**就是说一个对象应当对其他对象尽可能少的了解。即只直接与朋友通信,或者通过朋友与陌生人通信。
    朋友的定义(或关系):
    (1)当前对象本身。
    (2)以参量的形式传入到当前对象方法中的对象。
    (3)当前对象的实例变量直接引用的对象。
    (4)当前对象的实例变量如果是一个聚集,那么聚集中的元素也都是朋友。
    (5)当前对象所创建的对象。
    实现:
    (1)在类的划分上,应当创建有弱耦合的类。类之间的耦合越弱,就越有利于复用。
    (2)在类的结构设计上,每一个类都应当尽量降低成员的访问权限。一个类不应当public自己的属性,而应当提供取值和赋值的方法让外界间接访问自己的属性。
    (3)在类的设计上,只要有可能,一个类应当设计成不变类。
    (4)在对其它对象的引用上,一个类对其它对象的引用应该降到最低。
    (5)尽量限制局部变量的有效范围.

    展开全文
  • OOP的六大原则

    2021-01-16 21:47:02
    具有这样特性的oop语言,在进行项目显实现是就容易达到重用性、灵活性和扩展性。 开闭原则(Open Close Principle) 对扩展开放、对修改关闭。这是让我们的系统达到一个可扩展的考量,对扩展放开这个好理解,但对...

    六大原则主要从高内聚、低耦合的考量得出的。主要焦距在抽象、接口、实体的关系间。面向对象编程的三大特性:封装、继承、多态。具有这样特性的oop语言,在进行项目显实现是就容易达到重用性、灵活性和扩展性。

    1. 开闭原则(Open Close Principle)
      对扩展开放、对修改关闭。这是让我们的系统达到一个可扩展的考量,对扩展放开这个好理解,但对修改关闭呢?出现修改极大可能是实体代码出现了问题,那就一定是需要修正的。但在产品流水线上的代码开发,要想修改别人的代码需要走的流程会带来不可预计的成本。所以我一般不去直接修改源码,会去重新做一个继承或实习,通过扩展的开发达到目的。这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为。

    2. 里氏代换原则(Liskov Substitution Principle)
      里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。
      例如正方形我们知道是一类特殊的长方形,但在类的设计时我们会去把一个square继承rectangle吗?很明显的是square只有一个边长属性,而rectangle会有长和宽。所以square不能在别的场合去代替rectangle,square只能自己重新抽象。

    3. 依赖倒转原则(Dependence Inversion Principle)
      这个原则是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。

    4. 接口隔离原则(Interface Segregation Principle)
      这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。由此可见,其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。

    5. 迪米特法则,又称最少知道原则(Demeter Principle)
      最少知道原则是指:一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

    6. 合成复用原则(Composite Reuse Principle)
      合成复用原则是指:尽量使用合成/聚合的方式,而不是使用继承。合成复用原则,要求在软件复用时,要先尽量使用组合或者聚合等关联关系实现,其次才考虑使用继承。也就是在一个新对象里通过关联的方式使用已有对象的一些方法和功能。
      重要性
        通常类的复用可以分为继承和合成,继承复用虽然简单,但是存在很大的缺点:
        (1)耦合度高,父类代码的修改会影响到子类,不利于代码的维护。
        (2)破坏了类的封装性,因为继承会将父类的实现细节暴露给子类,所以又叫做 “白箱” 复用。
        (3)限制了复用的灵活性,从父类继承来的实现是静态的,在运行期是无法改变的。

      合成复用是将已有的对象作为新对象的成员对象来实现,新对象调用已有对象的功能,达到复用:
        (1)不会破坏封装性,因为新对象只能调用已有对象暴露出来的方法,所以又叫做 “黑箱” 复用
        (2)耦合度低,已有对象的变化对新对象的影响较小,可以在新对象的中,根据需要调用已有对象的一些操作。
        (3)复用的灵活性高,可以在代码的运行中,动态选择相同类型的其他具体类。

    展开全文
  • 浅析OOP原则

    2012-04-21 00:30:48
    前言:   学习java编程已经有相当长的一段时间了,可以说对面向对象语言编程已经是有了相当深刻的理解了。每一个程序员在编写代码的时候...说到java编程,OOP原则就要上场了。。。  OOP: Object Oriented Pr...

    前言:    

          学习java编程已经有相当长的一段时间了,可以说对面向对象语言编程已经是有了相当深刻的理解了。每一个程序员在编写代码的时候不仅要能够用一门语言来实现我们的想要的东西,而且还要有规范我们所做的工作的一套原则。我想不仅是编程,做每一件事情包括做人都要有自己的原则性。说到java编程,OOP原则就要上场了。。。

          OOP: Object Oriented Programming,面向对象的程序设计。所谓“对象”就是一个或一组数据以及处理这些数据的方法和过程的集合。面向对象的程序设计完全不同于传统的面向过程程序设计,它大大地降低了软件开发的难度,使编程就像搭积木一样简单,是当今电脑编程的一股势不可挡的潮流。

      OOP 达到了软件工程的三个主要目标:重用性、灵活性和扩展性。为了实现整体运算,每个对象都能够接收信息、处理数据和向其它对象发送信息。OOP 主要有以下的概念和组件:

          组件 - 数据和功能一起在运行着的计算机程序中形成的单元,组件在 OOP 计算机程序中是模块和结构化的基础。

      抽象性 - 程序有能力忽略正在处理中信息的某些方面,即对信息主要方面关注的能力。

      封装 - 也叫做信息封装:确保组件不会以不可预期的方式改变其它组件的内部状态;只有在那些提供了内部状态改变方法的组件中,才可以访问其内部状态。每类组件都提供了一个与其它组件联系的接口,并规定了其它组件进行调用的方法。

      多态性 - 组件的引用和类集会涉及到其它许多不同类型的组件,而且引用组件所产生的结果得依据实际调用的类型。

      继承性 - 允许在现存的组件基础上创建子类组件,这统一并增强了多态性和封装性。典型地来说就是用类来对组件进行分组,而且还可以定义新类为现存的类的扩展,这样就可以将类组织成树形或网状结构,这体现了动作的通用性。

     

     

          国际上一般认为OPP一共有七大原则,分别是以下七大原则:

    一  OCP(Open-Closed Principle) 开放-封闭原则
        软件实体应该扩展开放、修改封闭:
        1. “对于扩展是开放的” (Open for extension)。这意味着模块的行为是可以扩展的,当应用的需求改变时,我们可以对模块进行扩展,使其具有满足那些改变的新行为,换句话说,我们可以改变模块的功能。
        2. “对于更改是封闭的” (Closed for modification)。对模块行为进行扩展时,不必改动模块的源代码或者二进制代码,模块的二进制可执行版本,无论是可链接的库、DLL或JAVA 的.jar文件,都无需改动。
        实现:合理划分构件,一种可变性不应当散落在代码的很多角落里,而应当被封装到一个对象里;一种可变性不应当和另一个可变性混合在一起。

    二 DIP(Dependency-Inversion Principles)依赖倒置原则
        第1点:高层模块不依赖底层模块,两者都依赖抽象。
        第2点:抽象不应该依赖于细节,细节应该依赖于抽象。
        每个较高层次都为它所需要的服务声明一个抽象接口,较低的层次实现这些抽象接口,每个高层类都通过该抽象接口使用下一层的服务,接口属于高层,低层要实现高层的接口,因此现在是低层依赖于高层是依赖关系倒置和接口所有权的倒置。
        实现:应该通过抽象耦合的方式,使具体类最大可能的仅和其抽象类(接口)发生耦合;程式在需要引用一个对象时,应当尽可能的使用抽象类型作为变量的静态类型,这就是针对接口编程的含义。

    LSP(Liskov Substitution Principle) 替换原则

        继承思想的基础。“只有当衍生类能够替换掉基类,软件单位的功能不会受到影响时,基类才真正被复用,而衍生类也才能够在基类的基础上增加新的行为。

    四 ISP(Interface Insolation Principle)接口隔离原则
        接口功能单一,避免接口污染。
        一个接口代表一个角色,不应当将不同的角色都交给一个接口。没有关系的接口合并在一起,形成一个臃肿的大接口,这是对角色和接口的污染----角色隔离原则。
        将接口理解成为侠义的java接口,这样一来,接口隔离原则讲的就是为同一个角色提供宽、窄不同的接口,以对付不同的客户端。这种办法在服务行业中叫做定制服务---定制服务。
           实现:一个类对另外一个类的依赖性应当是建立在最小的接口上的。使用多个专门的接口比使用单一的总接口要好。
        (动机:当我们设计应用程序的时候,如果一个模块包含多个子模块,那么我们应该小心对该模块做出抽象。设想该模块由一个类实现,我们可以把系统抽象成一个接口。但 是当我们想要添加一个新的模块扩展程序时,如果要添加的模块只包含原系统中的一些子模块,那么就会强迫我们实现接口中的所有方法,并且还要编写一些哑方 法。这样的接口被称为胖接口或者叫被污染的接口,使用这样的接口将会给系统引入一些不正确的行为。)

    五 SRP(Single Resposibility Principle) 单一职责原则
        就一个类而言,应该仅有一个引起他变化的原因。 假如一个类的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能会抑止这个类完成其他职责的能力。
        单一职责原则的好处:
        第一、有助于我们分析和编码的思路的清晰。(当你的代码里有了三层或以上的if语句或for语句的嵌套的时候,你不要跟我说,你已经把问题分析得很清楚了。多层嵌套的if或for语句只能说明你还没有把问题分析清楚。)
        第二、使我们的编码、测试和维护变得简单。
        第三、将一个个复杂的问题简单化以后,易于代码的重用。(当你的代码的多个功能搅和在一起的时候,你是没办法考虑代码的重用的,因为你的每一处代码都有不同。)
        第四、易于系统的扩展

     六 LoD (Law of Demeter)迪米特法则
         即最少知识原则。一个对象应当对其他对象有尽可能少的了解。只和最直接的类交互,对第三方可以通过转达交互,从而减少对象间的耦合性。

     七 CARP(Composite/Aggregate Reuse Principle)合成/聚合复用原则
        就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过向这些对象的委派达到复用已有功能的目的。简而言之就是:要尽量使用合成/聚合,尽量不要使用继承。
        聚合:用来表示“拥有”关系或者整体和部分的关系。
        合成:用来表示一种强得多的“拥有”关系。在一个合成里,部分和整体的生命周期是一样的。一个合成的新对象完全拥有对其组成部分的支配权,包括它们的创建和泯灭等。 
         当然想要很深刻的理解OOP原则光是看点简介是远远不够的,在这里我就拿其中的一个原则 LSP(Liskov Substitution Principle) 替换原则通过举例稍微深入分析一下。
           对于依赖倒置原则,说的是父类不能依赖子类,它们都要依赖抽象类。这种依赖是我们实现代码扩展和运行期内绑定(多态)的基础。因为一旦类的使用者依赖某个具体的类,那么对该依赖的扩展就无从谈起;而依赖某个抽象类,则只要实现了该抽象类的子类,都可以被类的使用者使用,从而实现了系统的扩展。

        但是,光有依赖倒置原则,并不一定就使我们的代码真正具有良好的扩展性和运行期内绑定。请看下面的代码 

    public class Animal
    {
        private string name;
        public Animal(string name)
        {
            this.name = name;
        }
        public void Description()
        {
            Console.WriteLine("This is a(an) " + name);
        }
    }
    

    下面是它的子类猫类:

     

     

     

    public class Cat : Animal
    {
        public Cat(string name)
        {
            
        }
        public void Mew()
        {
            Console.WriteLine("The cat is saying like 'mew'");
        }
    }
    

     下面是它的子类狗类:

    public class Dog : Animal
    {
        public Dog(string name)
        {
     
        }
        public void Bark()
        {
            Console.WriteLine("The dog is saying like 'bark'");
        }
    }
    

     最后,我们来看客户端的调用:

    public void DecriptionTheAnimal(Animal animal)
    {
        if (typeof(animal) is Cat)
        {
            Cat cat = (Cat)animal;
            Cat.Decription();
            Cat.Mew();
        }
        else if (typeof(animal) is Dog)
        {
            Dog dog = (Dog)animal;
            Dog.Decription();
            Dog.Bark();
        }
    }
    

     通过上面的代码,我们可以看到虽然客户端的依赖是对抽象的依赖,但依然这个设计的扩展性不好,运行期绑定没有实现。phpma开源
    是什么原因呢?其实就是因为不满足里氏替换原则,子类如CatMew()方法父类根本没有,Dog类有Bark()方法父类也没有,两个子类都不能替换父类。这样导致了系统的扩展性不好和没有实现运行期内绑定。
    现在看来,一个系统或子系统要拥有良好的扩展性和实现运行期内绑定,有两个必要条件:第一是依赖倒置原则;第二是里氏替换原则。这两个原则缺一不可。
     
    我们知道,在我们的大多数的模式中,我们都有一个共同的接口,然后子类和扩展类都去实现该接口。
    下面是一段原始代码:

    if(action.Equals(“add”))
    {
      //do add action
    }
    else if(action.Equals(“view”))
    {
      //do view action
    }
    else if(action.Equals(“delete”))
    {
      //do delete action
    }
    else if(action.Equals(“modify”))
    {
      //do modify action
    }
    

     我们首先想到的是把这些动作分离出来,就可能写出如下的代码:

     

    public class AddAction
    {
        public void add()
        {
            //do add action
        }
    }
    public class ViewAction
    {
        public void view()
        {
            //do view action
        }
    }
    public class deleteAction
    {
        public void delete()
        {
            //do delete action
        }
    }
    public class ModifyAction
    {
        public void modify()
        {
            //do modify action
        }
    }
    

     我们可以看到,这样代码将各个行为独立出来,满足了单一职责原则,但这远远不够,因为它不满足依赖颠倒原则和里氏替换原则。phpma开源
    下面我们来看看命令模式对该问题的解决方法:

    public interface Action
    {
        public void doAction();
    }
    //然后是各个实现:
    public class AddAction : Action
    {
        public void doAction()
        {
            //do add action
        }
    }
    public class ViewAction : Action
    {
        public void doAction()
        {
            //do view action
        }
    }
    public class deleteAction : Action
    {
        public void doAction()
        {
            //do delete action
        }
    }
    public class ModifyAction : Action
    {
        public void doAction()
        {
            //do modify action
        }
    }
    

     

    p这样,客户端的调用大概如下:

    public void execute(Action action)
    {
        action.doAction();
    }
    

     看,上面的客户端代码再也没有出现过typeof这样的语句,扩展性良好,也有了运行期内绑定的优点。

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • OOP 原则

    2014-04-02 14:54:27
    S = 单一职责原则 Single Responsibility Principle O = 开放闭合原则 Opened Closed Principle L = Liscov替换原则 Liscov Substitution Principle I = 接口隔离原则 Interface Segregation Principle D = 依赖...

    S = 单一职责原则 Single Responsibility Principle


    O = 开放闭合原则 Opened Closed Principle


    L = Liscov替换原则 Liscov Substitution Principle


    I = 接口隔离原则 Interface Segregation Principle


    D = 依赖倒置原则 Dependency Inversion Principle

    展开全文
  • 基于OOP原则优化ADO.NET

    2020-03-13 11:26:03
    文章目录基于OOP原则优化ADO.NET为什么要基于OOP原则优化ADO.NeT:实现代码的复用DBHelper/SQLHelper类的封装面向对象的基本原则:1. 单一职责原则(对象职责明确原则)2. 开放封闭原则(核心原则)3. 依赖倒置原则(OOP...
  • OOP原则优化ADO.NET

    2020-02-26 08:39:21
    基于OOP原则优化 原因:在程序中只要有哪个程序功能需要对数据库进行访问操作,那么必须要有之前学习的四个步骤:(创建数据库连接对象-创建数据库命令对象-针对不同的命令执行结果是否选择使用另外两个对象对结果...
  • 面向对象的三大特性是"封装、"多态"、"继承",五大原则是"单一职责原则"、"开放封闭原则"、"里氏替换原则"、"依赖倒置原则"、"接口分离原则"。 什么是面向对象 面向对象(Object Oriented,OO)是软件开发方法。...
  • OOP 7大原则

    千次阅读 2016-06-12 18:27:00
    1.开闭原则(Open-Closed Principle,OCP) 1)定义:一个软件实体应当对扩展开放,对修改关闭( Software entities should be open for extension,but closed for modification.)。即在设计一个模块的时候,应当使...
  • C#(三) —— OOP原则

    2021-08-26 13:53:42
  • 面向对象编程(OOP)的六大原则

    千次阅读 2018-08-17 14:40:45
    面向对象编程是一种很重要的编程思想,相应的,也有它自己的原则,接下来我将为大家简单的介绍一下面向对象编程的六大原则。 一、单一职责原则——SRP(Single-Responsibility Principle) 单一职责,字面意思就是...
  • 二、OOP7大原则 单一职责原则 – SRP(原子性,方法实现的功能要单一,七大原则的总纲) (Single Responsibility Principle) 优化代码的第一步 一个类中应该是一组相关性很高的函数、数据的封装。 开闭原则 – OCP...
  • 面向对象编程的四个基本原则 1、开放封闭原则 2、依赖倒置原则 3、接口分离原则 4、Liskov替换原则
  • 1.以开关原则为(open-close)为例(来源于杨晓峰大佬的实例) public class VIPCenter{ void serviceVIP(T extend User user) { if(user instance SlumDogVIP) { //穷 x VIP 活动抢的那种 ...
  • 一直都在学习基本的数据结构,依然是面向过程编程,很难对程序语言有较深的理解,在学习C#的时候,我渐渐开始接触类、接口等概念,然而真正开始理解并应用这些概念可花费了不少时间,随后我也渐渐发现,OOP技术的...
  • 设计模式系列:OOP设计6大原则

    千次阅读 2017-02-22 08:10:43
    用面向对象的语言来讲,OCP 是一个最抽象的接口,而其余的5大原则只是OCP 的子类接口,他们一起定义了 OOP 世界的开发标准,常用的23中设计模式更是只能算作这6大原则的实现抽象类,咱们开发的代码实践才是真正的...
  • 设计模式OOP原则

    千次阅读 2014-06-04 14:40:44
    原则1:DRY(Don't repeat yourself) 即不要写重复的代码,而是用“abstraction”类来抽象公有的东西。如果你需要多次用到一个硬编码值,那么可以设为公共常量;如果你要在两个以上的地方使用一个代码块,那么...
  • OOP六大原则

    2020-09-19 11:57:54
    文章目录OOP六大原则单一职责原则定义说明开闭原则定义说明里氏替换原则定义说明依赖倒置原则定义说明理解示例接口隔离原则定义说明迪米特原则定义说明 OOP六大原则 OOP名词解析 Object 对象 Oriented 面向 ...
  • OOP七大原则

    2020-12-22 22:36:00
    1.开闭原则 对扩展开放,对修改关闭。 当需求发生变化时,在不修改软件实体源代码的情况下,可以进行功能扩展,使其满足新需求。 2.里氏替换原则 继承必须确保超类所拥有的性质在子类中仍然成立。 通俗来讲就是,...
  • Java OOP 六大原则

    2020-08-23 10:37:44
    Java OOP 六大原则 1、单一职责原则SRP(Single Responsibility Principle) 一个模块就做单个功能模块的事情,功能尽量单一,降低耦合性 2、开放封闭原则OCP(Open-Close Principle) 对功能的扩展开放,对修改功能...
  • OOP编程七大原则

    2020-05-18 16:06:19
    1.开闭原则 开闭原则是七大设计原则中最常见、最基本的,在spring的静态代理模块就有用到。 定义:软件实体对扩展是开放的,但对修改是关闭的。意思就是说在不修改软件实体的基础上去扩展其他功能。 问题的...
  • java oop 六大设计原则

    2017-05-26 09:51:47
    java oop 六大设计原则 高内聚低耦合,是软件工程中的概念,是判断设计好坏的标准,主要是面向对象的设计: 类的内聚性是否高,耦合度是否低。内聚和耦合密切相关,同其它模块存在强耦合关系的模块常意味这弱内聚,...
  • 李氏替换原则是以提出者命名的,是指对父类对象的引用在替换成子类的时候也可以保证编译和逻辑不出现异常。  在日常开发中,我们经常会对父类的方法进行重写,从而可能导致没有遵循李氏替换原则,这样有一个坏处,...
  • OOP以及OOP的基本原则和优缺点

    千次阅读 2014-03-04 09:06:05
    面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种... 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标:重用性、灵活
  • java-oop的7大原则

    2021-01-28 09:58:32
    这个东西很粗糙,但是先了解一下,就很有用处。以后编码到了几万行代码就会有点感触。
  • 作者在讲述的时候很生动,举一系列例子,使得我们更好地理解它讲述出来的六大原则,那我么下面我们就来看看OOP的六大原则到底如何运用和他们起到的作用。 1.单一职责原则 定义:就一类而言,应该仅有一个引起它...
  • OOP设计原则

    2012-10-17 23:26:13
    自己做的关于OOP设计原则的PPT!需要的可以下载
  • [设计模式](一):OOP设计原则

    千次阅读 2017-08-14 17:10:24
    设计模式的基本原则:单一职责原则(Single Responsibility Principle - SRP)、里氏代换原则(Liskov Substitution Principle)、依赖倒转原则(Dependence Inversion Principle)、接口隔离原则(Interface ...
  • 一、OCP原则(开闭原则)—— Open Close Principle 实体类、模块和方法应该对扩展开放,对修改关闭,尽量面向接口编程。 public interface ocp{ void open(); void close(); } 二、SRP原则(职责单一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,543
精华内容 11,017
关键字:

oop原则