接口隔离原则，接口隔离原则适用于哪个设计模式

本文目录一览

1，接口隔离原则适用于哪个设计模式
2，java语言支持oop中的oop是什么
3，面向对象的五大原则
4，面向对象五项基本原则
5，面向对象设计原则开放封闭原则
6，面向对象的基本概念是什么

1，接口隔离原则适用于哪个设计模式

接口隔离原则表明客户端不应该被强迫实现一些他们不会使用的接口，应该把胖接口中的方法分组，然后用多个接口代替它，每个接口服务于一个子模块。　　接口隔离原则　　不应该强迫客户端依赖于他们不会使用的接口。　　实例　　下面是一个违反了接口隔离原则的例子。我们使用Manager类代表一个管理工人的管理者。有两种类型的工人：普通的和高效的，这两种工人都需要吃午饭。现在来了一批机器人，它们同样为公司工作，但是他们不需要吃午饭。一方面Robot类需要实现IWoker接口，因为他们要工作，另一方面，它们又不需要实现IWorker接口，因为它们不需要吃饭。　　在这种情况下IWorker就被认为是一个被污染了的接口。　　如果我们保持现在的设计，那么Robot类将被迫实现eat（）方法，我们可以写一个哑类它什么也不做（比如说它只用一秒钟的时间吃午饭），但是这会对程序造成不可预料的结果（例如管理者看到的报表中显示被带走的午餐多于实际的人数）。　　根据接口隔离原则，一个灵活的设计不应该包含被污染的接口。对于我们的例子来说，我们应该把IWorker分离成2个接口。

搜一下：接口隔离原则适用于哪个设计模式

接口隔离原则适用于哪个设计模式

2，java语言支持oop中的oop是什么

OOP: Object Oriented Programming,面向对象的程序设计。所谓“对象”就是一个或一组数据以及处理这些数据的方法和过程的集合。面向对象的程序设计完全不同于传统的面向过程程序设计，它大大地降低了软件开发的难度，使编程就像搭积木一样简单，是当今电脑编程的一股势不可挡的潮流。面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。OOP 主要有以下的概念和组件：组件－数据和功能一起在运行着的计算机程序中形成的单元，组件在 OOP 计算机程序中是模块和结构化的基础。抽象性－程序有能力忽略正在处理中信息的某些方面，即对信息主要方面关注的能力。封装－也叫做信息封装：确保组件不会以不可预期的方式改变其它组件的内部状态；只有在那些提供了内部状态改变方法的组件中，才可以访问其内部状态。每类组件都提供了一个与其它组件联系的接口，并规定了其它组件进行调用的方法。多态性－组件的引用和类集会涉及到其它许多不同类型的组件，而且引用组件所产生的结果得依据实际调用的类型。继承性－允许在现存的组件基础上创建子类组件，这统一并增强了多态性和封装性。典型地来说就是用类来对组件进行分组，而且还可以定义新类为现存的类的扩展，这样就可以将类组织成树形或网状结构，这体现了动作的通用性。由于抽象性、封装性、重用性以及便于使用等方面的原因，以组件为基础的编程在脚本语言中已经变得特别流行。Python 和 Ruby 是最近才出现的语言，在开发时完全采用了 OOP 的思想，而流行的 Perl 脚本语言从版本5开始也慢慢地加入了新的面向对象的功能组件。用组件代替“现实”上的实体成为 JavaScript（ECMAScript）得以流行的原因，有论证表明对组件进行适当的组合就可以在英特网上代替 HTML 和 XML 的文档对象模型（DOM）。

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）。是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。

三个过程通常会相互影响，不是个简单的顺序关系。这种“非顺序的关系”就是软件过程研究的主要内容。ooa通过对象的思想进行用户业务的分析和构架，获得对象化的分析结果。ood通过对象的思想进行软件系统设计，获得对应的详细设计结果，可能是文档化的详细设计，也可能是模型化的设计模型。前两个都属于方法论的范畴，而后者则属于过程论的范畴。oop是指在软件开发过程中通过oo的思想进行表达和实现。ooa通过对象的思想进行用户业务的分析和构架，获得对象化的分析结果。ood通过对象的思想进行软件系统设计，获得对应的详细设计结果，可能是文档化的详细设计，也可能是模型化的设计模型。前两个都属于方法论的范畴，而后者则属于过程论的范畴。oop是指在软件开发过程中通过oo的思想进行表达和实现。

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。1. 开闭原则 2. 依赖倒转原则3. 里氏代换原则　4. 合成/聚合复用原则　　5. 迪米特原则 6.6. 接口隔离原则

java语言支持oop中的oop是什么

3，面向对象的五大原则

单一职责原则　　对于单一职责原则，其核心思想为：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。　　专注，是一个人优良的品质；同样的，单一也是一个类的优良设计。交杂不清的职责将使得代码看起来特别别扭牵一发而动全身，有失美感和必然导致丑陋的系统错误风险。　　开放封闭原则　　对于开放封闭原则，它是面向对象所有原则的核心，软件设计说到底追求的目标就是封装变化、降低耦合，而开放封闭原则就是这一目标的最直接体现。　　开放封闭原则，其核心思想是：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。　　因此，开放封闭原则主要体现在两个方面：1、对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对其进行任何尝试的修改。　　实现开开放封闭原则的核心思想就是对抽象编程，而不对具体编程，因为抽象相对稳定。让类依赖于固定的抽象，所以修改就是封闭的；而通过面向对象的继承和多态机制，又可以实现对抽象类的继承，通过覆写其方法来改变固有行为，实现新的拓展方法，所以就是开放的。　　“需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。　　依赖倒置原则　　对于依赖倒置原则，其核心思想是：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。　　我们知道，依赖一定会存在于类与类、模块与模块之间。当两个模块之间存在紧密的耦合关系时，最好的方法就是分离接口和实现：在依赖之间定义一个抽象的接口使得高层模块调用接口，而底层模块实现接口的定义，以此来有效控制耦合关系，达到依赖于抽象的设计目标。　　抽象的稳定性决定了系统的稳定性，因为抽象是不变的，依赖于抽象是面向对象设计的精髓，也是依赖倒置原则的核心。　　依赖于抽象是一个通用的原则，而某些时候依赖于细节则是在所难免的，必须权衡在抽象和具体之间的取舍，方法不是一层不变的。依赖于抽象，就是对接口编程，不要对实现编程。　　接口隔离原则　　对于接口隔离原则，其核心思想是：使用多个小的专门的接口，而不要使用一个大的总接口。　　具体而言，接口隔离原则体现在：接口应该是内聚的，应该避免“胖”接口。一个类对另外一个类的依赖应该建立在最小的接口上，不要强迫依赖不用的方法，这是一种接口污染。　　接口有效地将细节和抽象隔离，体现了对抽象编程的一切好处，接口隔离强调接口的单一性。而胖接口存在明显的弊端，会导致实现的类型必须完全实现接口的所有方法、属性等；而某些时候，实现类型并非需要所有的接口定义，在设计上这是“浪费”，而且在实施上这会带来潜在的问题，对胖接口的修改将导致一连串的客户端程序需要修改，有时候这是一种灾难。在这种情况下，将胖接口分解为多个特点的定制化方法，使得客户端仅仅依赖于它们的实际调用的方法，从而解除了客户端不会依赖于它们不用的方法。　　分离的手段主要有以下两种：1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销。2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。　　Liskov替换原则　　对于Liskov替换原则，其核心思想是：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。同时，这一约束反过来则是不成立的，子类可以替换基类，但是基类不一定能替换子类。　　Liskov替换原则，主要着眼于对抽象和多态建立在继承的基础上，因此只有遵循了Liskov替换原则，才能保证继承复用是可靠地。实现的方法是面向接口编程：将公共部分抽象为基类接口或抽象类，通过Extract Abstract Class，在子类中通过覆写父类的方法实现新的方式支持同样的职责。　　Liskov替换原则是关于继承机制的设计原则，违反了Liskov替换原则就必然导致违反开放封闭原则。　　Liskov替换原则能够保证系统具有良好的拓展性，同时实现基于多态的抽象机制，能够减少代码冗余，避免运行期的类型判别。

面向对象的五大原则

4，面向对象五项基本原则

◆ SRP，单一职责原则，一个类应该有且只有一个改变的理由。 ◆ OCP，开放封闭原则，你应该能够不用修改原有类就能扩展一个类的行为。 ◆ LSP，Liskov替换原则，派生类要与其基类自相容。 ◆ DIP，依赖倒置原则，依赖于抽象而不是实现。 ◆ ISP，接口隔离原则，客户只要关注它们所需的接口

