JAVA设计模式（一）单例设计模式与建造者模式

设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，是前人智慧的结晶。
单例模式：保证一个类只有一个实例被产生。
通常说的单例模式主要有饥汉式和懒汉式（饱汉式）。下面一起来看看吧。

饥汉式

饥汉式是指在调用该类的实例获取方法时，类已经构造好了实例，可以直接进行返回的方式。

public class MySingletonHungry {
    private static mySingletonHungry = new MySingletonHungry();
    public MySingletonHungry{

    }

    public static MySingletonHungry getSingleHungry() {
        return mySingletonHungry;
    }
}

这种方式在类进行加载的时候就进行了初始化，回去对象的速度较快，但是类加载相对会变慢。

懒汉式

懒汉式是在用户进行调用的时候进行对象的初始化。

public class MySingletonHungry {
    private static mySingletonHungry = null;
    public MySingletonHungry{

    }

    public static MySingletonHungry getSingleHungry() {
        if( mySingletonHungry == null) {
            mySingletonHungry = new MySingletonHungry();
        }
        return mySingletonHungry;
    }
}

这种方式在类加载完成后，mySingletonHungry 为Null。只有在需要实力的时候，通过调用getSingleHungry()才能生成实力。
但是这样的方法其实是线程不安全的。当多个线程都去调用的时候就会出现线程抢占资源的问题。
为解决这样的问题，自然而然的应当想到采用同步方法。
因此改版后的如下：

public class MySingletonHungry {
    private static mySingletonHungry = null;
    public MySingletonHungry{

    }

    public static synchronized MySingletonHungry getSingleHungry() {
        if( mySingletonHungry == null) {
            mySingletonHungry = new MySingletonHungry();
        }
        return mySingletonHungry;
    }
}

通过synchronized 就可以解决掉线程安全的问题了。

使用静态内部类的方式

对于单例模式的写法，有一种被推荐的模式，就是静态内部类的方式。先来看看如何写。

public class MySingleton {
    public MySingleton{

    }

    public static MySingleton getSingleton() {
        return MysingletonHoder().sInstance;
    }

    public static class MysingletonHoder() {
        private static final MySingleton sInstance = new MySingleton(); 
    }
}

这种方式通过静态内部类在调用时只能被加载一次的特性保证的线程的安全，又不会因为多次对同步方法的调用产生额外的开销。

建造者模式

  建造者模式用于将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
  具体的解释可以理解为我们想组装一个汽车，一个汽车由轮胎，底盘，引擎，车壳等组成，而这几个部件都有自己的型号。在建造者模式下，我们只需要提供者几个部件的型号，便可以产出一辆符合我们要求的汽车了。
  为了达到我们的目的，在建造者模式中就产生了一下几个部分。
Dirextor: 指挥者类，用于统一组装流程。
Builder：抽象Builder类，规范产品的组建，一般是由子类实现。
oncreteBulider: 抽象Builder类的实现类，实现抽象Builder类定义的所有方法，并且返回一个组建好的对象。
Product: 产品类。
先来看一个汽车组装的简单实现。
首先是我们的产品类

public class Car {
    private String wheel;
    private String engine;
    private String carcolor;
    private String chasis;

    public void setWheel(String wheel){
        this.wheel = wheel;
    }
    public void setEngine(String engine){
        this.engine = engine;
    }
    public void setCarColor(String carcolor){
        this.carcolor = carcolor;
    }
    public void setChasis(String chasis){
        this.chasis = chasis;
    }
}

接下来需要一个对这个car的组装过程，厂商组装都有自己的一套流程但是抽象来看大体步骤是一样的，因此可以有一个模板来进行套用，这就是抽象类Builder。

public abstract class Builder {
    public abstract void buildWheel(String cpu);
    public abstract void buildEngine(String mainboard);
    public abstract void buildCarColor(String ram);
    public abstract void buildChasis(String ram);
    public abstract Car create();
}

接下来需要具体的实现这个组装过程，比如现在我们的厂商A。

public class ABuilder extends Builder {
    private Car ACar = new Car();
    @Override
    public void buildWheel(String wheel) {
        // TODO Auto-generated method stub
        ACar.setWheel(wheel);
    }

    @Override
    public void buildEngine(String Engine) {
        // TODO Auto-generated method stub
        ACar.setEngine(Engine);
    }

    @Override
    public void buildCarColor(String CarColor) {
        // TODO Auto-generated method stub
        ACar.setCarColor(CarColor);
    }

    @Override
    public void buildChasis(String Chasis) {
        // TODO Auto-generated method stub
        ACar.setChasis(Chasis);
    }

    @Override
    public Car create() {
        // TODO Auto-generated method stub
        return ACar;
    }

}

好了 现在组装的具体方法有了，接下来就需要开始组装流程了。具体的组装流程就是由Dirextor类来具体负责。是先组装底盘呢还是先组装轮子。

public class Direcror {
    Builder mBuild=null;
    public Direcror(Builder build){
        this.mBuild=build;
    }
    public Car CreateCar(String CarColor,String Engine,String Chasis,String wheel){
        //组装流程
       this.mBuild.buildCarColor(CarColor);
       this.mBuild.buildEngine(Engine);
       this.mBuild.buildChasis(Chasis);
       this.mBuild.buildWheel(wheel);
       return mBuild.create();
    }
}

这要一辆车的组装方式就写完了。接下来看看怎么使用。

public class BuildCar {
    public static void main(String[]args){
        //给定组装方案
        Builder mBuilder=new ABuilder();
      //开始组装
        Direcror mDirecror=new Direcror(mBuilder);

        mDirecror.CreateCar(CarColor, Engine, Chasis, wheel);
    }
}

通过这种方式就可以完成一辆车了。
如我们想通过A厂来组装指定配置的车辆，就使用ABuilder()；
想通过B厂的化，只需要在写一个BBuider()，然后如法炮制就行了。