设计模式 GOF23 创建型-CSDN博客

本文链接：https://blog.csdn.net/weixin_36572983/article/details/102825081

文章目录

创建型

创建型

简单工厂工厂模式

通过一个工厂来控制所有对象的创建。

SimpleFactory  factory = new SimpleFactory();
ChineseFlag chineseFlag = factory.create("chinese");
KoreanFlag koreanFlag = factory.create("korean");

//或者
ChineseFlag chineseFlag = new ChineseFactory.create();
KoreanFlag koreanFlag = new KoreanFactory.create();

抽象工厂模式

场景：有系列产品（产品镞）需要被生产，。
实现：将工厂抽象，而不仅是产品。每个工厂负责产品族的所有匹配产品。

//定义
public Interface Factory{ Flag createFlag();Food createFood(); }
public Interface Flag{ }
public Interface Food{ }
public class ChineseFlag implements Flag{ }
public class ChineseFood implements Food{ }
public class KoreanFlag implements Flag{ }
public class KoreanFood implements Food{ }
public class ChineseFactory implements Factory{
    @Override
    public Flag createFlag() {
        return new ChineseFlag();
    }
    @Override
    public Food createFood() {
        return new ChineseFood();
    }
}
public class KoreanFactory implements Factory{
    @Override
    public Flag createFlag() {
        return new KoreanFlag();
    }
    @Override
    public Food createFood() {
        return new KoreanFood();
    }
}
public class Client {
    public static void main(String[] args) {
        // 指定工厂是中国，后面一系列产品都是中国系列
        Factory chineseFactory = new ChineseFactory();
        Flag chineseFlag = chineseFactory.createFlag();
        Food chineseFood = chineseFactory.createFood();
        // 指定工厂是韩国，后面一系列产品都是韩国系列
        Factory koreanFactory = new KoreanFactory();
        Flag koreanFlag = koreanFactory.createFlag();
        Food koreanFood = koreanFactory.createFood();
    }
}

建造者模式

场景：一个产品，需要多个步骤生产完成。
实现：通过一个builder类，封装产品各部分的组装过程。使用Director，使用builder的各个步骤。
常用实例：Windows桌面开发的InitialComponents
对比抽象工厂：
- 抽象工厂生产系列产品
- 建造者只生产一个产品，一般来说是多步骤生成的复杂产品

public class Product {
    private String part1;
    private String part2;
    private String part3;
    public String getPart1() {
        return part1;
    }
    public void setPart1(String part1) {
        this.part1 = part1;
    }
    public String getPart2() {
        return part2;
    }
    public void setPart2(String part2) {
        this.part2 = part2;
    }
    public String getPart3() {
        return part3;
    }
    public void setPart3(String part3) {
        this.part3 = part3;
    }
    public void show(){
        System.out.println(this.part1+this.part2+this.part3);
    }
}
public abstract class Builder {
    protected Product product= new Product();
    public abstract void createPart1();
    public abstract void createPart2();
    public abstract void createPart3();
    public Product getProduct(){
        return product;
    }
}
public class NormalBuilder extends Builder{
    @Override
    public void createPart1() {
        product.setPart1("NormalBuilder build normal part1");
    }
    @Override
    public void createPart2() {
        product.setPart2("NormalBuilder build normal part2");
    }
    @Override
    public void createPart3() {
        product.setPart3("NormalBuilder build normal part3");
    }
}
public class BetterBuilder extends Builder{
    @Override
    public void createPart1() {
        product.setPart1("BetterBuilder build Better part1");
    }
    @Override
    public void createPart2() {
        product.setPart2("BetterBuilder build Better part2");
    }
    @Override
    public void createPart3() {
        product.setPart3("BetterBuilder build Better part3");
    }
}
public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public void build(){
        builder.createPart1();
        builder.createPart2();
        builder.createPart3();
        builder.product.show();
    }
}
public class Client {
    public static void main(String[] args) {
        new Director(new NormalBuilder()).build();
        new Director(new BetterBuilder()).build();
    }
}

原型模式：Prototype

场景：当对象变化很小、占内存很少、种类很少。
实现：就是 implements Cloneable。使用clone替代new 对象。
优点：无需调用构造函数，直接复制内存数据块，效率提高很多。
注意：值类型直接浅克隆就行；引用类型必须深度克隆。

单例模式：Singleton

场景：保证系统中只存在一个对象。
实现：使用私有构造器保证只能在class内部启动，使用静态代码，保证只执行一次。

public class Singleton {  
    //静态代码创建对象，加载时慢点，但后续
     private static Singleton instance = new Singleton();  
     //私有构造器
     private Singleton (){}
     //通过静态方法调用
     public static Singleton getInstance() {  
        return instance;  
     }  
 }

双重检查模式

public class Singleton {  
    //volatile，保证共享变量的修改对所有相关线程是可见的。（未必原子的）
    private volatile static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {  
    if (instance== null) {  
        synchronized (Singleton.class) {  
            if (instance== null) {  
                instance= new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}