单一职责原则对于单一职责原则，其核心思想为：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。专注，是一个人优良的品质；同样的，单一也是一个类的优良设计。交杂不清的职责将使得代码看起来特别别扭牵一发而动全身，有失美感和必然导致丑陋的系统错误风险。开放封闭原则对于开放封闭原则，它是面向对象所有原则的核心，软件设计说到底追求的目标就是封装变化、降低耦合，而开放封闭原则就是这一目标的最直接体现。开放封闭原则，其核心思想是：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。因此，开放封闭原则主要体现在两个方面：1、对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对其进行任何尝试的修改。实现开开放封闭原则的核心思想就是对抽象编程，而不对具体编程，因为抽象相对稳定。让类依赖于固定的抽象，所以修改就是封闭的；而通过面向对象的继承和多态机制，又可以实现对抽象类的继承，通过覆写其方法来改变固有行为，实现新的拓展方法，所以就是开放的。 “需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。依赖倒置原则对于依赖倒置原则，其核心思想是：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。我们知道，依赖一定会存在于类与类、模块与模块之间。当两个模块之间存在紧密的耦合关系时，最好的方法就是分离接口和实现：在依赖之间定义一个抽象的接口使得高层模块调用接口，而底层模块实现接口的定义，以此来有效控制耦合关系，达到依赖于抽象的设计目标。抽象的稳定性决定了系统的稳定性，因为抽象是不变的，依赖于抽象是面向对象设计的精髓，也是依赖倒置原则的核心。依赖于抽象是一个通用的原则，而某些时候依赖于细节则是在所难免的，必须权衡在抽象和具体之间的取舍，方法不是一层不变的。依赖于抽象，就是对接口编程，不要对实现编程。接口隔离原则对于接口隔离原则，其核心思想是：使用多个小的专门的接口，而不要使用一个大的总接口。具体而言，接口隔离原则体现在：接口应该是内聚的，应该避免“胖”接口。一个类对另外一个类的依赖应该建立在最小的接口上，不要强迫依赖不用的方法，这是一种接口污染。接口有效地将细节和抽象隔离，体现了对抽象编程的一切好处，接口隔离强调接口的单一性。而胖接口存在明显的弊端，会导致实现的类型必须完全实现接口的所有方法、属性等；而某些时候，实现类型并非需要所有的接口定义，在设计上这是“浪费”，而且在实施上这会带来潜在的问题，对胖接口的修改将导致一连串的客户端程序需要修改，有时候这是一种灾难。在这种情况下，将胖接口分解为多个特点的定制化方法，使得客户端仅仅依赖于它们的实际调用的方法，从而解除了客户端不会依赖于它们不用的方法。分离的手段主要有以下两种：1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销。2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。 liskov替换原则对于liskov替换原则，其核心思想是：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。同时，这一约束反过来则是不成立的，子类可以替换基类，但是基类不一定能替换子类。 liskov替换原则，主要着眼于对抽象和多态建立在继承的基础上，因此只有遵循了liskov替换原则，才能保证继承复用是可靠地。实现的方法是面向接口编程：将公共部分抽象为基类接口或抽象类，通过extract abstract class，在子类中通过覆写父类的方法实现新的方式支持同样的职责。 liskov替换原则是关于继承机制的设计原则，违反了liskov替换原则就必然导致违反开放封闭原则。 liskov替换原则能够保证系统具有良好的拓展性，同时实现基于多态的抽象机制，能够减少代码冗余，避免运行期的类型判别。

http://www.360doc.com/content/08/0430/19/61497_1226390.shtml

5，面向对象设计原则开放封闭原则

面向对象设计原则-开放封闭原则，对于扩展是开放的，对于修改是封闭的。修改（增加）类的成员变量或属性都是属于“修改”。扩展一般是指在原有的架构（小一点的说是接口）基础上进行扩展。开放封闭原则是指在现有的功能中，不修改原有的代码中进行扩展。为符合开放封闭原则，可以利用一些设计模式来实现。如第四副图，在原有countArea()方法需要增加输出功能。比如可以使用适配器模式（前提是要面向接口编程）。如下：原先的设计是定义一个接口ISqure,其定义的方法为第四副图左边类Squre包含的setLength、countArea方法。第四副图左边类Squre实现了ISqure。客户端调用代码：ISqure squre = new Square(); (一般不会这样直接获取对象，如通过工厂方法获取对象)；double area = squre.countArea();以上是原有的设计现在需要countArea方法中还具有输出功能，如何在不修改Squre类的情况下做到呢？新建另一个类SqureImpl,同时它也实现接口ISqure，代码如下：public class SqureAdapter implements ISqure static ISqure squre = new Squre();//原有的代码中的类Squre public void setLength(double length) squre.setLength(length); } public double countArea() double area = squre.countArea(); System.out.println(area); //增加输出area return area; }}修改客户端调用代码：ISqure squre = new SqureAdapter(); double area = squre.countArea();这样达到了不修改原有Square类，而是通过继承（扩展）接口ISqure，来增加了输出area的功能。这样做的好处是维持了原有代码（功能）的稳定性（可能系统的代码其他地方有很多调用Square的countArea方法，这样对它们是不影响的）。我也是最近在看面向对象设计原则的书，有问题或建议请提出来，大家共同学习。

