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

接口隔离原则：

接口分两种：

实例接口：Java中的类

类接口：interface定义的接口

原则的两种定义：

1.客户端不应该依赖它不需要的接口

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();

	}
}

运行结果：

冰冰--->脸蛋很漂亮

圆圆--->身材好

芳芳--->有气质

张三--->脸蛋很漂亮

张三--->身材好

张三--->有气质

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

版权声明：本文为博主原创文章，未经博主允许不得转载。