创建型设计模式

1单例模式

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点

1.1单例模式的写法

1.1.1饿汉模式

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {
    }
    public static Singleton getInstance() {   
        return  instance
    }
}

这种在类加载时就完成了初始化，所以类加载慢，但是获取对象速度快，避免了线程同步问题，在类加载时候完成实例化，但是如果一直没有用过的话，就会造成内存浪费。

1.1.2 懒汉模式

public class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在用户第一次调用时候初始化。虽然节约资源但是需要实例化，可能比较慢，在多线程时候不能保证现场安全，如果需要线程安全

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

1.1.3双重检查模式

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

这种写法进行了两次判断，这个是推荐的写法，资源利用率高，只有在第一次执行的时候才会被实例化。且加入线程安全机制

1.1.4 静态内部单例模式

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHolder.mSinglton;
    }

    private static class SingletonHolder {
        private static final Singleton mSinglton = new Singleton();
    }
}

第一次加载时候不会初始化，只有第一次调用的时候才会加载并初始化内部类，这样能保证线程安全，也有唯一性

1.2 使用场景

1.2.1 一个系统需要一个同享访问点或者数据

1.2.2 创建一个对象需要耗费资源过多，比如链接数据库等

1.2.3 工具类对象

2.工厂模式

定义一个用于创建对象的接口，让子类决定通过实例化那个类去创建哪一个类，工厂方法可以使一个类实例化

我们只考虑动态工厂模式 大概代码如下

public class Computer {
}

public abstract class ComputerFactory {
    public abstract <T extends Computer> T createComputer(Class<T> clz);
}

public class GDComputerFactory extends ComputerFactory {
    @Override
    public <T extends Computer> T createComputer(Class<T> clz) {
        Computer computer = null;
        String classname = clz.getName();
        try {
            computer = (Computer) Class.forName(classname).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) computer;
    }
}

public class Client {
    public Client() {
        GDComputerFactory gdComputerFactory = new GDComputerFactory();
        PGComputer computer = (PGComputer) gdComputerFactory.createComputer(Computer.class);
    }
}

3.建造者模式

3.1定义：将一个复杂的对象的构建和它的表示分离开，使得同样的构造过程可以创建不同的表示，它是创建一个复杂对象的创建者模型，能一步一步构建需要的配置。

3.2代码实现

如我现在需要生产一台电脑

先定义一个实体类

package com.example.maka.jianjiezhiguan2;

public class Computer {
    private String mCpu;
    private String mMainBoard;
    private String mRam;

    public String getmCpu() {
        return mCpu;
    }

    public void setmCpu(String mCpu) {
        this.mCpu = mCpu;
    }

    public String getmMainBoard() {
        return mMainBoard;
    }

    public void setmMainBoard(String mMainBoard) {
        this.mMainBoard = mMainBoard;
    }

    public String getmRam() {
        return mRam;
    }

    public void setmRam(String mRam) {
        this.mRam = mRam;
    }
}

定义一个建造者接口

package com.example.maka.jianjiezhiguan2;

public abstract class Builder {
    public abstract Builder buildCpu(String cpu);

    public abstract Builder buildMainBorder(String mainBorder);

    public abstract Builder buildRam(String ram);

    public abstract Computer create();

}

定义具体实现

public class MoomComputerBuilder extends Builder {
    private Computer mComputer = new Computer();

    @Override
    public Builder buildCpu(String cpu) {
        mComputer.setmCpu(cpu);
        return this;
    }

    @Override
    public Builder buildMainBorder(String mainBorder) {

        mComputer.setmMainBoard(mainBorder);
        return this;
    }

    @Override
    public Builder buildRam(String ram) {
        mComputer.setmRam(ram);
        return this;
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

建造模式具体实现

public class Dirctor {
    Builder mbuilder = null;

    public Dirctor(Builder builder) {
        mbuilder = builder;
    }

    public Computer createComputer(String cpu, String mainBoader, String ram) {
        return mbuilder.buildCpu(cpu).buildMainBorder(mainBoader).buildRam(ram).create();
    }
}

最后生产类

public class CreateComputer {
    CreateComputer() {
        MoomComputerBuilder moomComputerBuilder = new MoomComputerBuilder();
        Dirctor dirctor = new Dirctor(moomComputerBuilder);
        dirctor.createComputer("i5", "华硕", "666显卡");
    }
}

3.3使用场景

（1）相同的方法，不同的执行顺序，产生不同的结果

（2）多个部件被装配到一个对象的试试，但是产生结果不一样

（3）产品非常复杂，调用顺序不同，产生不同的效果

（4）在创建一些复杂对象时候，对象内部组成构件面临着复杂变化

（5）使用建造者模式可以使客户端 不需要知道产品内部组成细节

（6）让代码更加容易扩展