1，面向对象是一种思考方式（不用考虑哪些定义，就像我问你，汉语的说话方式，大部分人是不会思考完你要说的话是否符合规则在说呢，只要记住把所有涉及到的东西看成对象去编程）例：“一个人吃饭” 面向过程的思考方式：“第一步，人拿起筷子。第二步，人用筷子夹饭。第三步，人把饭吃掉。第四步，无线循环第二步第三步，直到饭没或人吃饱。” 面向对象的思考方式：人是一个类，饭是一个类，饭类中某属性减少，人类中某属性增加，饭类中属性没有时，或人类中属性达到最大值即吃完。扩展还是修改？扩展时什么？不就是增加，往类里面添加就是扩展。其实答案你自己已经写出来了，你 1,2,3,4，里面那个有添加就是扩展。修改不就是改变，改为嘛。扩展是开放的，对于修改是封闭的。就是说扩展你可以无限扩，没有局限。修改你只能改那类里的东西，类本来就有的属性。（没必要记，有些人就喜欢把不需要定义的，硬改成有定义。只要记住把所有涉及到的东西看成对象去编程）

1、开闭原则（Open Close Principle）：开闭原则就是说对扩展开放，对修改关闭。-----在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果--------。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。看下定义：这样的原则还有很多：2、里氏代换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范3、依赖倒转原则（Dependence Inversion Principle）这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。4、接口隔离原则（Interface Segregation Principle）这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。5、迪米特法则（最少知道原则）（Demeter Principle）为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。6、合成复用原则（Composite Reuse Principle）原则是尽量使用合成/聚合的方式，而不是使用继承。

6，面向对象的基本概念是什么

面向对象的核心是“开发对象模型“，对象模型包括四大主要要素（抽象、封装、模块化、层次结构）和3大次要要素（类型、持久、并发）。面向对象就主要围绕这几个要素进行的。最难的部分是确定正确（不是绝对）的类和对象。面向对象的发明是为了解决大中型以及工业级软件开发问题的，举几个小例子说明不了面向对象的优势，建议学面向对象还是找本国外教程，毕竟面向对象是人家发明的。

基本概念：谈到面向对象，这方面的文章非常多。但是，明确地给出对象的定义或说明对象的定义的非常少——至少我现在还没有发现。起初，“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法。可是，这个定义显然不能再适合现在情况。面向对象的思想已经涉及到软件开发的各个方面。如，面向对象的分析（ooa，object oriented analysis），面向对象的设计（ood，object oriented design）、以及我们经常说的面向对象的编程实现（oop，object oriented programming）。许多有关面向对象的文章都只是讲述在面向对象的开发中所需要注意的问题或所采用的比较好的设计方法。看这些文章只有真正懂得什么是对象，什么是面向对象，才能最大程度地对自己有所裨益。这一点，恐怕对初学者甚至是从事相关工作多年的人员也会对它们的概念模糊不清。面向对象的分析根据抽象关键的问题域来分解系统。面向对象的设计是一种提供符号设计系统的面向对象的实现过程，它用非常接近实际领域术语的方法把系统构造成“现实世界”的对象。优点：1）近代的软件产业发展非常的迅速，但是却出现了让软件开发人员越来越不能忽视的危机，比如，软件的开发成本，尤其是大型软件开发成本、软件维护升级等费用非常的昂贵，针对出现的危机，人们提出了能够提高代码复用等的面向对象技术，面向对象技术的提出可以使客户于软件开发人员、软件开发人员之间的交流更加的顺畅，原因在于：首先，面向对象技术通常对现实世界的对象进行抽象，这种抽象使得即是非专业人员也能明软件要做什么，使得客户于专业的软件开发人员交流起来更加顺畅，节约开发成本；其次，面向对象技术通常会采用封装，继承等技术，这些技术会使得不同的程序模块之间的关联度减小，可以使得开发人员专注于程序的研发，而不是把大量的精力都放到各个模块的协调上。2）并不是说我们利用了面向对象的语言，比如c++、java，面向对象技术的好处就会出现，实际上在小的程序设计上，可能根本不需要这么复杂。真正的大型软件开发用到时需要采用相应的技术方法，不断的优化，比如瀑布模型法，快速原型法。瀑布模型法主要是把软件分为若干阶段，在每一个阶段，都充分的和客户交流；快速模型法主要是首先提出一个总的模型提交给客户，然后在不断的修改，通常这种方法只适用于较小的工程。无论采用那种方法我们可以遵从一个原则：就是把大的软件项目不断的细化，最后细化到一个个小函数，然后在根据之间的关系封装等。

