6大设计模式（4）：接口隔离原则

接口隔离原则：

接口分两种：

实例接口：Java中的类

类接口：interface定义的接口

原则的两种定义：

1.client不应该依赖它不须要的接口

2.类间的依赖关系应该建立在最小的接口上

须要对接口进行细化。保持清纯性。

接口尽量细化，同一时候接口中的方法尽量少，增强专门性。

接口隔离原则是对接口进行规范约束，包括4层含义：

1.接口要尽量小

这是原则的核心定义。可是小也是有限度的，不能违反单一 职责原则。

2.接口要高内聚

什么是高内聚？就是提高类、接口的处理能力。降低对外的交互。

类提供一个方法。你仅仅须要知道调用这种方法就能够实现一系列的功能，可是详细是如何实现的就不知道了。详细到接口隔离原则就是在接口中尽量少的发布public方法。

3.定制服务

单独为当中的某一模块抽象成一个接口。

4.接口的设计是有限的

需求总是在变化的。

用书中的样例“星探寻找美女”来进一步理解上述四个含义。

首先得有一个美女的接口和星探的抽象接口：

interface IPrettyGirl {
// 长得好看
public void goodLooking();

// 身材好
public void niceFigure();

// 有气质
public void greatTemperament();
}

abstract class AbstractSearcher {
protected IPrettyGirl prettyGirl;

public AbstractSearcher(IPrettyGirl prettyGirl) {
this.prettyGirl = prettyGirl;
}

public abstract void show();
}

实现美女类和星探类：

class PrettyGirl implements IPrettyGirl {

private String name;

public PrettyGirl(String name) {
this.name = name;
}

@Override
public void goodLooking() {
System.out.println(name + "--->脸蛋非常美丽");
}

@Override
public void niceFigure() {
System.out.println(name + "--->身材非常好");
}

@Override
public void greatTemperament() {
System.out.println(name + "--->气质好");
}

}

class Searcher extends AbstractSearcher {

public Searcher(IPrettyGirl prettyGirl) {
super(prettyGirl);
}

@Override
public void show() {
System.out.println("-----美女信息例如以下-----");
// 展示面容
super.prettyGirl.goodLooking();
// 展示身材
super.prettyGirl.niceFigure();
// 展示气质
super.prettyGirl.greatTemperament();
}

}

场景类：

public class Client {

public static void main(String[] args) {
IPrettyGirl girl = new PrettyGirl("圆圆");
AbstractSearcher searcher = new Searcher(girl);
searcher.show();
}
}

可是美女并不一定都是满足长得美丽、身材好、有气质这三个条件。仅仅满足当中一个也能够算是一个“美女”。仅仅只是不是那么完美罢了。比方说。背影杀手。

那么详细到这个程序我们应该怎么去实现呢？PrettyGirl实现IPrettyGirl接口里的所有方法，所以仅仅能对IPrettyGirl接口进行拆分、细化。拆分成两个或几个接口。这个视需求而定。

如果我们将美女分为气质型美女和外形美的美女，这样就是两个接口。外形美女也能够分成 （脸）长得美丽的美女和身材好的美女。这样就是拆分成三个接口。各自是：IGoodLookingGirl、INiceFigureGirl、IGreatTemperamentGirl。

美女的接口及实现类：

interface IGoodLookingGirl {
public void goodLooking();
}

interface INiceFigureGirl {
public void niceFigure();
}

interface IGreatTemperamentGirl {
public void greatTemperament();
}

// 长得好看的美女
class GoodLookingGirl implements IGoodLookingGirl {

private String name;

public GoodLookingGirl(String name) {
this.name = name;
}

@Override
public void goodLooking() {
System.out.println(name + "--->脸蛋非常美丽");
}
}

// 身材好的美女
class NiceFigureGirl implements INiceFigureGirl {

private String name;

public NiceFigureGirl(String name) {
this.name = name;
}

@Override
public void niceFigure() {
System.out.println(name + "--->身材好");
}

}

