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
    
  • 相关阅读:
    基于tiny4412的Linux内核移植 -- 设备树的展开
    基于tiny4412的Linux内核移植 -- MMA7660驱动移植(九-2)
    tiny4412的中断资源连接关系示意图
    基于tiny4412的Linux内核移植 -- MMA7660驱动移植(九)
    基于tiny4412的Linux内核移植 -- PWM子系统学习(八)
    spring cloud服务发现注解之@EnableDiscoveryClient与@EnableEurekaClient
    springcloud之eureka配置——eureka.instance
    Maven parent.relativePath
    mybatis中大于等于小于等于的写法
    Eureka服务注册过程详解之IpAddress(详解eureka.instance.prefer-ip-address = true 与 eureka.instance.prefer-ip-address)
  • 原文地址:https://www.cnblogs.com/Lothlorien/p/10309664.html
Copyright © 2011-2022 走看看