设计模式-工厂模式与单例模式

一、工厂模式

工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
工厂模式完全负责设计原则，降低了对象之间的耦合度。很明显工厂方法模式依赖于抽象的架构，将实例化的任务交由子类去完成，同时也有非常好的拓展性。

先写一个Pizza接口，那么一个香喷喷的Pizza要做好就需要经过如下四个步骤！

public interface Pizza {
	public void prepare();
	public void bake();
	public void cut();
	public void box();
}

两种Pizza供君挑选！
Pizza A~

public class APizza implements Pizza {
	@Override
	public void prepare() {}
	@Override
	public void bake() {}
	@Override
	public void cut() {}
	@Override
	public void box() {
		System.out.println("A ok!");
	}
}

Pizza B~

public class BPizza implements Pizza {
	@Override
	public void prepare() {}
	@Override
	public void bake() {}
	@Override
	public void cut() {}
	@Override
	public void box() {
		System.out.println("B ok!");
	}
}

然后我们要有工厂来生产Pizza，即创建出Pizza的实例！

public class PizzaFactory {
	
	public Pizza createPizza(String type){
		Pizza pizza = null;
		if(type == "A"){
			pizza = new APizza();
		}else if(type == "B"){
			pizza = new BPizza();
		}
		return pizza;
	}
	
}

PizzaStore可以开始营业啦！

public class PizzaStore {

	PizzaFactory pizzaFactory;
	
	//开店的时候初始化我们的工厂！
	public PizzaStore(PizzaFactory pizzaFactory) {
		this.pizzaFactory = pizzaFactory;
	}
	
	//用户点餐就交给工厂去制作！
	public Pizza orderPizza(String type){
		Pizza pizza = pizzaFactory.createPizza(type);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
	
	//测试一下！
	public static void main(String[] args) {
		PizzaStore pizzaStore = new PizzaStore(new PizzaFactory());
		pizzaStore.orderPizza("A");
	}
}

二、单例模式

懒汉式
把自己的构造方法设置为私有的，不让别人访问你的实例，同时提供一个static方法给别人获取你的实例。

public class Single1 {
	
	private static Single1 single1;
	
	private Single1() {
	}
	
	public static Single1 getInstance(){
		if(single1 != null){
			single1 = new Single1();
		}
		return single1;
	}
}

饿汉式
定义了一个静态的final的实例，并且直接new了一个对象，这样就会导致Single2 类在加载字节码到虚拟机的时候就会实例化这个实例，当调用getInstance方法的时候，就会直接返回，不必做任何判断。这样做的好处是代码量明显减少了，坏处是，在没有使用该单例的时候，该单例却被加载了，同时如果该单例很大的话，将会浪费很多的内存。

public class Single2 {
	
	private static final Single2 single2 = new Single2();
	
	private Single2() {
	}
	
	public static Single2 getInstance(){
		return single2;
	}
}

同步懒汉式
使用synchronized关键字，相当于每个想要进入该方法的获取实例的线程都要阻塞，这对性能的影响是巨大的。其实只需要在实例第一次初始化的时候同步就足够了。

public class Single3 {
	
	private static Single3 Single3;
	
	private Single3() {
	}
	
	public synchronized static Single3 getInstance(){
		if(Single3 != null){
			Single3 = new Single3();
		}
		return Single3;
	}
}

双重检验锁
线程第一次进入会阻塞，但相较于同步懒汉式，已经有许多进步了。

public class Single4 {
	
	private static Single4 single4;
	
	private Single4(){}
	
	public static Single4 getInstance(){
		if(single4 == null){
			synchronized (Single4.class){
				if(single4 == null){
					single4 = new Single4();
				}
			}
		}
		return single4;
	}
}

懒加载内部类

public class Single5 {
	
	private static class InnerClass {
		private static final Single5 INSTANCE = new Single5();
	}
	
	private Single5 (){}
	
	public static final Single5 getInstance() {
		return InnerClass.INSTANCE;
	}
}

枚举类型

public enum Single6 {
	INSTANCE;
	public Single6 getInstance() {
		return INSTANCE;
	}
}