如何使用不同数量的参数创建对象？

Question

我的问题是如果我想创建一个代表联系人列表中的人的对象。 用户必须输入姓氏，如果不是，程序将不起作用。 除此之外，用户可以输入名字，地址，电话号码等，但这些不是必需的。 那么我该如何解决这些问题？ 我可以用不同的参数组合创建大量的构造函数，但我不认为这是正确的解决方案。

你们能帮我吗？

Answer 1

您是否听说过安装人员？

我曾经在一个项目有这个问题，我认为它是这样的：

1. 的必须填写值：通过构造函数传递它们
2. 可选值：使用setter方法

通过他们

类人的代码示例：主要CL的

public class person { 

    private String lastName; 
    private String firstName; 
    private String address; 
    private String phoneNumber; 

    //lastName is mandatory you should pass when you create your object 
    public person(String lastName) { 
     this.lastName = lastName; 
    } 

    public String getLastName() { 
     return lastName; 
    } 

    public void setLastName(String lastName) { 
     this.lastName = lastName; 
    } 

    public String getFirstName() { 
     return firstName; 
    } 

    //This is optional you can pass it using this setter 
    public void setFirstName(String firstName) { 
     this.firstName = firstName; 
    } 

    public String getAddress() { 
     return address; 
    } 

    //This is optional you can pass it using this setter 
    public void setAddress(String address) { 
     this.address = address; 
    } 

    public String getPhoneNumber() { 
     return phoneNumber; 
    } 

    //This is optional you can pass it using this setter 
    public void setPhoneNumber(String phoneNumber) { 
     this.phoneNumber = phoneNumber; 
    } 

    } 

代码示例屁股

public class yourclass { 
    public static void main(String[] args) { 
     String lastname="fooer"; //choose how you want to intercept the input if you are building a GUI app, tell me I would help you with JavaFx or Swing code. 
     String firstname="foo" //let's say this is the only optional to pass 
     person newperson = new person(lastname); 
     if (firstname.isEmpty()==false) 
      newperson.setFirstName(firstname); 

    } 
} 

Answer 2

简单的方法：使用构造强制性领域，并提供制定者看重等领域。

如果需要不变性，则需要更复杂的方法：使用构建器构建Person实例。

Builder应该是一个静态嵌套类的Person，提供了一个方法来建立一个Builder对象和Builder类提供方法来设置Builder对象的值。
此方法的每一个都会返回当前的Builder实例，但会返回创建并返回Person对象的build()。

下面是一个简单类：

public class Person { 

    private String name; 
    private String address; 
    private String phone; 

    // private constructor 
    private Person() { 
    } 

    public static class Builder { 

     private String name; 
     private String address; 
     private String phone; 

     // mandatory fields 
     public Builder(String name) { 
     this.name = name; 
     } 

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

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

     public Person build() { 
     Person p = new Person(); 
     p.name = name; 
     p.address = address; 
     p.phone = phone; 
     return p; 
     } 
    } 

} 

你可以使用它，然后以这种方式：

Person person = new Person.Builder("myName").address("myAddress").build(); 

或

Person person = new Person.Builder("myName").address("myAddress").phone("my phone").build(); 

Answer 3

你不想要尝试什么是telescoping constructor pattern？这是很容易实现，如果你有场（因而需要较小的构造函数） 的较小没有好的设计方面，可以考虑以下几点： Builder Design pattern

public class Computer { 

    //required parameters 
    private String HDD; 
    private String RAM; 

    //optional parameters 
    private boolean isGraphicsCardEnabled; 
    private boolean isBluetoothEnabled; 


    public String getHDD() { 
     return HDD; 
    } 

    public String getRAM() { 
     return RAM; 
    } 

    public boolean isGraphicsCardEnabled() { 
     return isGraphicsCardEnabled; 
    } 

    public boolean isBluetoothEnabled() { 
     return isBluetoothEnabled; 
    } 

    private Computer(ComputerBuilder builder) { 
     this.HDD=builder.HDD; 
     this.RAM=builder.RAM; 
     this.isGraphicsCardEnabled=builder.isGraphicsCardEnabled; 
     this.isBluetoothEnabled=builder.isBluetoothEnabled; 
    } 

    //Builder Class 
    public static class ComputerBuilder{ 

     // required parameters 
     private String HDD; 
     private String RAM; 

     // optional parameters 
     private boolean isGraphicsCardEnabled; 
     private boolean isBluetoothEnabled; 

     public ComputerBuilder(String hdd, String ram){ 
      this.HDD=hdd; 
      this.RAM=ram; 
     } 

     public ComputerBuilder setGraphicsCardEnabled(boolean isGraphicsCardEnabled) { 
      this.isGraphicsCardEnabled = isGraphicsCardEnabled; 
      return this; 
     } 

     public ComputerBuilder setBluetoothEnabled(boolean isBluetoothEnabled) { 
      this.isBluetoothEnabled = isBluetoothEnabled; 
      return this; 
     } 

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

    } 

} 

Answer 4

您可以使用不同的模式：

• 的JavaBeans（getter和setter）
• 伸缩构造（具有不同数量的参数）
• Builder模式

但它们中的不会保证用户输入的内容。

它主要取决于您的用户界面，以及可能从UI获得的数据。

如果UI有可能发送空值或为空字符串，那么您应该将它们处理为必填字段，因为这是您的业务逻辑，无论您使用的是哪种模式。

让我们萨雷你需要从DTOPerson这是建立新的人从UI传来：

public Person register(Person personDTO) { 
    validatePerson(personDTO); 
    Person person = new Person(personDTO.getName(), personDTO.getSurname()); 
    // for not mandatory fields 
    person.setAddress(personDTO.getAddress()); 

    // ... 
} 

public void validatePerson(Person person) { 
    Optional.ofNullable(person.getName()).orElseThrow(() -> 
     new IllegalArgumentException("Name is required!") 
    ); 

    Optional.ofNullable(person.getSurname()).orElseThrow(() -> 
      new IllegalArgumentException("Surname is required!") 
    ); 
}