überladen - java vererbung




Wie rufe ich einen Konstruktor von einem anderen in Java auf? (11)

Das Schlüsselwort this kann verwendet werden, um einen Konstruktor von einem Konstruktor aufzurufen. Wenn Sie mehrere Konstruktoren für eine Klasse schreiben, gibt es Situationen, in denen Sie einen Konstruktor von einem anderen Konstruktor aufrufen möchten, um doppelten Code zu vermeiden.

Bellow ist ein Link, den ich zu einem anderen Thema über Konstruktor und Getter () und Setter () erkläre, und ich habe eine Klasse mit zwei Konstruktoren verwendet. Ich hoffe die Erklärungen und Beispiele helfen dir.

Setter Methoden oder Konstruktoren

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


Es gibt Entwurfsmuster, die die Notwendigkeit komplexer Konstruktionen abdecken - wenn es nicht prägnant gelingt, erstellen Sie eine Fabrikmethode oder eine Fabrikklasse.

Mit dem neuesten Java und dem Hinzufügen von Lambdas ist es einfach, einen Konstruktor zu erstellen, der jeden gewünschten Initialisierungscode akzeptiert.

class LambdaInitedClass {

   public LamdaInitedClass(Consumer<LambdaInitedClass> init) {
       init.accept(this);
   }
}

Nennen Sie es mit ...

 new LambdaInitedClass(l -> { // init l any way you want });

Innerhalb eines Konstruktors können Sie das Schlüsselwort this , um einen anderen Konstruktor in derselben Klasse aufzurufen. Dies wird als expliziter Konstruktoraufruf bezeichnet .

Hier ist eine weitere Rectangle-Klasse mit einer anderen Implementierung als im Abschnitt Objects.

public class Rectangle {
    private int x, y;
    private int width, height;

    public Rectangle() {
        this(1, 1);
    }
    public Rectangle(int width, int height) {
        this( 0,0,width, height);
    }
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }

}

Diese Klasse enthält eine Reihe von Konstruktoren. Jeder Konstruktor initialisiert einige oder alle der Elementvariablen des Rechtecks.


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

Beispiel:

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 den Konstruktor nur das Überladungskonzept anwendbar ist und nicht Vererbung oder Überschreibung.


Ja, es ist möglich, einen Konstruktor von einem anderen unter Verwendung von this() aufzurufen this()

class Example{
   private int a = 1;
   Example(){
        this(5); //here another constructor called based on constructor argument
        System.out.println("number a is "+a);   
   }
   Example(int b){
        System.out.println("number b is "+b);
   }

Ja, es ist möglich:

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

    public Foo(int x) {
        this.x = x;
    }
}

Um an einen bestimmten Superklassenkonstruktor statt an einen in derselben Klasse zu ketten, verwenden Sie stattdessen super . Beachten Sie, dass Sie nur zu einem Konstruktor verketten können , und es muss die erste Anweisung in Ihrem Konstruktorhauptteil sein .

Siehe auch diese verwandte Frage , die sich auf C # bezieht , wo aber die gleichen Prinzipien gelten.


Sie können einen Konstruktor aus einem anderen Konstruktor der gleichen Klasse verwenden, indem Sie das Schlüsselwort "this" verwenden. Beispiel -

class This1
{
    This1()
    {
        this("Hello");
        System.out.println("Default constructor..");
    }
    This1(int a)
    {
        this();
        System.out.println("int as arg constructor.."); 
    }
    This1(String s)
    {
        System.out.println("string as arg constructor..");  
    }

    public static void main(String args[])
    {
        new This1(100);
    }
}

Ausgabe - String als Arg-Konstruktor .. Default-Konstruktor .. int als Arg-Konstruktor ..


Verwenden Sie this(args) . Das bevorzugte Muster besteht darin, vom kleinsten Konstruktor zum größten zu arbeiten.

public class Cons {

 public Cons() {
  // A no arguments constructor that sends default values to the largest
  this(madeUpArg1Value,madeUpArg2Value,madeUpArg3Value);
 }

 public Cons(int arg1, int arg2) {
  // An example of a partial constructor that uses the passed in arguments
  // and sends a hidden default value to the largest
  this(arg1,arg2, madeUpArg3Value);
 }

 // Largest constructor that does the work
 public Cons(int arg1, int arg2, int arg3) {
  this.arg1 = arg1;
  this.arg2 = arg2;
  this.arg3 = arg3;
 }
}

Sie können auch einen in jüngerer Zeit empfohlenen Ansatz von valueOf oder nur von "of" verwenden:

public class Cons {
 public static Cons newCons(int arg1,...) {
  // This function is commonly called valueOf, like Integer.valueOf(..)
  // More recently called "of", like EnumSet.of(..)
  Cons c = new Cons(...);
  c.setArg1(....);
  return c;
 }
} 

Um eine super(asdf) , verwenden Sie super(asdf) . Der Aufruf von super muss der erste Aufruf im Konstruktor sein oder Sie erhalten einen Compilerfehler.


Wie alle bereits gesagt haben, verwenden Sie this(…) , was als expliziter Konstruktoraufruf bezeichnet wird .

Beachten Sie jedoch, dass Sie innerhalb einer solchen expliziten Konstruktoraufrufanweisung nicht darauf verweisen können

  • beliebige Instanzvariablen oder
  • alle Instanzmethoden oder
  • alle inneren Klassen , die in dieser Klasse oder einer Oberklasse deklariert sind, oder
  • this oder
  • super .

Wie in JLS (§8.8.7.1) angegeben.


Ziemlich einfach

public class SomeClass{

    int number;
    String someString;

    public SomeClass(){
        number = 0;
    }

    public SomeClass(int number){
        this(); //set the class to 0
        this.setNumber(number); 
    }

    public SomeClass(int number, String someString){
        this(number); //call public SomeClass( int number )
    }

    public void setNumber(int number){
        this.number = number;
    }
    public void setString(String someString){
        this.someString = someString;
    }
    //.... add some accessors
}

Jetzt hier ist ein kleiner zusätzlicher Kredit:

public SomeOtherClass extends SomeClass {
    public SomeOtherClass(int number, String someString){
         super(number, someString); //calls public SomeClass(int number, String someString)
    }
    //.... Some other code.
}

Hoffe das hilft.


Ich werde dir einen einfachen Weg sagen

Es gibt zwei Arten von Konstruktoren:

  1. Standardkonstruktor
  2. Parametrisierter Konstruktor

Ich werde das in einem Beispiel erklären

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

Im obigen Beispiel habe ich 3 Anrufarten gezeigt

  1. Dieser Aufruf von this () muss die erste Anweisung im Konstruktor sein
  2. Dies ist Name ohne Objekt. Dies ruft automatisch den Standardkonstruktor auf. 3.Dies ruft den parametrisierten Konstruktor auf.

Hinweis: Dies muss die erste Anweisung im Konstruktor sein.





constructor