JAVA建造者模式

看到别人的代码顿觉精妙,记录留存。

应用场景:假设有一个问题,我们需要创建一个学生对象,属性有name,number,class,sex,age,school等属性,如果每一个属性都可以为空,也就是说我们可以只用一个name,也可以用一个school,name,或者一个class,number,或者其他任意的赋值来创建一个学生对象,这时该怎么构造?

难道我们写6个1个输入的构造函数,15个2个输入的构造函数.......吗?这个时候就需要用到Builder模式了。

public class Builder {

    static class Student{
        String name = null ;
        int number = -1 ;
        String sex = null ;
        int age = -1 ;
        String school = null ;
        static class StudentBuilder{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
            public StudentBuilder setName(String name) {
                this.name = name;
                return  this ;
            }

            public StudentBuilder setNumber(int number) {
                this.number = number;
                return  this ;
            }

            public StudentBuilder setSex(String sex) {
                this.sex = sex;
                return  this ;
            }

            public StudentBuilder setAge(int age) {
                this.age = age;
                return  this ;
            }

            public StudentBuilder setSchool(String school) {
                this.school = school;
                return  this ;
            }
            public Student build() {
                return new Student(this);
            }
        }

        public Student(StudentBuilder builder){
            this.age = builder.age;
            this.name = builder.name;
            this.number = builder.number;
            this.school = builder.school ;
            this.sex = builder.sex ;
        }
    }

    public static void main( String[] args ){
        /**
         * Student.StudentBuilder()方法新建StudentBuilder静态类,然后调用setAge方法设置年龄,由于所有
         * set方法都返回StudentBuilder类对象,所以可以一直调用,直至需要设置的属性设置完毕然后调用Student
         * 有参构造方法,以StudentBuilder为参数,将刚才所设置的参数一一赋值,关键在于每个set函数返回值都是
         * 一个StudentBuilder对象,这样才能灵活调用所有设置方法
         */

        Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
        Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
    }
}

研究清楚了这个方法扩展思考:干嘛非得多建静态类,于是有了下面代码:

class Human {
    private String name;
    private int age;
    private String sex;

    public Human setName(String name) {
        this.name = name;
        return this;
    }
    public Human setAge(int age) {
        this.age = age;
        return this;
    }
    public Human setSex(String sex) {
        this.sex = sex;
        return this;
    }
    
     public Human Human(){
        return this;
     }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }
}

public class Builder {

    static class Student{
        String name = null ;
        int number = -1 ;
        String sex = null ;
        int age = -1 ;
        String school = null ;
        static class StudentBuilder{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
            public StudentBuilder setName(String name) {
                this.name = name;
                return  this ;
            }

            public StudentBuilder setNumber(int number) {
                this.number = number;
                return  this ;
            }

            public StudentBuilder setSex(String sex) {
                this.sex = sex;
                return  this ;
            }

            public StudentBuilder setAge(int age) {
                this.age = age;
                return  this ;
            }

            public StudentBuilder setSchool(String school) {
                this.school = school;
                return  this ;
            }
            public Student build() {
                return new Student(this);
            }
        }

        public Student(StudentBuilder builder){
            this.age = builder.age;
            this.name = builder.name;
            this.number = builder.number;
            this.school = builder.school ;
            this.sex = builder.sex ;
        }
    }

    public static void main( String[] args ){
        /**
         * Student.StudentBuilder()方法新建StudentBuilder静态类,然后调用setAge方法设置年龄,由于所有
         * set方法都返回StudentBuilder类对象,所以可以一直调用,直至需要设置的属性设置完毕然后调用Student
         * 有参构造方法,以StudentBuilder为参数,将刚才所设置的参数一一赋值,关键在于每个set函数返回值都是
         * 一个StudentBuilder对象,这样才能灵活调用所有设置方法
         */

        Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
        Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
        Human h = new Human().setAge(1).setName("张三");
    }
}

也能实现此功,并且看上去更简单点,或许原代码有其他拓展功能,各位求指教。

### Java 建造者模式的实现与用法 建造者模式(Builder Pattern)是一种创建型设计模式,其目的是将复杂对象的构建过程与其表示分离,使得同样的构建过程可以创建不同的表示[^1]。以下是关于建造者模式Java中的实现与用法的详细说明。 #### 1. 建造者模式的核心概念 建造者模式主要由以下几部分组成: - **Product(产品角色)**:表示被构建的复杂对象。 - **Builder(抽象建造者)**:为创建一个Product对象的各个部件指定抽象接口。 - **ConcreteBuilder(具体建造者)**:实现Builder接口,构建并装配该产品的各个部件。 - **Director(指挥者)**:构造一个使用Builder接口的对象[^2]。 #### 2. 示例代码解析 以下是一个简单的建造者模式实现示例: ```java // Product类 public class Actor { private String type; private String sex; private String face; private String costume; private String hairstyle; public void setType(String type) { this.type = type; } public void setSex(String sex) { this.sex = sex; } public void setFace(String face) { this.face = face; } public void setCostume(String costume) { this.costume = costume; } public void setHairstyle(String hairstyle) { this.hairstyle = hairstyle; } public String getType() { return type; } public String getSex() { return sex; } public String getFace() { return face; } public String getCostume() { return costume; } public String getHairstyle() { return hairstyle; } } ``` ```java // 抽象建造者 public abstract class ActorBuilder { protected Actor actor = new Actor(); public abstract void buildType(); public abstract void buildSex(); public abstract void buildFace(); public abstract void buildCostume(); public abstract void buildHairstyle(); public Actor createActor() { return actor; } } ``` ```java // 具体建造者 public class HeroBuilder extends ActorBuilder { @Override public void buildType() { actor.setType("英雄"); } @Override public void buildSex() { actor.setSex("男性"); } @Override public void buildFace() { actor.setFace("英俊"); } @Override public void buildCostume() { actor.setCostume("铠甲"); } @Override public void buildHairstyle() { actor.setHairstyle("短发"); } } ``` ```java // 指挥者 public class ActorController { public Actor construct(ActorBuilder ab) { ab.buildType(); ab.buildSex(); ab.buildFace(); ab.buildCostume(); ab.buildHairstyle(); return ab.createActor(); } } ``` ```java // 测试类 public class Client { public static void main(String[] args) { ActorBuilder builder = new HeroBuilder(); ActorController controller = new ActorController(); Actor hero = controller.construct(builder); System.out.println(hero.getType() + "的外观"); System.out.println("性别:" + hero.getSex()); System.out.println("面容:" + hero.getFace()); System.out.println("服装:" + hero.getCostume()); System.out.println("发型:" + hero.getHairstyle()); } } ``` 上述代码展示了如何通过建造者模式创建一个复杂的`Actor`对象。每个具体建造者负责构建不同类型的`Actor`,而指挥者`ActorController`则负责协调建造者的构建过程[^3]。 #### 3. 使用场景 建造者模式适用于以下场景: - 当需要创建复杂对象时,对象的构建过程独立于其表示。 - 当需要将对象的构建过程分解为多个步骤,并允许用户只通过指定必要的部分来构建对象时[^4]。 #### 4. 优点 - 将复杂对象的构建过程与其表示分离,使得相同的构建过程可以创建不同的表示。 - 提高了系统的灵活性和扩展性,便于维护和修改。 #### 5. 缺点 - 增加了系统的复杂性,引入了额外的类和对象。 - 如果产品对象的变化较为频繁,则可能导致需要频繁修改建造者类[^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值