zoukankan      html  css  js  c++  java
  • Builder模式

    package builder;
    
    /**
     *   返回一个带有内部类的引用的外部类,外部类的参数由于有final修饰,
        所以外部类的对象是不可变的,而内部类则保证了参数的灵活构造
        这有点延迟初始化的意思,像工厂方法一样,将类的构造推迟了一下
        通过这一推迟,便推出了灵活性和不可变性
        但这也导致了对象无法进行后续修改,只能重新构造
        但这也是有解决方法的,只要把外部类的字段的final去掉,添加上
        set方法,即既可以拥有Builder模式的便利又可以灵活改变对象,只是会牺牲不可变性
    
        综上,本模式的核心在于:
        1. 内部类Builder含有外部类的字段,
        2. 每个字段的set方法返回this引用
        3. build()方法返回外部类的实例,并包含自身的引用
        4. 外部类通过内部类的引用构造自己
     */
    public class CartmanBean {
    
        private final String name;
        private final Integer age;
        private final String gender;
        private final String friend;
        private final Integer grade;
        private final String outlook;
    
        private CartmanBean(Builder builder) {
            this.name = builder.name;
            this.age = builder.age;
            this.gender = builder.gender;
            this.friend = builder.friend;
            this.grade = builder.grade;
            this.outlook = builder.outlook;
        }
    
        public static class Builder {
            // 必须初始化的参数
            private final String name;
            private final Integer age;
            // 选择初始化的参数, 没有了final
            private String gender;
            private String friend;
            private Integer grade;
            private String outlook;
    
            // 首先构造必须的参数
            public Builder(String name, int age) {
                this.name = name;
                this.age = age;
            }
    
            // 然后构造可选的参数,关键是返回this
            public Builder gender(String gender) {
                this.gender = gender;
                return this;
            }
    
            public Builder friend(String friend) {
                this.friend = friend;
                return this;
            }
    
            public Builder grade(Integer grade) {
                this.grade = grade;
                return this;
            }
    
            public Builder outlook(String outlook) {
                this.outlook = outlook;
                return this;
            }
            // 返回一个带有内部类的引用的外部类,外部类的参数由于有final修饰,
            // 所以外部类的对象是不可变的,而内部类则保证了参数的灵活构造
            // 这有点延迟初始化的意思,像工厂方法一样,将类的构造推迟了一下
            // 通过这一推迟,便推出了灵活性和不可变性
            // 但这也导致了对象无法进行后续修改,只能重新构造
            public CartmanBean build() {
                return new CartmanBean(this);
            }
        }
    
        public String getName() {
            return name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public String getGender() {
            return gender;
        }
    
        public String getFriend() {
            return friend;
        }
    
        public Integer getGrade() {
            return grade;
        }
    
        public String getOutlook() {
            return outlook;
        }
    
        @Override
        public String toString() {
            return this.name+" "+this.age+" "+this.outlook+" "+this.friend;
        }
    }
    
    
    package builder;
    
    public class Client {
    
        public static void main(String[] args) {
            CartmanBean cartman = new CartmanBean.Builder("cartman",12)
                    .friend("kyle").gender("boy").outlook("handsome").build();
            System.out.println(cartman.toString());
    
        }
    }
    
    结果:
    cartman 12 handsome kyle
    
  • 相关阅读:
    Python
    算法的时间复杂度和空间复杂度-总结
    列表自动滚动
    React 结合ant-mobile 省市区级联
    5G从小就梦想着自己要迎娶:高速率、低时延、大容量三个老婆
    一文读懂GaussDB(for Mongo)的计算存储分离架构
    cpu占用过高排查
    我是如何从零开始自学转行IT并进入世界500强实现薪资翻倍?
    Linux重定向用法详解
    说出来也许你不信,我被 Linux 终端嘲笑了……
  • 原文地址:https://www.cnblogs.com/Lothlorien/p/10309664.html
Copyright © 2011-2022 走看看