Konstruktorüberladung in Java - Best Practice

Zwar gibt es keine "offiziellen Leitlinien" Folge ich dem Prinzip der KISS und TROCKEN. Machen die überladenen Konstruktoren so einfach wie möglich, und der einfachste Weg ist, dass Sie nur aufrufen, diese(...). So brauchen Sie nur zu prüfen und zu verarbeiten, die Parameter nur einmal.

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
    }

}

Vom unit-Test-Sicht, es werden einfach zu testen das Klasse, da kannst du in der Ressourcen in Sie. Wenn die Klasse hat viele Ressourcen (oder Mitarbeiter, als einige OO-Freaks nennen), sollten Sie eines dieser beiden Dinge:

Eine parameter-Klasse

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
}

Den Konstruktor Einfach nur entweder zu teilen braucht die SimpleParams parameter:

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

...oder machen SimpleParams ein Attribut:

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

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

Eine factory-Klasse

Machen eine factory-Klasse, initialisiert die Ressourcen für Sie, das ist günstig, wenn die Initialisierung der Ressourcen ist ein bisschen schwierig:

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

Dem Konstruktor erfolgt dann in der gleichen Weise wie bei der parameter-Klasse:

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

Eine Kombination von beiden

Yeah... Sie können mix and match, beide Möglichkeiten, je nachdem, was einfacher für Sie an der Zeit. Parameter-Klassen und einfache factory-Klassen sind ziemlich viel die gleiche Sache in Anbetracht der Simple Klasse, dass Sie auf die gleiche Art verwendet.

InformationsquelleAutor der Antwort Spoike

Wenn Sie haben eine sehr komplexe Klasse mit vielen Optionen, von denen nur einige Kombinationen gültig sind, sollten Sie erwägen, ein generator. Funktioniert sehr gut sowohl codewise aber auch logisch.

Den generator ist eine geschachtelte Klasse mit Methoden, die nur entworfen, um Felder zu setzen, und dann die ComplexClass Konstruktor nimmt nur so ein generator als ein argument.

Edit: Die ComplexClass Konstruktor sicherstellen können, dass der Staat in der Builder gültig ist. Das ist sehr schwer zu tun, wenn Sie gerade verwenden-setter auf ComplexClass.

InformationsquelleAutor der Antwort Thorbjørn Ravn Andersen

Gut, hier ist ein Beispiel für überladene Konstruktoren.

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;
   }
}

Im obigen Beispiel können Sie sehen, überladene Konstruktoren. Namen der Konstruktoren ist die gleiche, aber jeder hat verschiedene Konstruktoren Parameter.

Hier sind einige Ressourcen, die werfen mehr Licht auf der Konstruktor überladen in java,

Konstruktoren.

Konstruktor Erklärung.

InformationsquelleAutor der Antwort Shiva