什么是一些常见的,现实世界的例子使用Builder模式的？它给你带来了什么？为什么不使用工厂模式？
到目前为止,我使用构建器模式的以下实现(与此处描述的实现相反):
public class Widget {
public static class Builder {
public Builder(String name, double price) { ... }
public Widget build() { ... }
public Builder manufacturer(String value) { ... }
public Builder serialNumber(String value) { ... }
public Builder model(String value) { ... }
}
private Widget(Builder builder) { ... }
}
这适用于我遇到的大多数情况,我需要使用各种必需/强制和可选参数来构建复杂对象.然而,最近我一直在努力了解当所有参数都是强制性的(或至少绝大多数参数)时,模式是如何有益的.
解决这个问题的一种方法是将传入的参数逻辑分组到它们自己的类中,以减少传递给构建器构造函数的参数数量.
例如,而不是:
Widget example = new Widget.Builder(req1, req2, req3,req4,req5,req6,req7,req8)
.addOptional(opt9)
.build();
分组如下:
Object1 group1 = new Object1(req1, req2, req3, req4);
Object2 group2 …最近我搜索了一种初始化复杂对象的方法,而没有将大量参数传递给构造函数.我尝试使用构建器模式,但我不喜欢这样的事实,即如果我确实设置了所有需要的值,我无法在编译时检查.
当我使用构建器模式创建我的Complex对象时,创建更"类型安全",因为它更容易看到用于什么参数:
new ComplexBuilder()
.setFirst( "first" )
.setSecond( "second" )
.setThird( "third" )
...
.build();
但现在我遇到了问题,我很容易错过一个重要的参数.我可以在build()方法中检查它,但这只是在运行时.如果我错过了什么,在编译时没有什么可以警告我.
现在我的想法是创建一个构建器,"提醒"我是否错过了所需的参数.我的第一次尝试看起来像这样:
public class Complex {
private String m_first;
private String m_second;
private String m_third;
private Complex() {}
public static class ComplexBuilder {
private Complex m_complex;
public ComplexBuilder() {
m_complex = new Complex();
}
public Builder2 setFirst( String first ) {
m_complex.m_first = first;
return new Builder2();
}
public class Builder2 {
private Builder2() {}
Builder3 setSecond( String …我有一个带有以下代码的类，在这里我希望使用任何代表数字的类/类型都是琐碎的。我发现自己定义了大量的方法，如下所示：
public class Range {
private BigDecimal inferior = new BigDecimal(0);
private BigDecimal superior = new BigDecimal(1);
public Range(BigDecimal inferior, BigDecimal superior) {
if (inferior.compareTo(superior) == -1) {
this.inferior = inferior;
this.superior = superior;
}
}
public Range(int inferior, int superior) {
this(new BigDecimal(inferior), new BigDecimal(superior));
}
public Range(Integer inferior, Integer superior) {
this(new BigDecimal(inferior), new BigDecimal(superior));
}
public Range(float inferior, float superior) {
this(new BigDecimal(inferior), new BigDecimal(superior));
}
public Range(double inferior, double superior) {
this(new BigDecimal(inferior), new BigDecimal(superior));
} …例如,我有一个构建GUI的类,一个处理GUI所有事件的类,以及包含受GUI对象(主要是滑块)影响的所有对象的主类,以及GUI类和事件类.
现在,事件类的构造函数具有GUI类和GUI所更改的每个对象作为参数.这些都是相当多的对象,所以我现在拥有的论据数量大约是8,而且还在增长.
对我的问题有一个更优雅的解决方案,30个参数根本感觉不对吗？
ps,我宁愿不合并类,因为这三个都很大,并且会使一切都变得不那么可读.
我有一个关于封装的问题:
当一个类有很多数据字段时,是否建议使用封装？
使用以下类作为示例:
abstract public class Character {
private String name;
private String characterClass;
private int level;
private int hitDice;
private int strength;
private int constitution;
private int dexterity;
private int intelligence;
private int wisdom;
private int charisma;
private int hp;
private int currentHp;
private int armorClass;
private int BaseAttackBonus;
private long xp;
private double gp;
private Inventory inventory;
private double carriedWeight;
private Equipment equipment;
protected Character(String name) {
setName(name);
setCharacterClass("Class");
setLevel(1);
setHitDice(0);
setStrength(10);
setConstitution(10);
setDexterity(10);
setIntelligence(10);
setWisdom(10);
setCharisma(10);
setHp((int) …我有一个构建器模式，在该模式中，很可能所有参数都是必需的，因此我创建了一个长的构造函数，如下代码所示。
public final class ResponseHolder {
// all below six are related to response information
private final String response;
private final boolean isLinking;
private final TypeHold typeOfId;
private final long userTimeInMs;
private final long userLmdInDays;
private final String maskInfo;
// below two are related to error handling
private final ErrorCode error;
private final StatusCode status;
private ResponseHolder(Builder builder) {
this.response = builder.response;
this.isLinking = builder.isLinking;
this.typeOfId = builder.typeOfId;
this.userTimeInMs = builder.userTimeInMs;
this.userLmdInDays = builder.userLmdInDays;
this.maskInfo = builder.maskInfo;
this.error = builder.error; …