接口隔离原则发明人

A. 《单一职责准则》与《接口隔离原则》有什么区别

接口隔离原则表明客户端不应该被强迫实现一些他们不会使用的接口，应该把胖接口中的方法分组，然后用多个接口代替它，每个接口服务于一个子模块。
接口隔离原则
不应该强迫客户端依赖于他们不会使用的接口。
实例
下面是一个违反了接口隔离原则的例子。我们使用Manager类代表一个管理工人的管理者。有两种类型的工人：普通的和高效的，这两种工人都需要吃午饭。现在来了一批机器人，它们同样为公司工作，但是他们不需要吃午饭。一方面Robot类需要实现IWoker接口，因为他们要工作，另一方面，它们又不需要实现IWorker接口，因为它们不需要吃饭。
在这种情况下IWorker就被认为是一个被污染了的接口。
如果我们保持现在的设计，那么Robot类将被迫实现eat()方法，我们可以写一个哑类它什么也不做（比如说它只用一秒钟的时间吃午饭），但是这会对程序造成不可预料的结果（例如管理者看到的报表中显示被带走的午餐多于实际的人数）。
根据接口隔离原则，一个灵活的设计不应该包含被污染的接口。对于我们的例子来说，我们应该把IWorker分离成2个接口。
3. interface IWorker {
4. public void work();
5.
6. public void eat();
7. }
8.
9. class Worker implements IWorker {
10. public void work() {
11. // ....working
12. }
13.
14. public void eat() {
15. // ...... eating in launch break
16. }
17. }
18.
19. class SuperWorker implements IWorker{
20. public void work() {
21. //.... working much more
22. }
23.
24. public void eat() {
25. //.... eating in launch break
26. }
27. }
28.
29. class Manager {
30. IWorker worker;
31.
32. public void setWorker(IWorker w) {
33. worker=w;
34. }
35.
36. public void manage() {
37. worker.work();
38. }
39. }

// interface segregation principle - bad example
interface IWorker {
public void work();
public void eat();
}
class Worker implements IWorker {
public void work() {
// ....working
}
public void eat() {
// ...... eating in launch break
}
}
class SuperWorker implements IWorker{
public void work() {
//.... working much more
}
public void eat() {
//.... eating in launch break
}
}
class Manager {
IWorker worker;
public void setWorker(IWorker w) {
worker=w;
}
public void manage() {
worker.work();
}
}

下面是遵循接口隔离原则的代码。通过把IWorker分离成两个接口，Robot类不需要再被强迫实现eat()方法。如果我们需要为Robot类添加其他的功能，例如重新充电，我们可以创建一个新的IRechargeable接口，其中包含一个重新充电的方法recharge。
Java代码 复制代码

1. //interface segregation principle - good example
2.
3. interface IWorkable {
4. public void work();
5. }
6.
7. interface IFeedable{
8. public void eat();
9. }
10.
11. class Worker implements IWorkable, IFeedable {
12. public void work() {
13. // ....working
14. }
15.
16. public void eat() {
17. //.... eating in launch break
18. }
19. }
20.
21. class SuperWorker implements IWorkable, IFeedable{
22. public void work() {
23. //.... working much more
24. }
25.
26. public void eat() {
27. //.... eating in launch break
28. }
29. }
30.
31. class Robot implements IWorkable{
32. public void work() {
33. // ....working
34. }
35. }
36.
37. class Manager {
38. IWorkable worker;
39.
40. public void setWorker(IWorkable w) {
41. worker = w;
42. }
43.
44. public void manage() {
45. worker.work();
46. }
47. }

//interface segregation principle - good example
interface IWorkable {
public void work();
}
interface IFeedable{
public void eat();
}
class Worker implements IWorkable, IFeedable {
public void work() {
// ....working
}
public void eat() {
//.... eating in launch break
}
}
class SuperWorker implements IWorkable, IFeedable{
public void work() {
//.... working much more
}
public void eat() {
//.... eating in launch break
}
}
class Robot implements IWorkable{
public void work() {
// ....working
}
}
class Manager {
IWorkable worker;
public void setWorker(IWorkable w) {
worker = w;
}
public void manage() {
worker.work();
}
}

总结
如果已经设计成了胖接口，可以使用适配器模式隔离它。
像其他设计原则一样，接口隔离原则需要额外的时间和努力，并且会增加代码的复杂性，但是可以产生更灵活的设计。如果我们过度的使用它将会产生大量的包含单一方法的接口，所以需要根据经验并且识别出那些将来需要扩展的代码来使用它。

B. 什么是接口隔离原则

就是有些端口不用但是你要是不隔离可能会影响别的端口 一般式高电阻 或是接地

C. 接口隔离原则的简介

一、ISP简介（ISP--Interface Segregation Principle）：
使用多个专门的接口比使用单一的总接口要好。
一个类对另外一个类的依赖性应当是建立在最小的接口上的。
一个接口代表一个角色，不应当将不同的角色都交给一个接口。没有关系的接口合并在一起，形成一个臃肿的大接口，这是对角色和接口的污染。
“不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于它所在的类层次结构。”这个说得很明白了，再通俗点说，不要强迫客户使用它们不用的方法，如果强迫用户使用它们不使用的方法，那么这些客户就会面临由于这些不使用的方法的改变所带来的改变。

D. 对象的三个基本要素

