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

单例模式

    //最简单、有效的单例实现
    private static class SingleWithHolder {
        private static class Holder{
            private static SingleWithHolder instance = new SingleWithHolder();
        }
        //通过SingleWithHolder.instance()得到单例
        private static SingleWithHolder instance() {
            return Holder.instance;
        }
    }

    //使用enum实现单例
    private enum SingleWithEnum{
        //通过SingleWithEnum.INSTANCE.instance()得到单例
        INSTANCE{
            @Override
            public SingleTest instance() {
                return instance;
            }
        };
        protected SingleTest instance;
        //enum的构造器必须为private
        private SingleWithEnum() {
            instance = new SingleTest();
        }
        //Enum为抽象类
        public abstract SingleTest instance();
    }

    //经典的双重检查锁
    private static class SingleWithDoubleCheck{
        private static volatile SingleSample instance;
        public static SingleSample instance() {
            if (instance == null) {
                synchronized (SingleWithDoubleCheck.class) {
                    if (instance == null) {
                        //如果不将instance声明为volatile，这里就会出现问题，instance = new SingleSample();的执行逻辑大致分三步：
                        // 1分配对象空间、2赋初值、3返回对象引用，
                        // 如果经过指令重排序后执行顺序变成了1、3、2，就会出现可以获得非空对象，但对象内字段为零值的情况，而volatile可以禁止指令重排序。
                        instance = new SingleSample();
                    }
                }
            }
            return instance;
        }
    }

工厂模式

工厂模式可以屏蔽产品生产的细节（工厂生产产品本身是很复杂的，可能又会涉及其他产品的生产，这些细节都由工厂来保证），同时将产品的具体实现与客户解耦，工厂是用来生产产品的，如何提升工厂的扩展性（方便的加入新工厂、新产品）是工厂模式要注意的。

简单工厂模式

//产品抽象
abstract class BMW {  
    public BMW(){  
          
    }  
}  
//具体产品  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  
//产品工厂，负责生产所有产品
public class Factory {  
    public BMW createBMW(int type) {  
        switch (type) {  
          
        case 320:  
            return new BMW320();  
  
        case 523:  
            return new BMW523();  
  
        default:  
            break;  
        }  
        return null;  
    }  
}  
//客户
public class Customer {  
    public static void main(String[] args) {  
        Factory factory = new Factory();  
        //类似spring中BeanFactory的getBean
        BMW bmw320 = factory.createBMW(320);  
        BMW bmw523 = factory.createBMW(523);  
    }  
}  

工厂方法模式

//产品抽象
abstract class BMW {  
    public BMW(){  
          
    }  
}  
//具体产品
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}  
//工厂抽象
interface FactoryBMW {  
    BMW createBMW();  
}  
//具体工厂
public class FactoryBMW320 implements FactoryBMW{  
  
    @Override  
    public BMW320 createBMW() {  
  
        return new BMW320();  
    }  
  
}  
public class FactoryBMW523 implements FactoryBMW {  
    @Override  
    public BMW523 createBMW() {  
  
        return new BMW523();  
    }  
}  
//客户
public class Customer {  
    public static void main(String[] args) {  
        //类似spring中ClassPathXmlApplicationContext和FileSystemXmlApplicationContext都继承了抽象类AbstractXmlApplicationContext，二者的差异仅在于路径解析
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
        BMW320 bmw320 = factoryBMW320.createBMW();  
  
        FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
        BMW523 bmw523 = factoryBMW523.createBMW();  
    }  
}  

抽象工厂模式

现在要求为每个车型生产配件

//发动机以及型号    
public interface Engine {    
  
}    
public class EngineA extends Engine{    
    public EngineA(){    
        System.out.println("制造-->EngineA");    
    }    
}    
public class EngineBextends Engine{    
    public EngineB(){    
        System.out.println("制造-->EngineB");    
    }    
}    
  
//空调以及型号    
public interface Aircondition {    
  
}    
public class AirconditionA extends Aircondition{    
    public AirconditionA(){    
        System.out.println("制造-->AirconditionA");    
    }    
}    
public class AirconditionB extends Aircondition{    
    public AirconditionB(){    
        System.out.println("制造-->AirconditionB");    
    }    
}   
//工厂抽象
public interface AbstractFactory {    
    //制造发动机  
    public Engine createEngine();  
    //制造空调   
    public Aircondition createAircondition();   
}    
  
  
//宝马320系列配件工厂
public class FactoryBMW320 implements AbstractFactory{    
        
    @Override    
    public EngineA createEngine() {      
        return new EngineA();    
    }    
    @Override    
    public AirconditionA createAircondition() {    
        return new AirconditionA();    
    }    
}    
//宝马523系列配件工厂    
public class FactoryBMW523 implements AbstractFactory {    
    
     @Override    
    public EngineB createEngine() {      
        return new EngineB();    
    }    
    @Override    
    public AirconditionB createAircondition() {    
        return new AirconditionB();    
    }    
}   
//客户
public class Customer {    
    public static void main(String[] args){    
        //生产宝马320系列配件  
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();    
        factoryBMW320.createEngine();  
        factoryBMW320.createAircondition();  
            
        //生产宝马523系列配件    
        FactoryBMW523 factoryBMW523 = new FactoryBMW523();    
        factoryBMW320.createEngine();  
        factoryBMW320.createAircondition();  
    }    
}  

工厂方法只能生产一种产品，而抽象工厂可以生产多种产品。

参考：http://blog.csdn.net/jason0539/article/category/3092021