创建型设计模式优缺点总结及场景应用Java-优快云博客

本文链接：https://blog.youkuaiyun.com/SheepYangStudy/article/details/146150288

1.常用设计模式介绍

1.1.创建型设计模式

设计模式	描述	优点	缺点
单例模式	确保对象的唯一性	1. 单例对象在内存中只有一个，可以减少内存开支，不过在java中要注意垃圾回收机制的影响。 2. 单例模式提供了对唯一示例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。 3. 允许可变数目实例。	1. 单例模式中没有抽象层，因此扩展困难，若要扩展，除非修改代码，基本上没有第二种途径。 2.面向对象语言垃圾回收机制，当对象长时间不使用，被销毁回收，导致实例需要重新创建，且单例状态丢失
简单工厂模式	集中式工厂的实现	1.工厂类包含必要的判断逻辑，决定什么时候创建哪个实例。 2.客户端无需知道具体的产品类的类名，只需要具体产品类对应的参数即可 3.通过引入配置文件，可以不修改代码更换和增加新的具体产品类，提高系统的灵活性	1.工厂类累职责过重，一旦挂了，影响全局 2.增加了类的个数，增加系统复杂度和理解度 3.系统扩展困难 4.简单工厂模式由于使用了静态工厂方法，无法通过继承来实现 5.一旦新增产品，需要修改工厂类
工厂模式	多太工厂的实现	1.无需知道产品对应的工厂，无序关心细节，无需知道具体产品类的类名 2.基于工厂角色和产品角色的多态性设计是工厂方法模式的关键 3.使用工厂方法模式的另一个优点是系统中加入新产品时，无需修改抽象工厂和抽象产品的接口	1.添加新的产品，需要新增产品类 2.由于考虑可扩展，需要引入抽象层
抽象工厂模式	产品族的创建	1.抽象工厂隔离了类的生成，客户不需要知道什么被创建 2.当一个产品族的多个对象被设计成一起工作时，他能够保证客户端始终只使用同一个产品族的对象 3.新增产品族很方便	1.新增产品等级时，需要修改抽像层代码，违背了开闭原则
原型模式	对象克隆
建造者模式	复杂对象的组装和创建	1.客户端不需要知道产品内部的组成的细节 2.每个建造者相对独立，与其他建造者无关 3.可以更加精细的控制产品的创建过程	1.建造者模式构建的产品一般具有较多的共同点 2.如果产品的内部结构复杂且多变，要定义很多具体的建造者来实现哲宗变化，导致系统变得很庞大，增加系统的难度和运行成本

2.场景应用

2.1 抽象工厂模式应用

门票产品信息按照产品配置信息类型划分：基础信息、预定规则、退款规则、取票规则、套装信息等。按照产品类型划分4种类型：普通门票产品、门票套装产品、活动产品、活动套装产品。产品类型是产品族，产品配置信息是产品等级，请看如下示意图，根据抽象工厂生成产品族的思想，将产品类型当成产品族，产品信息分类当成产品等级，符合抽象工厂模式。

代码结构如下图所示：

具体的代码如下：（只粘贴了普通门票创建代码，其他门票套装，活动产品，活动套装代码类似，可以参考门票创建代码自己编写）

//创建产品
public interface CreateProduct {
    AddBase addBase();

    AddActivity addActivity();

    AddBooking addBooking();

    AddPickUp addPickUp();

    AddRefund addRefund();

    AddPackage addPackage();
}
//普通门票创建
public class CreateTicketProduct implements CreateProduct {

    @Override
    public AddBase addBase() {
        return new TicketProductAddBase();
    }

    @Override
    public AddActivity addActivity() {
        return new TicketProductAddActivity();
    }

    @Override
    public AddBooking addBooking() {
        return new TicketProductAddBooking();
    }

    @Override
    public AddPickUp addPickUp() {
        return new TicketProductAddPickUp();
    }

    @Override
    public AddRefund addRefund() {
        return new TicketProductAddRefund();
    }

    @Override
    public AddPackage addPackage() {
        return new TicketProductAddPackage();
    }
}

产品等级：
//基础信息
public interface AddBase {
    void addBase();
}
//活动信息
public interface AddActivity {
    void addActivity();
}
//预定规则
public interface AddBooking {
    void addBooing();
}
//退款信息
public interface AddRefund {
    void addRefund();
}
//取票信息
public interface AddPickUp {
    void addPickUp();
}
//套装信息
public interface AddPackage {
    void addPackage();
}

