构造函数重载在Java中 - 最佳实践(Constructor overloading in Jav

类似的还有这几个主题，但我无法找到一个具有足够的答案。

我想知道什么是Java中构造函数重载的最佳实践。 我已经有我自己关于这个问题的想法，但我想听到更多的建议。

我指的是这两个构造函数重载在一个简单的类和构造函数重载继承的同时已经超载的类（意为基类已经重载的构造函数）。

谢谢 ：）

Answer 1:

虽然没有“官方指南”我跟KISS和DRY原则。 请重载构造尽可能简单和最简单的方法是，他们只是把这种（...）。 这样，你只需要检查和一次且仅一次处理的参数。

public class Simple {

    public Simple() {
        this(null);
    }

    public Simple(Resource r) {
        this(r, null);
    }

    public Simple(Resource r1, Resource r2) {
        // Guard statements, initialize resources or throw exceptions if
        // the resources are wrong
        if (r1 == null) {
            r1 = new Resource();
        }
        if (r2 == null) {
            r2 = new Resource();
        }

        // do whatever with resources
    }

}

从单元测试的角度来看，它会变得容易，测试类，因为你可以把资源放在它。 如果类有很多资源（或合作者一些OO-爱好者称呼它），考虑这两件事之一：

做一个参数类

public class SimpleParams {
    Resource r1;
    Resource r2;
    // Imagine there are setters and getters here but I'm too lazy 
    // to write it out. you can make it the parameter class 
    // "immutable" if you don't have setters and only set the 
    // resources through the SimpleParams constructor
}

在简单的构造函数只需要两种分裂SimpleParams参数：

public Simple(SimpleParams params) {
    this(params.getR1(), params.getR2());
}

......或使SimpleParams属性：

public Simple(Resource r1, Resource r2) {
    this(new SimpleParams(r1, r2));
}

public Simple(SimpleParams params) {
    this.params = params;
}

做一个工厂类

做一个工厂类，初始化的资源给你，这是有利的，如果初始化资源是有点难度：

public interface ResourceFactory {
    public Resource createR1();
    public Resource createR2();
}

构造函数然后以同样的方式与参数类来完成：

public Simple(ResourceFactory factory) {
    this(factory.createR1(), factory.createR2());
} 

使两者的结合

是啊...你可以混合和匹配取决于是什么的时候你更容易左右逢源。 参数类和简单的工厂类是相当多的考虑同样的事情， Simple类，他们正在用同样的方式。

Answer 2:

我认为最好的做法是， 单一的主构造到重载构造函数调用是指this()与相关参数的默认值。 这样做的原因是，它使得它更清楚什么是对象的构造状态是-真的，你能想到主构造作为唯一真正的构造中，其他人只是委托给它

这方面的一个例子是JTable -主构造需要一个TableModel （加列和选择模式），另一个构造函数调用这个主构造。

对于那些超已经有了重载的构造函数的子类，我会倾向于认为它是合理的治疗任何父类的构造函数作为主要的，并认为这是完全合法的不是有一个单一的主构造。 例如，当延伸Exception ，所以经常提供3个构造方法，一个以只是一个String消息，一个采取Throwable原因和其它同时服用。 每个构造函数调用的super直接。

Answer 3:

如果你有很多，其中只有一些组合是有效的选择一个非常复杂的类，可以考虑使用生成器。 作品非常好两者codewise也是逻辑。

所述生成器是与仅设计来设置字段的方法的嵌套类，然后将ComplexClass构造只需要这样一个生成器作为参数。

---

编辑：ComplexClass构造可以保证在Builder中的状态是有效的。 这是很难做到的，如果你只是使用上ComplexClass制定者。

Answer 4:

这真的取决于那种类，因为不是所有的类都是一样的。

作为一般原则，我建议2种选择：

• 对于值不变类（例外，整型的DTO和例如）使用单主构造如在上面建议的答案
• 对于一切（会话Bean，服务，可变对象，JPA和JAXB实体等）使用默认的构造函数只有在所有属性合理的默认值，因此可以无需额外配置使用

Answer 5:

好了，下面是重载的构造函数的例子。

public class Employee
{
   private String name;
   private int age;

   public Employee()
   {
      System.out.println("We are inside Employee() constructor");
   }

   public Employee(String name)
   {
      System.out.println("We are inside Employee(String name) constructor");
      this.name = name;
   }

   public Employee(String name, int age)
   {
      System.out.println("We are inside Employee(String name, int age) constructor");
      this.name = name;
      this.age = age;
   }

   public Employee(int age)
   {
      System.out.println("We are inside Employee(int age) constructor");
      this.age = age; 
   }

   public String getName()
   {
      return name;
   }

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

   public int getAge()
   {
      return age;
   }

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

在上面的例子中，你可以看到的重载构造。 构造函数的名称是相同的，但每一个构造函数都有不同的参数。

这里有一些资源，扔在构造函数中的Java超载较为清淡，

构造函数 。

构造解释 。

文章来源: Constructor overloading in Java - best practice