// 有气质的美女
class GreatTemperamentGirl implements IGreatTemperamentGirl {

private String name;

public GreatTemperamentGirl(String name) {
this.name = name;
}

@Override
public void greatTemperament() {
System.out.println(name + "--->有气质");
}

}

// 完美
class PrettyGirl implements IGoodLookingGirl, INiceFigureGirl,
IGreatTemperamentGirl {

private String name;

public PrettyGirl(String name) {
this.name = name;
}

@Override
public void greatTemperament() {
System.out.println(name + "--->有气质");
}

@Override
public void niceFigure() {
System.out.println(name + "--->身材好");
}

@Override
public void goodLooking() {
System.out.println(name + "--->脸蛋非常美丽");
}

}

星探的接口及实现类：

abstract class AbstractSearcher {
protected PrettyGirl prettyGirl;
protected GoodLookingGirl goodLookingGirl;
protected GreatTemperamentGirl greatTemperamentGirl;
protected NiceFigureGirl niceFigureGirl;

public AbstractSearcher(PrettyGirl prettyGirl) {
this.prettyGirl = prettyGirl;
}

public AbstractSearcher(IGoodLookingGirl goodLookingGirl) {
this.goodLookingGirl = (GoodLookingGirl) goodLookingGirl;
}

public AbstractSearcher(IGreatTemperamentGirl greatTemperamentGirl) {
this.greatTemperamentGirl = (GreatTemperamentGirl) greatTemperamentGirl;
}

public AbstractSearcher(INiceFigureGirl niceFigureGirl) {
this.niceFigureGirl = (NiceFigureGirl) niceFigureGirl;
}

public abstract void showPrettyGirl();

public abstract void showGoodLookingGirl();

public abstract void showNiceFigureGirl();

public abstract void showGreatTemperamentGirl();
}

class Searcher extends AbstractSearcher {

public Searcher(IGoodLookingGirl goodLookingGirl) {
super(goodLookingGirl);
}

public Searcher(INiceFigureGirl niceFigureGirl) {
super(niceFigureGirl);
}

public Searcher(IGreatTemperamentGirl temperamentGirl) {
super(temperamentGirl);
}

public Searcher(PrettyGirl prettyGirl) {
super(prettyGirl);
}

@Override
public void showPrettyGirl() {
super.prettyGirl.goodLooking();
super.prettyGirl.niceFigure();
super.prettyGirl.greatTemperament();
}

@Override
public void showGoodLookingGirl() {
super.goodLookingGirl.goodLooking();
}

@Override
public void showNiceFigureGirl() {
super.niceFigureGirl.niceFigure();
}

@Override
public void showGreatTemperamentGirl() {
super.greatTemperamentGirl.greatTemperament();
}

}

场景类：

public class Client {

public static void main(String[] args) {
IGoodLookingGirl goodLookingGirl = new GoodLookingGirl("冰冰");
INiceFigureGirl niceFigureGirl = new NiceFigureGirl("圆圆");
IGreatTemperamentGirl greatTemperamentGirl = new GreatTemperamentGirl(
"芳芳");
PrettyGirl prettyGirl = new PrettyGirl("张三");
AbstractSearcher goodlookingGirlsearcher = new Searcher(goodLookingGirl);
AbstractSearcher niceFigureGirlSearcher = new Searcher(niceFigureGirl);
AbstractSearcher greatTemperamentGirlSearcher = new Searcher(
greatTemperamentGirl);
AbstractSearcher prettyGirlSearcher = new Searcher(prettyGirl);

goodlookingGirlsearcher.showGoodLookingGirl();
niceFigureGirlSearcher.showNiceFigureGirl();
greatTemperamentGirlSearcher.showGreatTemperamentGirl();
prettyGirlSearcher.showPrettyGirl();

}
}

执行结果：

冰冰--->脸蛋非常美丽

圆圆--->身材好

芳芳--->有气质

张三--->脸蛋非常美丽

张三--->身材好

张三--->有气质

写完之后本人就懵了，事实上写的过程中就已经懵了，越写越认为理解的有问题。怎么会这么麻烦。

。。