《设计模式之美》(二：创造型模式)

单例模式
- 饿汉式
- 懒汉式:双重校验->volatile 在jdk版本较低，禁止指令排序
- 内部类
- 枚举

单例的劣势
1. 继承、多态支持的不友好
2. 隐藏依赖关系
3. 扩展性不好（比如要创建两个对象）
4. 测试不友好
5. 不支持参数的构造函数
先调用 init(paramA,paramB) 再调用 getInstance()
getInstance(paramA,paramB),有问题
配置静态参数

线程单例
进程单例：一般默认方式
集群单例:多个进程也是单例---->加锁 回写 释放锁 外部共享存储区(比如文件)

code
//饿汉
public class A {
    private static A instance = new A();

    private A() {
    }

    public static A getInstance() {
        return instance;
    }
}

//懒汉
public class A {
    private static A instance ;
    
    public static A getInstance() {
        if (instance == null){
            synchronized (A.class){
                if (instance == null){
                    instance = new A();
                }
            }
        }
        return instance;
    }
}

//枚举
public enum A {
    ONE(1),TWO(2),THREE(3),FOUR(4),FIVE(5);

    private int value;
    A(int i) {
        this.value = i;
    }
    public int getValue() {
        return value;
    }
}

//静态内部类
public class A {
    
    private static class B{
        private static A instance = new A();
    }

    public static A getInstance() {
        return B.instance;
    }
}

工厂

简单工厂
工厂方法：在构造对象比较复杂的时候，工厂里创建工厂

DI:解析配置文件，工厂类创建对象(反射)

code
public interface IParseConfig {
    void parse(String input);
}
public class XMLParse implements IParseConfig {
    @Override
    public void parse(String input) {
        //xml 解析
    }
}

public class JsonParse implements IParseConfig {
    @Override
    public void parse(String input) {
        //Json 解析
    }
}

public class PropertyParse implements IParseConfig {
    @Override
    public void parse(String input) {
        //properties 解析
    }
}

public class ParseFactory {

    private static final HashMap<String,IParseConfig> cacheParse = new HashMap<>();
    static {
        cacheParse.put("json",new JsonParse());
        cacheParse.put("xml",new XMLParse());
        cacheParse.put("properties",new PropertyParse());
    }

    public  void parse(String filePath){
        //简单工厂
        String fileExtension = getFileExtension(filePath);
        String input = "解析出来的文件流";
        IParseConfig parseConfig;
        if ("json".equals(fileExtension)){
            parseConfig = new JsonParse();
        }else if ("xml".equals(fileExtension)){
            parseConfig = new XMLParse();
        }else if ("properties".equals(fileExtension)){
            parseConfig = new PropertyParse();
        }else {
            throw new UnsupportedOperationException("UnSupport format");
        }
        parseConfig.parse(input);

        //节省创建时间 直接在缓存拿出来
        IParseConfig parseConfig1 = cacheParse.get(fileExtension);
        parseConfig1.parse(input);

        //工厂方法
        IParseFactory parseFactory;
        if ("json".equals(fileExtension)){
            parseFactory = new JsonParseFactory();
        }else if ("xml".equals(fileExtension)){
            parseFactory = new XMLParseFactory();
        }else if ("properties".equals(fileExtension)){
            parseFactory = new PropertyParseFactory();
        }else {
            throw new UnsupportedOperationException("UnSupport format");
        }
        parseConfig =  parseFactory.createParse();
        parseConfig.parse(input);

    }

    private String getFileExtension(String filePath){
        return "json";
    }
}

//xml properties相似 省略
public class JsonParseFactory implements IParseFactory {
    @Override
    public IParseConfig createParse() {
        return new JsonParse();
    }
}

//抽象工厂 工厂创建多个实例
public interface IConfigParseFactory {
    IParseFactory createRuleParser();
    ISystemFactory createSystemParser();
}

建造者模式

如果必填参数比较多，通过构造函数不是很合适
各个参数有依赖关系，通过set不太好检验
如果有需求，对象创建之后，各个属性不可变

public class Dialog {
    private String title;
    private int width;
    private int height;


    private Dialog(Builder builder) {
        title = builder.title;
        width = builder.width;
        height = builder.height;
    }

    public static class Builder{
        private  String title;
        private  int width;
        private  int height;

        public Builder setWidth(int width){
            if (width < 0){
                throw new UnsupportedOperationException("width should >= 0");
            }
            this.width = width;
            return Builder.this;
        }

        public Builder setHeight(int height){
            if (height < 0){
                throw new UnsupportedOperationException("width should >= 0");
            }
            this.height = height;
            return Builder.this;
        }

        public Builder setTitle(String title){
            this.title = title;
            return Builder.this;
        }

        public Dialog build(){
            if (title.isEmpty()){
                throw new IllegalArgumentException("title should not empty");
            }
            return new Dialog(this);
        }
    }

}

 Dialog dialog = new Dialog.Builder()
                .setTitle("标题")
                .setWidth(100)
                .setHeight(100)
                .build();

原型模式
如果创建对象成本比较高，可以直接通过拷贝对象来获取新对象，拷贝对象有深拷贝和浅拷贝两种，clone方法是浅拷贝，只拷贝了索引和基本数据类型，没有拷贝对象，深拷贝是拷贝索引和引用
实现深拷贝的两种方式
- 序列化对象
- 递归拷贝对象对象引用对象
  浅拷贝适用于不可变的数据