对象，常有两层意思，指行动或思考时作为目标的事物或特指恋爱的对方等含义。
我国学者唐震在《接受与选择》一书中把对象看成是围绕着人的、被人用来接受或选择的特定事物。他提出了对象序列说：
个体的对象世界是指从个体诞生开始就围绕在个体周围的世界，它包括支持该个体存在的物质实体和用于该个体发展的各种因素。从个体的生存处境看，个体的对象世界是我们通常所指的广泛意义上的自然界以及这个自然界的展开形式。这个世界由低级到高级依次展开，它们呈现给个体的是由“原始自然——人化自然——能动自然——虚拟自然”等所构成的序列。
中文名
对象
拼音
ì xìang
词义
目标
出自
《套不住的手》
快速
导航
哲学名词信息技术名词面向对象
词语概念
基本信息
【词目】对象
【英译】character
【注音】ㄉㄨㄟˋ ㄒㄧㄤˋ
【同义词】工具、器材、东西、目标、标的、目的、方向、宗旨
基本解释
(1) [target;object]：目标
(2) [wife or husband]：指夫妇中的一方
(3) [character]：描写或写实的特定人或物
小说中描写的主要对象[1]
引证解释
1. 指行动或思考时作为目标的事物。
赵树理《套不住的手》：“训练的对象虽说是初参加生产的人，可是也有例外。”
2. 特指恋爱的对方。
指男、女朋友关系，恋爱双方的行为的称呼如“谈对象、处对象”。婚后，一般若称家属则特指老公或老婆。
冰心《我的学生》：“她的男朋友很多，却没听说过有哪一个特别好的。您说的对，她不会在同学中选对象，她一定会嫁给外交人员。”
刘绍棠《小荷才露尖尖角》：“如花似玉的一个姑娘，亲娘又是个说媒拉纤的老手， 花碧莲 却一直没有找到对象。”
3.北方方言亦指物色配偶。
谷峪《强扭的瓜不甜》：“咱长大自个对象去。”[1]
4.计算机语言。
对象就是客观世界中存在的人、事、物体等实体在计算机逻辑中的映射

E. 接口分离原则的好处

将软件组件作为一个单独的过程，目的是将组件作为构造软件的“零部件”。位置透明，接口固定，自描述，重用方便，安全。使用多个专门的接口比使用单一的总接口要好。
一个类对另外一个类的依赖性应当是建立在最小的接口上的。
一个接口代表一个角色，不应当将不同的角色都交给一个接口。没有关系的接口合并在一起，形成一个臃肿的大接口，这是对角色和接口的污染。
“不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于它所在的类层次结构。”这个说得很明白了，再通俗点说，不要强迫客户使用它们不用的方法，如果强迫用户使用它们不使用的方法，那么这些客户就会面临由于这些不使用的方法的改变所带来的改变。接口隔离原则表明客户端不应该被强迫实现一些他们不会使用的接口，应该把胖接口中的方法分组，然后用多个接口代替它，每个接口服务于一个子模块。
接口隔离原则
不应该强迫客户端依赖于他们不会使用的接口。
实例
下面是一个违反了接口隔离原则的例子。我们使用Manager类代表一个管理工人的管理者。有两种类型的工人：普通的和高效的，这两种工人都需要吃午饭。现在来了一批机器人，它们同样为公司工作，但是他们不需要吃午饭。一方面Robot类需要实现IWoker接口，因为他们要工作，另一方面，它们又不需要实现IWorker接口，因为它们不需要吃饭。
在这种情况下IWorker就被认为是一个被污染了的接口。
如果我们保持现在的设计，那么Robot类将被迫实现eat（）方法，我们可以写一个哑类它什么也不做（比如说它只用一秒钟的时间吃午饭），但是这会对程序造成不可预料的结果（例如管理者看到的报表中显示被带走的午餐多于实际的人数）。
根据接口隔离原则，一个灵活的设计不应该包含被污染的接口。对于我们的例子来说，我们应该把IWorker分离成2个接口。

F. solid原则是什么

solid原则包括以下五个：

1、单一职责原则（SRP）：表明一个类有且只有一个职责。一个类就像容器一样，它能添加任意数量的属性、方法等。

2、开放封闭原则（OCP）：一个类应该对扩展开放，对修改关闭。这意味一旦创建了一个类并且应用程序的其他部分开始使用它，就不应该修改它。

3、里氏替换原则（LSP）：派生的子类应该是可替换基类的，也就是说任何基类可以出现的地方，子类一定可以出现。值得注意的是，当通过继承实现多态行为时，如果派生类没有遵守LSP，可能会让系统引发异常。

4、接口隔离原则（ISP）：表明类不应该被迫依赖他们不使用的方法，也就是说一个接口应该拥有尽可能少的行为，它是精简的，也是单一的。

5、依赖倒置原则（DIP）：表明高层模块不应该依赖低层模块，相反，他们应该依赖抽象类或者接口。这意味着不应该在高层模块中使用具体的低层模块。

(6)接口隔离原则发明人扩展阅读：

DIP原则规定了在类之间存在依赖关系的情况下，应使用抽象（如接口）来定义它们，而不是直接引用类。 这减少了由较低级别模块的变化导致的错误，导致较高层的错误。 DIP经常在依赖注入中被使用。

当开发者遵循ISP原则时，大类实现了多个更小的接口，根据用途对功能进行分组。依赖关系与那些相关联用于松耦合，增加健壮性，灵活性以及可复用性。

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

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

H. 面向对象设计的6个设计原则最早谁提出的

Booch最先描述了面向对象的软件开发方法的基础问题。

面向对象设计的六大基本原则:
1)开闭原则
2)里氏代换原则
3)依赖倒转原则
4)接口隔离原则
5)迪米特法则
6)合成/聚合复用原则

I. C#中什么叫接口隔离原则

Bars bar = new Bars();
bar.setId(rs.getLong("id"));
bar.setName(rs.getString("name"));
bar.setType(rs.getInt("type"));
bar.setCreatorId(rs.getLong("creator_id"));
resultList.add(bar);
if (currentNum == skipEnd - 1)
break;
}