Wie rufe ich in Java einen Konstruktor von einem anderen aus auf?

Question

Ist es möglich, einen Konstruktor von einem anderen aufzurufen (innerhalb der gleichen Klasse, nicht von einer Unterklasse)? Wenn ja, wie? Und was könnte der beste Weg sein, einen anderen Konstruktor aufzurufen (wenn es mehrere Möglichkeiten gibt)?

Answer 1

Mit diesem Schlüsselwort können wir einen Konstruktor in einem anderen Konstruktor innerhalb derselben Klasse aufrufen.

Beispiel :-

 public class Example {

      private String name;

      public Example() {
          this("Mahesh");
      }

      public Example(String name) {
          this.name = name;
      }

 }

Answer 2

Wie bereits gesagt wurde, verwenden Sie this(…) die als expliziter Konstruktoraufruf .

Beachten Sie jedoch, dass innerhalb einer solchen expliziten Konstruktoraufrufanweisung Sie dürfen sich nicht auf

• tout Instanzvariablen o
• tout Beispielmethoden o
• tout innere Klassen die in dieser Klasse oder einer Oberklasse deklariert sind, oder
• this o
• super .

Wie in JLS (§8.8.7.1) angegeben.

Answer 3

Ja, es kann eine beliebige Anzahl von Konstruktoren in einer Klasse vorhanden sein, und sie können von einem anderen Konstruktor aufgerufen werden, indem this() [Bitte nicht verwechseln this() Konstruktoraufruf mit this Schlüsselwort]. this() o this(args) sollte die erste Zeile im Konstruktor sein.

Exemple :

Class Test {
    Test() {
        this(10); // calls the constructor with integer args, Test(int a)
    }
    Test(int a) {
        this(10.5); // call the constructor with double arg, Test(double a)
    }
    Test(double a) {
        System.out.println("I am a double arg constructor");
    }
}

Dies wird als Konstruktorüberladung bezeichnet.
Bitte beachten Sie, dass für Konstruktoren nur das Überladungskonzept gilt und nicht die Vererbung oder das Überschreiben.

Answer 4

Ja, es ist möglich, einen Konstruktor von einem anderen aus aufzurufen. Aber es gibt dafür eine Regel. Wenn ein Aufruf von einem Konstruktor zu einem anderen gemacht wird, dann

der Aufruf des neuen Konstruktors muss die erste Anweisung im aktuellen Konstruktor sein

public class Product {
     private int productId;
     private String productName;
     private double productPrice;
     private String category;

    public Product(int id, String name) {
        this(id,name,1.0);
    }

    public Product(int id, String name, double price) {
        this(id,name,price,"DEFAULT");
    }

    public Product(int id,String name,double price, String category){
        this.productId=id;
        this.productName=name;
        this.productPrice=price;
        this.category=category;
    }
}

So etwas wie unten wird also nicht funktionieren.

public Product(int id, String name, double price) {
    System.out.println("Calling constructor with price");
    this(id,name,price,"DEFAULT");
}

Auch bei der Vererbung wird bei der Erstellung eines Objekts der Unterklasse zunächst der Konstruktor der Oberklasse aufgerufen.

public class SuperClass {
    public SuperClass() {
       System.out.println("Inside super class constructor");
    }
}
public class SubClass extends SuperClass {
    public SubClass () {
       //Even if we do not add, Java adds the call to super class's constructor like 
       // super();
       System.out.println("Inside sub class constructor");
    }
}

Daher wird auch in diesem Fall zunächst ein weiterer Konstruktoraufruf deklariert, bevor andere Anweisungen erfolgen.

Answer 5

Ich werde Ihnen einen einfachen Weg zeigen

Hay zwei Typen von Konstrukteuren:

1. Standard-Konstruktor
2. Parametrisierter Konstruktor

Ich erkläre es an einem Beispiel

class ConstructorDemo 
{
      ConstructorDemo()//Default Constructor
      {
         System.out.println("D.constructor ");
      }

      ConstructorDemo(int k)//Parameterized constructor
      {
         this();//-------------(1)
         System.out.println("P.Constructor ="+k);       
      }

      public static void main(String[] args) 
      {
         //this(); error because "must be first statement in constructor
         new ConstructorDemo();//-------(2)
         ConstructorDemo g=new ConstructorDemo(3);---(3)    
       }
   }                  

In dem obigen Beispiel habe ich 3 Arten von Aufrufen gezeigt

1. der Aufruf von this() muss die erste Anweisung im Konstruktor sein
2. Dies ist Name less Object und ruft automatisch den Standardkonstruktor auf. 3. dies ruft den parametrisierten Konstruktor auf.

Note : muss dies die erste Anweisung im Konstruktor sein.