//门票基础信息
public class TicketProductAddBase implements AddBase {
    @Override
    public void addBase() {
        System.out.println("门票产品---新增基础信息");
    }
}
//门票活动信息
public class TicketProductAddActivity implements AddActivity {
    @Override
    public void addActivity() {
        System.out.println("门票产品---无活动信息，无需新增");
    }
}
//门票预定规则
public class TicketProductAddBooking implements AddBooking {
    @Override
    public void addBooing() {
        System.out.println("门票产品---新增预定信息");
    }
}

//门票退款规则
public class TicketProductAddRefund implements AddRefund {
    @Override
    public void addRefund() {
        System.out.println("门票产品---新增退款信息");
    }
}
//门票取票规则
public class TicketProductAddPickUp implements AddPickUp {
    @Override
    public void addPickUp() {
        System.out.println("门票产品---新增取票信息");
    }
}
//门票套装信息
public class TicketProductAddPackage implements AddPackage {
    @Override
    public void addPackage() {
        System.out.println("门票产品---无套装信息，无需添加");
    }
}

创建门票产品客户端代码：

public static void main(String[] args) {
        System.out.println("添加门票产品---------------------------------");
        //添加门票产品
        CreateProduct createTicketProduct = getCreateProduct(1);
        createTicketProduct.addBase().addBase();
        createTicketProduct.addActivity().addActivity();
        createTicketProduct.addBooking().addBooing();
        createTicketProduct.addPickUp().addPickUp();
        createTicketProduct.addRefund().addRefund();
        createTicketProduct.addPackage().addPackage();

        System.out.println("添加门票套装产品--------------------------------");
        //添加套装产品
        CreateProduct createProduct = getCreateProduct(2);
        createProduct.addBase().addBase();
        createProduct.addActivity().addActivity();
        createProduct.addBooking().addBooing();
        createProduct.addPickUp().addPickUp();
        createProduct.addRefund().addRefund();
        createProduct.addPackage().addPackage();

        System.out.println("添加活动产品---------------------------------");
        CreateProduct createActivityProduct = getCreateProduct(3);
        createActivityProduct.addBase().addBase();
        createActivityProduct.addActivity().addActivity();
        createActivityProduct.addBooking().addBooing();
        createActivityProduct.addPickUp().addPickUp();
        createActivityProduct.addRefund().addRefund();
        createActivityProduct.addPackage().addPackage();

        System.out.println("添加活动套装产品---------------------------------");
        CreateProduct createActivityPackage = getCreateProduct(4);
        createActivityPackage.addBase().addBase();
        createActivityPackage.addActivity().addActivity();
        createActivityPackage.addBooking().addBooing();
        createActivityPackage.addPickUp().addPickUp();
        createActivityPackage.addRefund().addRefund();
        createActivityPackage.addPackage().addPackage();
    }

    public static CreateProduct getCreateProduct(int type) {

        return switch (type) {
            case 3 -> new CreateActivityProduct();
            case 1 -> new CreateTicketProduct();
            case 4 -> new CreateActivityPackageProduct();
            default -> new CreateTicketPackageProduct();
        };
    }

运行结果：

添加门票产品---------------------------------
门票产品---新增基础信息
门票产品---无活动信息，无需新增
门票产品---新增预定信息
门票产品---新增取票信息
门票产品---新增退款信息
门票产品---无套装信息，无需添加
添加门票套装产品--------------------------------
门票套装产品---新增基础信息
门票套票产品---无活动信息，无需新增
门票套装产品---新增预定信息
门票套装产品---新增取票信息
门票套装产品---新增退款信息
门票套装产品---新增套装信息
添加活动产品---------------------------------
活动产品---新增基础信息
活动产品---新增活动信息
活动产品---新增预定信息
活动产品---新增取票信息
活动产品---新增退款信息
活动产品---无套装信息，无需添加
添加活动套装产品---------------------------------
活动套装产品---新增基础信息
活动套装产品---新增活动信息
活动套装产品---新增预定信息
活动套装产品---新增取票信息
活动套装产品---新增退款信息
活动套装产品---新增套装信息

2.2 建造者模式场景应用

上述所说门票产品信息划分为：基础信息，活动信息，预定规则，退款规则，取票规则，套装信息等，但是不同的产品类型，需要组装的信息有所区别。每种类型的产品，需要的产品信息映射关系如下表所示，符合建造者模式负责组装复杂对象的特点。

产品类型	需要的产品信息
普通门票产品	基础信息预定规则退款规则取票规则
门票套装产品	基础信息预定规则退款规则取票规则套装信息
活动产品	基础信息活动信息预定规则退款规则取票规则
活动套装产品	基础信息活动信息预定规则退款规则取票规则套装信息

代码结构：

具体的代码如下：

产品类：

//门票产品
public class TicketProduct {
    private String base;
    private String activity;
    private String booking;
    private String refund;
    private String pickUp;
    private String packageInfo;

    public String getBase() {
        return base;
    }

