《Effective Java》第2条：遇到多个构造器参数时要考虑使用构建器

于 2025-03-16 11:00:00 发布
阅读量870 收藏 19
点赞数 15
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34912208/article/details/146135107
版权

在《Effective Java》一书中，第2条建议强调了在遇到多个构造器参数时，应考虑使用构建器（Builder）模式。这一建议旨在解决当类的构造器参数过多时，代码可读性和可维护性下降的问题。

1. 为什么选择使用构建器

  1. 可读性增强：

    • 当一个类的构造器包含多个参数时，尤其是当这些参数类型相同时，调用构造器时很容易出错。使用构建器模式可以通过方法链的方式，使代码更具可读性，参数的意义更加明确。

  2. 灵活性提高：

    • 构建器模式允许通过多个步骤来构建对象，可以在创建对象的过程中进行更细粒度的控制。此外，构建器可以方便地支持可选参数的设定，而不需要为每一种参数组合都提供一个单独的构造器。

  3. 防止构造器膨胀：

    • 随着类的发展，可能需要添加更多的构造器参数。使用构建器可以避免构造器参数的组合爆炸问题，即不需要为每一种可能的参数组合都提供一个构造器。

2. 正例与反例

2.1 反例：

假设有一个表示营养信息的类NutritionFacts，它包含多个构造器参数：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0); // 默认calories为0
    }

    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0); // 默认fat为0
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat) {
        this(servingSize, servings, calories, fat, 0); // 默认sodium为0
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0); // 默认carbohydrate为0
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }
}

这种方式的缺点是：构造器重载使得代码难以阅读和维护，且当添加新的字段时，需要修改所有构造器。

2.2 正例：

使用构建器模式重构NutritionFacts类：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        private int servingSize = 0;
        private int servings = 1;
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder servingSize(int val) {
            servingSize = val;
            return this;
        }

        public Builder servings(int val) {
            servings = val;
            return this;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }

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

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

使用构建器创建对象：

NutritionFacts cocaCola = new NutritionFacts.Builder()
    .servingSize(240)
    .servings(8)
    .calories(100)
    .sodium(35)
    .carbohydrate(27)
    .build();

这种方式使得代码更加清晰，且易于扩展。

3. 构建器在Java编程中的重要性

构建器模式在Java编程中非常重要，尤其是在需要创建不可变对象且构造器参数较多时。它提高了代码的可读性和可维护性，使得对象创建过程更加灵活和安全。

4. 具体建议及最佳实践

在Java编程中，使用构建器（Builder）模式时，可以遵循以下具体的建议或最佳实践：

4.1 使用静态内部类作为构建器

  • 原因：将构建器实现为类的静态内部类，可以方便地访问外围类的私有成员，同时保持命名空间的整洁。静态内部类与外部类共享同一个包作用域，因此可以访问外部类的所有成员（包括私有成员）。

  • 示例：

    public class Person {
    private final String name;
    private final int age;
    private final String address;

    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.address = builder.address;
    }

    public static class Builder {
        private String name;
        private int age;
        private String address;

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

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

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

        public Person build() {
            return new Person(this);
        }
    }
}
4.2 支持方法链设计

  • 原因：构建器的方法应返回构建器自身（this），以便支持方法链调用。这样可以使客户端代码更加简洁，提高可读性。

  • 示例：

    Person person = new Person.Builder()
    .setName("Alice")
    .setAge(30)
    .setAddress("123 Main St")
    .build();
4.3 设置合理的默认值

  • 原因：在构建器中为可选参数设置合理的默认值，可以减少客户端代码的复杂性。这样，客户端在调用构建器时，只需设置必要的参数，而无需为所有参数提供值。

  • 示例：

    public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        private int servingSize = 240; // 默认份量为240毫升
        private int servings = 1;      // 默认份数为1份
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        // 设置方法...

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
}
4.4 考虑不可变性

  • 原因：使用构建器模式时，通常与不可变对象一起使用。不可变对象在创建后不能被修改，这有助于保证线程安全，并简化并发编程。

  • 示例：

    public class ImmutablePerson {
    private final String name;
    private final int age;

    private ImmutablePerson(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public static class Builder {
        private final String name;
        private final int age;

        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public ImmutablePerson build() {
            return new ImmutablePerson(this);
        }
    }
}
4.5 保持构建器方法的幂等性

  • 原因：构建器的方法应该是幂等的，即多次调用同一个方法应该产生相同的结果。这有助于避免在构建过程中因重复设置参数而导致的错误。

  • 示例：

    public class Car {
    private final String brand;
    private final String model;
    private String color = "Red"; // 默认颜色为红色

    private Car(Builder builder) {
        this.brand = builder.brand;
        this.model = builder.model;
        this.color = builder.color;
    }

    public static class Builder {
        private final String brand;
        private final String model;
        private String color;

        public Builder(String brand, String model) {
            this.brand = brand;
            this.model = model;
        }

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

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

    在上面的示例中，setColor方法是幂等的，多次调用该方法将始终覆盖之前的颜色设置。

4.6 在构建器中执行必要的验证

  • 原因：在构建对象之前，可以在构建器中执行必要的验证逻辑，以确保构建的对象是有效的。这有助于避免在对象创建后才发现问题。

  • 示例：

    public class ValidatedPerson {
    private final String name;
    private final int age;

    private ValidatedPerson(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public static class Builder {
        private String name;
        private int age;

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

        public Builder setAge(int age) {
            if (age < 0 || age > 120) {
                throw new IllegalArgumentException("Age must be between 0 and 120");
            }
            this.age = age;
            return this;
        }

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

4.7 避免在构建器中暴露过多的实现细节

  • 原因：构建器应仅暴露构建对象所必需的方法，避免暴露过多的实现细节。这有助于保持构建器的简洁性，并减少客户端代码的错误。

  • 示例：

    避免在构建器中提供与构建对象无关的方法，例如获取中间状态的方法。

通过遵循以上最佳实践，可以在Java项目中有效地应用构建器模式，提高代码的质量、可读性和可维护性。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

探_无止境

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值