//本程序是接口制定标准的操作
interface USB
{
	public abstract void start();
	public abstract void stop();
}
class Computer
{	
	public static void plugin(USB usb)		//电脑可以使用接口
	{
		usb.start();
		System.out.println("电脑插上USB");
		usb.stop();
	}

}
class Flash implements USB
{
	public void start()
	{
		System.out.println("U盘启动");
	}
	public void stop()
	{
		System.out.println("U盘停止");
	}
}
class Printer implements USB
{
	public void start()
	{
		System.out.println("打印机启动");
	}
	public void stop()
	{
		System.out.println("打印机停止");
	}
}
public class Test06 
{
	public static void main(String[] args) 
	{
		Flash f = new Flash();
		Printer p = new Printer();
		Computer com = new Computer();
		com.plugin(f);
		com.plugin(p);
	}
}

程序解读：

接口 interface 定义的是一种标准，无论是U盘还是printer都能够调用该标准使用。

在每个对象中，覆写USB标准具体内容。

扩展：钥匙是否算是一种接口呢，每个人都属于一个对象，人具备了钥匙就能够开门。

1.工厂设计模式

//本程序是工厂设计模式的操作
interface Fruit 
{
	public abstract void eat();
}
class Apple implements Fruit 
{
	public void eat()
	{
		System.out.println("吃苹果");
	}
}
class Orange implements Fruit 
{
	public void eat()
	{
		System.out.println("吃橘子");
	}
}
public class Test06 
{
	public static void main(String[] args) 
	{
		Fruit a = new Apple();
		Fruit b = new Orange();
		a.eat();
		b.eat();
	}
}

但是程序有个问题，main方法更多的是一个客户端，不负责产生苹果，只是指明苹果。此时直接在主方法中指定了要操作的子类，如果要更换子类，肯定要修改客户端。

跟特定的子类紧密的耦合在一起。

//本程序是工厂设计模式的操作
interface Fruit 
{
	public abstract void eat();
}
class Factory
{
	public static Fruit getFruit(String name)
	{
		Fruit f = null;
		if ("Apple".equals(name))
		{
			f = new Apple();
		}
		if ("Orange".equals(name))
		{
			f = new Orange();
		}
		return f;
	}
}
class Apple implements Fruit 
{
	public void eat()
	{
		System.out.println("吃苹果");
	}
}
class Orange implements Fruit 
{
	public void eat()
	{
		System.out.println("吃橘子");
	}
}
public class Test06 
{
	public static void main(String[] args) 
	{
		new Factory().getFruit(args[0]).eat();
	}
}

其中，在工厂中，为了判断是否是苹果类的equals方法的顺序很有讲究。

2.代理设计模式

生活中的代理上网服务器

//本程序是工厂设计模式的操作
interface Network 
{
	public abstract void browse();
}
class Real implements Network
{
	public void browse()
	{
		System.out.println("上网浏览信息");
	}
}
class  Proxy implements Network
{
	private Network network;			//代理对象
	public Proxy(Network network)
	{
		this.network = network ;
	}
	public void check()
	{
		System.out.println("用户合法");
	}
	public void browse()
	{
		this.check();
		this.network.browse();
	}
}
public class Test06 
{
	public static void main(String[] args) 
	{
		Network net = new Proxy(new Real());		//指定代理
		net.browse();
	}
}

3.适配器设计

具体思路：在接口中声明较多的方法，但是实际使用只是一部分。

//本程序是适配器设计模式的操作
interface  Window 
{
	public abstract void open();
	public abstract void close();
	public abstract void expand();
}
abstract class WindowAdapter implements Window
{
	public void open() {};
	public void close() {};
	public void expand() {};
}
class Win extends WindowAdapter
{
	public void open()
	{
		System.out.println("打开");
	}
}
public class Test06 
{
	public static void main(String[] args) 
	{
		Window  x = new Win();
		x.open();
	}
}

这种设计思路在java的图形界面使用非常多。

4.内部类的扩展

之前讲解了内部类的概念，实际在抽象类中可以包含接口

//本程序是内部类扩展的操作
abstract class A
{
	public abstract void printA();
	interface B
	{
		public abstract void printB();
	}
}
class Exp extends A
{
	public void printA()
	{
		System.out.println("A打印方法");
	}
	class X implements B
	{
		public void printB()
		{
			System.out.println("B打印方法");
		}
	}
}

public class Test06 
{
	public static void main(String[] args) 
	{
		Exp.X aa= new Exp().new X();
		A.B a = aa;
		a.printB();
	}
}

反之，在一个接口中定义一个抽象类。

从实际开发角度，这种设计不常见，代码结构混乱。