    public void setBase(String base) {
        this.base = base;
    }

    public String getActivity() {
        return activity;
    }

    public void setActivity(String activity) {
        this.activity = activity;
    }

    public String getBooking() {
        return booking;
    }

    public void setBooking(String booking) {
        this.booking = booking;
    }

    public String getRefund() {
        return refund;
    }

    public void setRefund(String refund) {
        this.refund = refund;
    }

    public String getPickUp() {
        return pickUp;
    }

    public void setPickUp(String pickUp) {
        this.pickUp = pickUp;
    }

    public String getPackageInfo() {
        return packageInfo;
    }

    public void setPackageInfo(String packageInfo) {
        this.packageInfo = packageInfo;
    }
}

抽象建造者类：

public abstract class AbstractProductBuilder {
 protected TicketProduct ticketProduct = new TicketProduct();

 public abstract void buildBase();

 public abstract void buildActivity();

 public abstract void buildBooking();

 public abstract void buildRefund();

 public abstract void buildPickUp();

 public abstract void buildPackageInfo();

 public TicketProduct getTicketProduct() {
  return ticketProduct;
 }

 public boolean isBuildActivity() {
  return true;
 }

 public boolean isBuildPackageInfo() {
  return true;
 }
}

具体的建造者类：

1.门票产品

public class TicketProductBuilder extends AbstractProductBuilder {
    @Override
    public void buildBase() {
        ticketProduct.setBase("Building base info");
    }

    @Override
    public void buildActivity() {
        ticketProduct.setActivity("Building activity info");
    }

    @Override
    public void buildBooking() {
        ticketProduct.setBooking("Building booking info");
    }

    @Override
    public void buildRefund() {
        ticketProduct.setRefund("Building refund info");
    }

    @Override
    public void buildPickUp() {
        ticketProduct.setPickUp("Building pickup info");
    }

    @Override
    public void buildPackageInfo() {
        ticketProduct.setPackageInfo("Building package info");
    }

    public boolean isBuildActivity() {
        return false;
    }

    public boolean isBuildPackageInfo() {
        return false;
    }
}

2.活动产品

public class ActivityProductBuilder extends AbstractProductBuilder {
    @Override
    public void buildBase() {
        ticketProduct.setBase("Building base info");
    }

    @Override
    public void buildActivity() {
        ticketProduct.setActivity("Building activity info");
    }

    @Override
    public void buildBooking() {
        ticketProduct.setBooking("Building booking info");
    }

    @Override
    public void buildRefund() {
        ticketProduct.setRefund("Building refund info");
    }

    @Override
    public void buildPickUp() {
        ticketProduct.setPickUp("Building pickup info");
    }

    @Override
    public void buildPackageInfo() {
        ticketProduct.setPackageInfo("Building package info");
    }

    public boolean isBuildPackageInfo() {
        return false;
    }
}

3.门票套装和活动套装，根据上述映射关系，创建对应的建造者

指挥类：

public class ProductDirector {
    public TicketProduct constructTicketProduct(AbstractProductBuilder builder) {
        builder.buildBase();
        if (builder.isBuildActivity()) {
            builder.buildActivity();
        }
        builder.buildBooking();
        builder.buildRefund();
        builder.buildPickUp();
        if (builder.isBuildPackageInfo()) {
            builder.buildPackageInfo();
        }
        return builder.getTicketProduct();
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        System.out.println("普通门票产品--------");
        AbstractProductBuilder builder = new TicketProductBuilder();
        ProductDirector director = new ProductDirector();
        TicketProduct product;
        product = director.constructTicketProduct(builder);
        System.out.println(product.getBase());
        System.out.println(product.getActivity());
        System.out.println(product.getBooking());
        System.out.println(product.getRefund());
        System.out.println(product.getPickUp());
        System.out.println(product.getPackageInfo());

        System.out.println("活动门票产品--------");
        AbstractProductBuilder activityProductBuilder = new ActivityProductBuilder();
        //ProductDirector director = new ProductDirector();
        TicketProduct activityProduct;
        activityProduct = director.constructTicketProduct(activityProductBuilder);
        System.out.println(activityProduct.getBase());
        System.out.println(activityProduct.getActivity());
        System.out.println(activityProduct.getBooking());
        System.out.println(activityProduct.getRefund());
        System.out.println(activityProduct.getPickUp());
        System.out.println(activityProduct.getPackageInfo());
    }
}

运行结果：


普通门票产品--------
Building base info
null
Building booking info
Building refund info
Building pickup info
null
活动门票产品--------
Building base info
Building activity info
Building booking info
Building refund info
Building pickup info
null

2.3 总结

1.不用为了使用设计模式而强加使用

2.宗旨代码可扩展，好维护