接口及其设计模式

1.接口有两种定义：

(1)对外的API.

(2)interface的声明.

关于接口的设计模式：

(1)定制服务模式：通过把每个服务都设为一个接口，这样可以粒度化每个服务。

如果需要某个特定的服务的组合，则只需要直接扩展细粒度的接口即可。

interface InternetService{
	public void connect();
	public void disconnect();
}
interface MailService{
	public void send();
	public void receive();
}
interface VirusService{
	public void begin();
	public void end();
}
class InternetServiceImpl implements InternetService{
	public void connect(){
		System.out.println("开始连接网络..."); 
	}
	public void disconnect(){
		System.out.println("开始关闭网络..."); 
	}
}
class MailServiceImpl implements MailService{
	public void send(){
		System.out.println("开始发送邮件..."); 
	}
	public void receive(){
		System.out.println("开始接收邮件..."); 
	}
}
class VirusServiceImpl implements VirusService{
	public void begin(){
		System.out.println("开始检查病毒..."); 
	}
	public void end(){
		System.out.println("检查病毒完毕..."); 
	}
}
interface Menu1 extends InternetService,MailService{
}
interface Menu2 extends InternetService,VirusService{
}
class Menu1Impl implements Menu1{
	private InternetService is;
	private MailService ms;
	public Menu1Impl(InternetService is,MailService ms){
		this.is = is;
		this.ms = ms;
	}
	public void connect(){
		is.connect();
	}
	public void disconnect(){
		is.disconnect();
	}
	public void send(){
		ms.send();
	}
	public void receive(){
		ms.receive();
	}
}
class Menu2Impl implements Menu2{
	private InternetService is;
	private VirusService vs;
	public Menu2Impl(InternetService is,VirusService vs){
		this.is = is;
		this.vs = vs;
	}
	public void connect(){
		is.connect();
	}
	public void disconnect(){
		is.disconnect();
	}
	public void begin(){
		vs.begin();
	}
	public void end(){
		vs.end();
	}
}
public class ServiceDemo{
	public static void main(String args[]){
		InternetService is = new InternetServiceImpl();
		MailService ms = new MailServiceImpl();
		VirusService vs = new VirusServiceImpl();
		Menu1Impl m1 = new Menu1Impl(is,ms);
		Menu2Impl m2 = new Menu2Impl(is,vs);
		System.out.println("检测menu1的功能中......"); 
		m1.connect();
		m1.disconnect();
		m1.send();
		m1.receive();
		System.out.println("检测menu2的功能中......"); 
		m2.connect();
		m2.disconnect();
		m2.begin();
		m2.end();
	}
}

2.适配器设计模式

适配器是两个接口的中间过度，比如电脑必须要保证电压在15V，而电源的电压是220V，则需要一个适配器将220V转换成15V，因此适配器就是接口的转换作用。

interface Source{
	public int add(int a,int b);
}
class SourceImpl implements Source{
	public int add(int a,int b){
		return a+b;
	}
}
interface Target{
	public int addOne(int a);
}
class TargetImpl implements Target{
	private Source s ;
	public TargetImpl(Source s){
		this.s = s;
	}
	public int addOne(int a){
		return s.add(a,1);
	}
}
public class AdapterDemo{
	public static void main(String args[]){
		Source s = new SourceImpl();
		Target t = new TargetImpl(s);
		System.out.println("2+1="+t.addOne(2));
	}
}

3.默认适配器模式

在java.awt.event包中，有许多接口，比如WindowEvent接口，比如此接口中有5个函数，如果要实现这个接口，必须要全部实现这些方法，如果我们只需要这个接口中的1个方法即可，但是其他的函数也必须实现，所以我们需要一个适配器，适配器中空实现接口，因此如果扩展适配器，则只要实现所需的方法即可。

4.标识类型接口模式

这个接口没有任何需要实现的方法，接口的意义只是标识作用，如果一个类实现了这个接口，只是说明这个类是某个类型的。

比如Serializable接口就是典型的标识类型接口。

5.常量接口模式

在接口中只有public static final 常量。

6.代理模式

拥有委托类、代理类、第三方。

注意：委托类和代理类实现同一个接口。

代理类帮助委托类处理一些无用的或者轻易解决的问题。

委托类是最终决定的类。

interface A{
	public boolean isAgree(int num);
}
class Source implements A{
	private int deadLine = 1000;
	public int getDeadLine(){
		return deadLine;
	}
	public boolean isAgree(int num){
		if(num>deadLine+100) return true;
		else return false;
	}
}
class Proxy implements A{
	private Source s;
	public Proxy(Source s){
		this.s = s;	
	}
	public boolean isAgree(int num){
		if(num<s.getDeadLine()){
			return false;
		}
		return s.isAgree(num);
	}
}
class Target{
	private Proxy p;
	public Target(Proxy p){
		this.p = p;
	}
	public boolean isGet(int num){
		return p.isAgree(num);
	}
}
public class ProxyDemo{
	public static void main(String args[]){
		Source s = new Source();
		Proxy p = new Proxy(s);
		Target t = new Target(p);
		System.out.println(t.isGet(800));
		System.out.println(t.isGet(1200)); 
	}
}