Question

在构造函数中包含很多参数是错误的吗？像10到15个参数？因为我正在设计一个类，其中构造函数将具有许多参数，例如，Person类。

我的示例person类在其构造函数中有6个参数：

public class Person {
    private String fName;
    private String lName;
    private String mInitial;
    private int age;
    private String contactNumber;
    private String emailAddress;

    public Person(String fName, String lName, String mInitial, int age, String contactNumber, String emailAddress) {
       //insert rest of code here 
    }
}

这是错的吗？为构造函数创建大量参数？

然后我打算创建一个名为Employee的类，然后将其扩展到person类，然后它也会有一个很长的构造函数。

令我担心的是实践，这是好还是什么？还有其他建议吗？

Answer 1

通常，如果您发现自己的参数太多，则意味着您没有足够的低级别课程。在您的情况下，您可以拥有class Name { /* fname, lname, initial, */ }，也许还有class Contact { /* email, phone */ }
扩展类时，让构造函数将base作为一个参数，然后添加新的额外参数。（您可能意味着Employee将扩展Person，而不是相反，因此public Employee (Person person, Company company, String employeeId) { super(person); this.company = company; this.employeeId = employeeId; }

好问题！

Answer 2

使用 builder pattern

，而不是使用 telescoping构造函数模式

public class Person {
    private final String fName;
    private final String lName;
    private final String mInitial;
    private final int age;
    private final String contactNumber;
    private final String emailAddress;

    public Person(PersonBuilder builder) {
       //insert rest of code here 
       fName = builder.fName;
       ...
    }

    public static class PersonBuilder {
        private String fName;
        private String lName;
        private String mInitial;
        private int age;
        private String contactNumber;
        private String emailAddress;
        // setter methods
        public PersonBuilder setFirstName(String name) {
             fName = name;
             return this;
        }
        ...
        // build method
        public Person build() {
            return new Person(this);
        }

    }
}

...

Person p = new PersonBuilder()
              .setFirstName("")
              // set all the setter methods
              .build();

Answer 3

您可以将Person分解为Name和Contact。

public class ComposedPerson {
    private Name name;
    private int age;
    private Contact contact;

    public ComposedPerson(Name name, int age, Contact contact) {
        this.name = name;
        this.age = age;
        this.contact = contact;
    }

    public static void main(String... args) {
        Name name = new Name("John");
        Contact contact = new Contact("12345", "john@doe.com");
        ComposedPerson person = new ComposedPerson(name, 45, contact);
   }

示例Name。看看我如何使用伸缩构造函数来允许可选参数。

public class Name {
    private String fName;
    private String lName;
    private String mInitial;

    public Name(String fName) {
        this(fName, null, null);
    }

    public Name(String fName, String lName) {
        this(fName, lName, null);
    }

    public Name(String fName, String lName, String mInitial) {
        this.fName = fName;
        this.lName = lName;
        this.mInitial = mInitial;
    }
}

Answer 4

是的，在任何类型的函数中都有很多参数是不好的。根据一本名为Code Complete 2的书，最大参数应该在7左右。

这是因为它会降低代码可读性和可维护性和可用性。想象一下，在同一个项目上工作的其他开发人员，如何遵循您的代码？

例如，有许多不同的方法来处理这种工厂模式。这取决于您如何设计应用程序。

但是在你的代码中，我认为没有。参数仍然可以接受（6个参数）

如果您的对象需要这么多参数来实例化，那么您需要重新考虑如何设计代码。例如，某些属性是否可以包装到单独的类中？可以将某些属性作为参数传递吗？即，从另一个类中获取值。等...

在构造函数中有很多参数

4 个答案: