构造器模式

最新推荐文章于 2020-08-18 16:22:58 发布
最新推荐文章于 2020-08-18 16:22:58 发布
阅读量757 收藏 1
点赞数
分类专栏： # 设计模式 文章标签： 构造器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingyundezuoan/article/details/84574940
版权

构造器模式

概述

  • 概念：构造器模式 Builder Pattern1
  • 作用：
    • 使复杂对象的构造算法和它的表示分离，以便同一个构造算法，可以创建不同的表示1
    • 为了将复杂对象的构建过程与它的表示分离2
  • 区别3：
    • 模板模式：
      • 执行流程由父类决定
      • 一旦执行流程变更需要修改父类，违反了开闭设计原则
    • 构造模式：执行流程由第三方监工类决定
      • 一旦执行流程变更无需修改底层的父子类，只需要修改监控类
  • 场景1：

    • 场景一

      • 类的构造方法4

        • 当类中有新增属性时，需要扩充构造方法，新增属性，当可选参数过多时，构造对象时就很容易传错参数
        • 当类中某些属性可选时，需要定制构造方法，即某些属性可空，某些情况构造对象不需要传值

      • 代码示例

        package test;

import java.io.Serializable;

/**
 * 用户对象
 * @author test
 * 1.创建类
 * 2.添加当前类的成员变量，区分变量：必须与可选；添加 Set Get 方法
 * 3.创建静态内部类 - 当前的建造类
 * 4.添加内部类的成员变量，拷贝外部类的成员变量
 * 5.添加外部类构造方法，构造方法入参为内部类，构造方法属性赋值
 * 6.添加内部类构造方法，构造方法入参为必须成员变量
 * 7.添加内部类成员方法，可选成员变量赋值
 * 8.添加内部类建造方法，返回外部类的对象
 */
public class User implements Serializable {

    private static final long serialVersionUID = 3601470141407549788L;

    /**
     * 用户编号 required 成员变量
     */
    private Integer id ;

    /**
     * 用户名称 required 成员变量
     */
    private String name ;

    /**

     * 用户年龄 optional 成员变量
     */
    private Integer age ;

    /**
     * 用户身高 optional 成员变量
     */
    private Integer height ;

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public Integer getHeight() {
        return height;
    }

    private User (UserBuild userBuild){
        this.id = userBuild.id ;
        this.name = userBuild.name ;
        this.age = userBuild.age ;
        this.height = userBuild.height ;
    }

    public String toString(){
        StringBuilder toStringBuilder = new StringBuilder(this.name.length() * 4);
        toStringBuilder.append("User ").append("id:").append(this.id).append(",name:").append(this.name).append(",age:")
                .append(this.age).append(",height:").append(this.height);
        return toStringBuilder.toString();
    }

    /**
     * User 类建造者类
     * @author test
     */
    private static class UserBuild {

        /**
         * 用户编号 required 成员变量
         */
        private Integer id ;

        /**
         * 用户名称 required 成员变量
         */
        private String name ;

        /**

         * 用户年龄 optional 成员变量
         */
        private Integer age ;

        /**
         * 用户身高 optional 成员变量
         */
        private Integer height ;

        public UserBuild(Integer id ,String name){
            this.id = id ;
            this.name = name ;
        }

        public UserBuild age(Integer age){
            this.age = age ;
            return this ;
        }

        public UserBuild height(Integer height){
            this.height = height ;
            return this ;
        }

        public User build(){
            return new User(this);
        }
    }

    public static void main(String[] args) {

        User user = new UserBuild(1,"2").age(3).height(4).build();
        System.out.println(user.toString());
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getAge());
        System.out.println(user.getHeight());
    }
}

    • 其他方式

      • 快速添加Builder内部类的方法——PO类上添加 Guava @Builder 注解5
      • 新增参数时不必修改构造方法——PO类上添加 Guava @AllArgsConstructor 注解5

    • 场景二

      • 将复杂对象的构造与对象的属性分离，调用方只需要指定需要调用的类型而无需关注具体的建造过程及细节4

      • 代码示例

        package test;

import java.io.Serializable;

/**
 * 动物实体类
 * 动物身体由头、脚组成
 * @author test
 */
public class Animal implements Serializable{
    private static final long serialVersionUID = 2610315450660664668L;

    /**
     * 头
     */
    private Head head = new Head();

    /**
     * 脚
     */
    private Foot foot = new Foot();

