代码先锋网 代码片段及技术文章聚合

一、工厂模式

工厂模式就是将程序中创建对象的操作单独出来处理，这种模式的灵活性很高，如果以后还有子类的扩充，只需要修改工厂类即可。

例如：

abstract class Fruit{
	public abstract void eat();
}

class Apple extends Fruit{
	@Override
	public void eat() {
		System.out.println("我吃的是苹果");
	}
}

class Orange extends Fruit{
	@Override
	public void eat() {
		System.out.println("我吃的是橘子");
	}
}

public class FruitFactory {

	public static Fruit getInstance(String className){
		if("apple".equals(className))
			return new Apple();
		else if("orange".equals(className))
			return new Orange();
		else
			return null;
	}
	
	public static void main(String[] args) {
		Fruit f=FruitFactory.getInstance("apple");
		f.eat();
	}
}

 首先创建了一个水果的抽象类，定义了一个抽象方法eat()，之后定义了苹果和橘子两个水果的子类，具体实现eat方法。FruitFactory就是一个水果工厂类，根据参数的不同，返回不同的水果子类。

二、代理模式

代理设计就是指由一个代理主题来操作真实的主题，真实主题执行具体的业务操作，而代理主题负责其他业务的处理，类似于我们生活中通过代理来上网。

interface Network{
	public void getNet();
}

class Real implements Network{
	@Override
	public void getNet() {
		System.out.println("获得网络，成功上网。");
	}
	
}

class Proxy implements Network{
	public Network network;
	
	public Proxy(Network network){
		this.network=network;
	}
	private void check(){
		System.out.println("用户名密码正确");
	}
	@Override
	public void getNet() {
		this.check();
		network.getNet();
	}
	
}

public class NetworkProxy {
	public static void main(String[] args) {
		Network network=new Proxy(new Real());
		network.getNet();
	}

}

 首先定义一个上网接口，只有一个获取网络的方法。之后定义一个真实上网的类和代理上网的类都实现这个接口，而在代理类中需要设置被代理的真实操作并增加自己的业务。

三、适配器模式

在java中，一个类要实现一个接口必须覆写接口的所有抽象方法，如果一个接口定义的抽象方法过多，子类根本不需要这么多方法，这个时候我们可以定义一个中间的过渡，这个过渡类并不能直接被使用，则将其定义为抽象类，也就是适配器类。

interface Window{
	public void open();
	public void close();
	public void browse();
	public void play();
}

abstract class WindowAdapter implements Window{
	public void open(){};
	public void close(){};
	public void browse(){};
	public void play(){};
}

class Window1 extends WindowAdapter{
	public void open(){
		System.out.println("系统开启");
	}
	public void close(){
		System.out.println("系统关闭");
	}
}

class Window2 extends WindowAdapter{
	public void browse(){
		System.out.println("上网浏览信息");
	}
	public void play(){
		System.out.println("上网玩游戏");
	}
}
public class AdapterTest {
	public static void main(String[] args) {
		WindowAdapter adapter1=new Window1();
		WindowAdapter adapter2=new Window2();
		adapter1.open();
		adapter2.browse();
		adapter2.play();
		adapter1.close();
	}
}

 定义一个window接口，包含四个抽象方法，之后定义一个适配器类，覆写所有方法，方法体为空，适配器的子类则有选择的实现需要的方法。

四、单例模式

单例模式就是确保一个类只能有一个实例，这在spring框架中被广泛使用。

class A{
	private final static A a=new A();

	private A(){//避免使用new实例化对象
		
	}
	
	public static A getInstance(){
		return a;
	}
}

public class SingletonTest {
	public static void main(String[] args) {
		A a=A.getInstance();
		A aa=A.getInstance();
		System.out.println(a==aa);
	}
}

 通过以上例子可以发现，a对象和aa对象是完全相同的，即同一个实例。