Item2: Consider a builder when faced with many constructor parameters

最新推荐文章于 2025-08-12 16:23:29 发布

翻译最新推荐文章于 2025-08-12 16:23:29 发布 · 140 阅读

文章标签：

#design pattern #builder

java 专栏收录该内容

87 篇文章

订阅专栏

本文深入探讨了建造者模式在Java中的应用，通过两个实例详细解释了该模式如何简化复杂对象的创建过程，同时保持代码的清晰性和安全性。第一个实例展示了自行车对象的构建，第二个实例则演示了计算机对象的构建，包括个人电脑和掌上电脑的不同配置。

easier to read and write than Telescoping Constructor Pattern, and safer than Java Bean Style.

demo1:

class Bike{
    private Integer size;

    private String color;

    private String ring;

    private String cup;

    static class Builder{
        private Integer size;

        private String color;

        private String ring;

        private String cup;

        Builder(Integer size, String color){
            this.size = size;
            this.color = color;
        }

        public Builder ring(String ring){
            this.ring = ring;
            return this;
        }

        public Builder cup(String cup){
            this.cup = cup;
            return this;
        }

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

    private Bike(Builder builder){
        this.size = builder.size;
        this.color = builder.color;
        this.cup = builder.cup;
        this.ring = builder.ring;
    }
}

demo2:

abstract class Computer{
    private String cpu;

    abstract static class Builder<T extends Builder<T>>{
        private String cpu;

        public T cpu(String cpu){
            this.cpu = cpu;
            return self();
        }

        abstract Computer build();

        abstract protected T self();
    }

    Computer(Builder<?> builder){
        this.cpu = builder.cpu;
    }
}

class PersonalComputer extends Computer{

    private String fan;

    static class Builder extends Computer.Builder<Builder>{

        private String fan;

        public Builder fan(String fan){
            this.fan = fan;
            return this;
        }

//        @Override
//        public Builder builder() {
//            return new Builder();
//        }

        @Override
        protected Builder self() {
            return this;
        }

        @Override
        public PersonalComputer build(){
            return new PersonalComputer(this);
        }
    }

    protected PersonalComputer(Builder builder) {
        super(builder);
        this.fan = builder.fan;
    }
}

class PalmComputer extends Computer{
    private String camera;

    static class Builder extends Computer.Builder<Builder>{

        private String camera;

        public Builder camera(String camera){
            this.camera = camera;
            return this;
        }

//        @Override
//        public Builder builder() {
//            return null;
//        }

        @Override
        protected Builder self() {
            return this;
        }

        @Override
        public PalmComputer build(){
            return new PalmComputer(this);
        }
    }
    private PalmComputer(Builder builder){
        super(builder);
        this.camera = builder.camera;
    }
}

test unit:

    public static void main(String[] args) {
        Bike myBike = new Bike.Builder(80, "red").cup("yes").ring("yes").build();
        PersonalComputer personalComputer = new PersonalComputer.Builder().fan("three leaves").cpu("four cores").build();
        PalmComputer palmComputer = new PalmComputer.Builder().cpu("8 cores").camera("two cameras").build();
    }