    /**
     * 头的数量
     * @param num 数量
     */
    public void setHeadNum(int num){
        head.setNum(num);
    }

    /**
     * 设置脚的数量
     * @param num
     */
    public void setFootNum(int num){
        foot.setNum(num);
    }

    public Head getHead() {
        return head;
    }

    public void setHead(Head head) {
        this.head = head;
    }

    public Foot getFoot() {
        return foot;
    }

    public void setFoot(Foot foot) {
        this.foot = foot;
    }

    public String toString(){
        StringBuilder sb = new StringBuilder("");
        sb.append("Head num:").append(this.head.getNum()).append(",Foot num:").append(this.foot.getNum());
        return sb.toString();
    }
}

package test;

import java.io.Serializable;

/**
 * 头
 * @author test
 */
public class Head implements Serializable {
    private static final long serialVersionUID = 7657725082250430948L;

    /**
     * 数量
     */
    private Integer num ;


    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }
}


package test;

import java.io.Serializable;

/**
 * 脚
 * @author test
 */
public class Foot implements Serializable{
    private static final long serialVersionUID = -9198575656926734237L;

    private Integer num ;

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }
}

package test;

/**
 * 动物构造器
 * @author test
 */
public abstract class AnimalBuilder {

    protected Animal animal = new Animal();

    public abstract void setHeadNum();

    public abstract void setFootNum();
}

package test;

/**
 * 大象
 * @author test
 */
public class ElephantAnimal extends AnimalBuilder {

    @Override
    public void setHeadNum() {
        animal.setHeadNum(1);
    }

    @Override
    public void setFootNum() {
        animal.setFootNum(4);
    }
}

package test;

/**
 * 蚂蚁
 * @author test
 */
public class AntAnimal extends AnimalBuilder {

    @Override
    public void setHeadNum() {
        animal.setHeadNum(1);
    }

    @Override
    public void setFootNum() {
        animal.setFootNum(6);
    }
}

package test;

/**
 * 指挥者
 * @author test
 */
public class AnimalDirector {
    private AnimalBuilder animalBuilder;

    public AnimalDirector(AnimalBuilder animalBuilder){
        this.animalBuilder = animalBuilder;
    }

    public Animal createAnimal(){
        animalBuilder.setFootNum();
        animalBuilder.setHeadNum();
        return animalBuilder.animal;
    }
}

package test;

public class AnimalClient {

    public static void main(String[] args) {

        AnimalBuilder elephant = new ElephantAnimal();
        AnimalDirector director = new AnimalDirector(elephant);
        Animal animal = director.createAnimal();
        System.out.println(animal);
    }
}

    • 场景三：

      • 代码示例

        /**
 * 对象基类
 */
public abstract class Operation {
    public abstract Integer getOperationReuslt(Integer numA,Integer numB);
}

/**
 * 加法子类
 */
public class AddOperation extends Operation {
    @Override
    public Integer getOperationReuslt(Integer numA, Integer numB) {
        return numA+numB;
    }
}

/**
 * 减法子类
 */
public class SubOperation extends Operation {
    @Override
    public Integer getOperationReuslt(Integer numA, Integer numB) {
        return numA - numB;
    }
}

/**
 * 监工类
 */
public class Director {

    private Operation operation;

    public Director(Operation operation){
        this.operation = operation;
    }

    public Integer getOperationResult(Integer numA,Integer numB){
        return operation.getOperationReuslt(numA,numB);
    }
}

/**
 * 调用类
 */
public class BuilderMain {
    public static void main(String[] args) {
        AddOperation addOperation = new AddOperation();
        Director director = new Director(addOperation);
        System.out.println(director.getOperationResult(1, 2));
    }
}

  1. 设计模式—构造器模式 ↩︎ ↩︎ ↩︎

  2. Java设计模式–Java Builder模式 ↩︎

  3. 设计模式：Builder模式 ↩︎

  4. 建造者(Builder)模式 的若干使用场景 ↩︎ ↩︎

  5. PO类上添加 Guava @Builder 注解 ↩︎ ↩︎