专家拿来忽悠人的仅仅是一种思想而已没有那么多概念编码千万遍其意自现如果非要说三要素：继承多肽抽象；五原则是：单一职责原则对于单一职责原则，其核心思想为：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。专注，是一个人优良的品质；同样的，单一也是一个类的优良设计。交杂不清的职责将使得代码看起来特别别扭牵一发而动全身，有失美感和必然导致丑陋的系统错误风险。开放封闭原则　　对于开放封闭原则，它是面向对象所有原则的核心，软件设计说到底追求的目标就是封装变化、降低耦合，而开放封闭原则就是这一目标的最直接体现。开放封闭原则，其核心思想是：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。因此，开放封闭原则主要体现在两个方面：1、对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对其进行任何尝试的修改。实现开开放封闭原则的核心思想就是对抽象编程，而不对具体编程，因为抽象相对稳定。让类依赖于固定的抽象，所以修改就是封闭的；而通过面向对象的继承和多态机制，又可以实现对抽象类的继承，通过覆写其方法来改变固有行为，实现新的拓展方法，所以就是开放的。“需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。依赖倒置原则　　对于依赖倒置原则，其核心思想是：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。我们知道，依赖一定会存在于类与类、模块与模块之间。当两个模块之间存在紧密的耦合关系时，最好的方法就是分离接口和实现：在依赖之间定义一个抽象的接口使得高层模块调用接口，而底层模块实现接口的定义，以此来有效控制耦合关系，达到依赖于抽象的设计目标。抽象的稳定性决定了系统的稳定性，因为抽象是不变的，依赖于抽象是面向对象设计的精髓，也是依赖倒置原则的核心。依赖于抽象是一个通用的原则，而某些时候依赖于细节则是在所难免的，必须权衡在抽象和具体之间的取舍，方法不是一层不变的。依赖于抽象，就是对接口编程，不要对实现编程。接口隔离原则对于接口隔离原则，其核心思想是：使用多个小的专门的接口，而不要使用一个大的总接口。具体而言，接口隔离原则体现在：接口应该是内聚的，应该避免“胖”接口。一个类对另外一个类的依赖应该建立在最小的接口上，不要强迫依赖不用的方法，这是一种接口污染。接口有效地将细节和抽象隔离，体现了对抽象编程的一切好处，接口隔离强调接口的单一性。而胖接口存在明显的弊端，会导致实现的类型必须完全实现接口的所有方法、属性等；而某些时候，实现类型并非需要所有的接口定义，在设计上这是“浪费”，而且在实施上这会带来潜在的问题，对胖接口的修改将导致一连串的客户端程序需要修改，有时候这是一种灾难。在这种情况下，将胖接口分解为多个特点的定制化方法，使得客户端仅仅依赖于它们的实际调用的方法，从而解除了客户端不会依赖于它们不用的方法。分离的手段主要有以下两种：1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销。2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。Liskov替换原则　　对于Liskov替换原则，其核心思想是：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。同时，这一约束反过来则是不成立的，子类可以替换基类，但是基类不一定能替换子类。Liskov替换原则，主要着眼于对抽象和多态建立在继承的基础上，因此只有遵循了Liskov替换原则，才能保证继承复用是可靠地。实现的方法是面向接口编程：将公共部分抽象为基类接口或抽象类，通过Extract Abstract Class，在子类中通过覆写父类的方法实现新的方式支持同样的职责。