Java 设计模式 - 接口隔离原则

接口隔离原则要求的是在一个模块应该只依赖它需要的接口，以保证接口的小纯洁。而且需要保证接口应该尽量小，即设计接口的时候应该让接口尽量细化，不要定义太臃肿的接口（比如接口中有很多不相干的逻辑的方法声明）。

首先看看接口隔离原则的定义，有两种定义

第一种：Clients should not be forced to depend upon interfaces that they don't use.(客户端不应该强行以来它不需要的接口)

第二种：The dependency of one class to another one should depend on the smallest possible interface.（类间的依赖关系应该建立在最小的接口上）

而这里的接口，却不仅仅指的是通过interface关键字定义的接口，接口分为2种：

1、对象接口（Object Interface）

JAVA中声明的一个类，通过new关键字产生的一个实例，它是对一个类型的事物的描述，这也是一种接口。例如：

Phone phone = new Phone();这里的类Person就是实例phone的一个接口

2、类接口（Class Interface）

这种接口就是通过interface关键字定义的接口了

 

也就是说，接口隔离原则要求的是在一个模块应该只依赖它需要的接口，以保证接口的小纯洁。而且需要保证接口应该尽量小，即设计接口的时候应该让接口尽量细化，不要定义太臃肿的接口（比如接口中有很多不相干的逻辑的方法声明）。

接口隔离原则与单一职责原则有些相似，不过不同在于：单一职责原则要求的是类和接口职责单一，注重的是职责，是业务逻辑上的划分。而接口隔离原则要求的是接口的方法尽量少，尽量有用（针对一个模块）

在使用接口隔离原则的时候需要有一些规范：

1.接口尽量小

接口尽量小主要是为了保证一个接口只服务一个子模块或者业务逻辑

2.接口高内聚

接口高内聚是对内高度依赖，对外尽可能隔离。即一个接口内部的声明的方法相互之间都与某一个子模块相关，且是这个子模块必须的。

3.接口设计是有限度的

但是如果完全遵循接口隔离原则的话，会出现一个问题。即接口的设计力度会越来越小，这样就造成了接口数量剧增，系统复杂度一下子增加了，而这不是真实项目所需要的，所以在使用这个原则的时候还要在特定的项目，根据经验或者尝试判断，不过没有一个固定的标准。

举个例子

在春熙路上逛街，到处都是女的，有穿着丝袜的大妈（恶心一下），有文静的女生，有性感的辣妹，总之很多女的。然而当你对前面喊一声“美女，钱掉了”，估计前面连同大妈一起回头看看，以为在叫自己。如今美女这个词已经变得大众化了，反正跟女的打招呼就说美女。但是真正的美女是这样吗，男淫们心中的美女应该是这样的：身材好、长相好、气质佳。

IPrettyGirl.java：定义美女标准

1. //定义美女接口  
2. public interface IPrettyGirl {  
3.     //长相好  
4.     public void greatLooks();  
5.     //好身材  
6.     public void greatFigure();  
7.     //气质佳  
8.     public void greatTemperament();  
9. } 

PrettyGril.java：实现美女类

1. public class PrettyGirl implements IPrettyGirl {  
2.     private String name;  
3.     //构造函数，美女名字  
4.     public PrettyGirl(String name)  
5.     {  
6.         this.name = name;  
7.     }  
8.     //好身材  
9.     @Override 
10.     public void greatFigure() {  
11.         System.out.println(name+":身材非常好");  
12.     }  
13.     //好长相  
14.     @Override 
15.     public void greatLooks() {  
16.         System.out.println(name+":长相非常好");  
17.     }  
18.     //好气质  
19.     @Override 
20.     public void greatTemperament() {  
21.         System.out.println(name+":气质非常好");  
22.     }  
23.    
24. } 

AMan：是个抽象类，抽象出一个男人来

1. public abstract class AMan {  
2.     protected IPrettyGirl prettyGirl;  
3.     public AMan(IPrettyGirl prettyGirl)  
4.     {  
5.         this.prettyGirl = prettyGirl;  
6.     }  
7.        
8.     //帅哥开始找美女啦  
9.     public abstract void findGirl();  
10. } 

Man：

1. public class Man extends AMan {  
2.    
3.     public Man(IPrettyGirl prettyGirl) {  
4.         super(prettyGirl);  
5.     }  
6.    
7.     @Override 
8.     public void findGirl() {  
9.         System.out.println("美女在这里：----------------------");  
10.         super.prettyGirl.greatLooks();  
11.         super.prettyGirl.greatFigure();  
12.         super.prettyGirl.greatTemperament();  
13.            
14.     }  
15.    
16. } 

场景类，春熙路，帅哥开始寻找美女了

1. public class ChunxiRoad {  
2.     public static void main(String args[])  
3.     {  
4.         IPrettyGirl jiajia = new PrettyGirl("佳佳");  
5.         AMan man = new Man(jiajia);  
6.         man.findGirl();  
7.     }  
8. } 

运行结果：

美女在这里：---------------------- 
佳佳:长相非常好
佳佳:身材非常好
佳佳:气质非常好

但是这里有个问题，接口划分的不是很清晰，比如有些男人认为某些女生长相好，身材好就是美女（而不管这个女的素质啥样，比如那些“压脉带”）。而某些女生虽然长相一般，身材也一般，但是气质很好，这就是某些宅男心目中的气质型美女，或者三者具备。所以需要把接口划分的再细一点以满足不同男人的审美观。

我们把接口分为两种：

好身材

1. public interface IGreatBody {  
2.     //好长相  
3.     public void greatLooks();  
4.     //身材  
5.     public void greatFigure();  
6. } 

好气质

1. public interface IGreatTemperament {  
2.     //气质好  
3.     public void greatTemperament();  
4. } 

然后我们就可以根据自己的需求来寻找自己心目中认为的美女啦，举个例子

上面的AMan和Man传递的接口变为IGreatBody

接下来，我们来到了--东京。看到了cang老师

1. public class Tokyo {  
2.     public static void main(String args[])  
3.     {  
4.         IGreatBody canglaoshi = new PrettyGirl("cang老师");  
5.         AMan man = new Man(canglaoshi);  
6.         man.findGirl();  
7.     }  
8. } 

9. 运行结果：

   美女在这里：---------------------- 
   cang老师:长相非常好 
   cang老师:身材非常好 

   原文链接：http://www.cnblogs.com/loulijun/archive/2012/03/07/2382247.html