命运的左岸
关注
专栏目录
构建器模式
Android
04-14 1122
1.问题场景：设计某个类时，需要传入多个构造器参数（如6个参数），且这些参数中有必选参数（2个）和非必选参数（4个），那么该如何设计该类的构造器会更为合理呢？ 方案一：重叠构造器模式 方案二：JavaBeans模式 方案三：构建器模式 ... ... 2.重叠构造器模式 （1）形式：先提供一个包含了所有的构造参数的构造方法，再被其余的构造参数较少的构造方法来调用。简单的说，就是
【JAVA】构造器模式
最新发布
Deng_ml的博客
07-11 976
什么是构造器？ 构造器模式是一种创建对象的设计模式。 它的主要目的是将对象的创建过程和其表示分离，使得对象的创建更加灵活和可定制。 在构造器模式中，会定义一个构造器类，该类包含多个构造函数或者方法，用于设置对象的不同属性和状态。 以下是构造器模式的一些优点： 增加了对象创建的可读性和可理解性。通过明确的构造方法，可以清晰地看到对象创建时所需的参数和设置，这样在创建对象时，根据不同的需求选择相应的构造器，清晰明了。 提供了更好的对象初始化控制。可以对对象的初始化过程进行更精细的控制，确保对象在
构造器模式 BuilderPattern
GhostHouse
11-27 1552
using System; public class NiceGirl { private string _Name; private string _Tall; private string _SkinColor; private string _HairColor; private string _Weight; priv
JavaScript编程设计模式之构造器模式实例分析
01-19
本文实例讲述了JavaScript编程设计模式之构造器模式。分享给大家供大家参考，具体如下： 经典的OOP语言中，构造器（也叫构造函数）是一个用于初始化对象的特殊方法。在JS中，因为一切皆对象，对象构造器经常被提起。...
前端设计模式大全,包括工厂模式,原型模式,构造器模式等
04-18
本资料集包含了多种重要的前端设计模式，如工厂模式、原型模式和构造器模式，下面将详细阐述这些模式的核心概念和应用。 1. 工厂模式： 工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，通过抽象出...
JavaScript设计模式之构造器模式(生成器模式)定义与用法实例分析
10-18
在众多的设计模式中，构造器模式（也称为生成器模式）是实现面向对象编程的一种基本方式。在构造器模式中，构造函数用于创建特定的对象，每个新创建的实例都继承构造函数的属性和方法。 构造器模式的核心概念是利用...
JavaScript设计模式之工厂模式和构造器模式
10-24
JavaScript中的设计模式是编程中解决问题的可复用的方案模式，它不仅包括创建型、结构型、行为型三种主要设计模式类别，还涵盖众多具体的模式，如工厂模式和构造器模式。在设计模式的学习中，我们首先要区分模式与反...
《C++20设计模式》学习笔记-第2章构造器模式学习代码
02-04
第2章着重讲解了构造器模式，这是一种创建型设计模式，它关注的是对象的初始化过程。下面将详细阐述构造器模式的相关知识点，并结合提供的文件名来推测可能的学习内容。 首先，让我们理解构造器模式的基本概念。在...
Java设计模式 - 构造器模式
weixin_34343308的博客
11-01 232
　　一、构造器模式　　构造器模式，也被称为建造者、生成器模式，是设计模式中比较容易理解的模式之一。　　定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。　　上面的定义不太容易理解，简单点，构造器模式中的对象的属性是通过一个构造器来设置的，最后返回一个不同属性的对象。　　public class Toy {　　private String head;　　private ...
设计模式之：构造器模式
Fireworks
07-25 714
业务场景 构造一个复杂的对象，很多的属性，有些属性构造的时候需要做一些校验，格式转换 常见于在构建一个复杂的对象，或者是构建一个复杂的表达式的时候，在开源框架中有大量广泛的运用 在Mockito框架中，when().thenReturn()之类的，其实就是构造器模式的一种，通过多个连续的方法完成一个模拟对象的构建 还有就是spring test框架汇总，MvcMock对象，也是通过thenExpe...
设计模式之构造器模式（Builder）
weixin_45606518的博客
08-18 405
概念 Builder模式也叫建造者模式或者生成器模式。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。将一个复杂对象的构建与其表示相分离，使得同样的构建过 程(稳定)可以创建不同的表示(变化) 对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属
设计模式之建造者(构造器)模式
LQ的博客
07-04 1722
构造器模式也可以称之为建造者模式，构造器模式其实在android中使用的比较多，当然在写一些框架或封装一些模块的时候也经常会用到构造器模式。那么构造器模式适用的场景总结：适用于给定一个基础模板，可以配置多个参数，从而得到不同的结果。也就是说能够在此基础模板的基础上配置自己想要显示的模板样式。看代码示例：/** * builder模式 */ public class User { pri...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值