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

	}
}

 

执行结果：

冰冰--->脸蛋非常美丽
圆圆--->身材好
芳芳--->有气质
张三--->脸蛋非常美丽
张三--->身材好
张三--->有气质

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

。。