Que signifie la méthode "this()"?

Question

J'ai couru dans ce bloc de code, et il y a cette ligne que je ne quitte pas pour comprendre le sens ou ce qu'il fait.

public Digraph(In in) { 
    this(in.readInt()); 
    int E = in.readInt(); 
    for (int i = 0; i < E; i++) { 
     int v = in.readInt(); 
     int w = in.readInt(); 
     addEdge(v, w); 
    } 
} 

Je comprends ce que ou this.variable sont, mais ce qui est this()?

Answer 1

Ce sature constructeur:

public class Diagraph { 

    public Diagraph(int n) { 
     // Constructor code 
    } 


    public Digraph(In in) { 
     this(in.readInt()); // Calls the constructor above. 
     int E = in.readInt(); 
     for (int i = 0; i < E; i++) { 
     int v = in.readInt(); 
     int w = in.readInt(); 
     addEdge(v, w); 
     } 
    } 
} 

Vous pouvez dire ce code est un constructeur et non une méthode par l'absence d'un type de retour. Ceci est assez similaire à l'appel super() dans la première ligne du constructeur afin d'initialiser la classe étendue. Vous devez appeler this() (ou toute autre surcharge de this()) dans la première ligne de votre constructeur et ainsi éviter les duplications de code constructeur.

Vous pouvez également jeter un oeil à ce poste: Constructor overloading in Java - best practice

Answer 2

En utilisant this() comme une fonction comme celle-ci, appelle essentiellement le constructeur de la classe. Cela vous permet de toutes les initialisations génériques dans un constructeur et avoir des spécialisations dans d'autres. Donc, dans ce morceau de code par exemple, l'appel à this(in.readInt()) appelle le constructeur Digraph qui a un argument int.

Answer 3

Un autre constructeur de la classe Digraph avec un paramètre int.

Digraph(int param) { /* */ } 

Answer 4

Cet extrait de code est un constructeur.

Cet appel à un autre constructeur this appelle de la même classe

public App(int input) { 
} 

public App(String input) { 
    this(Integer.parseInt(input)); 
} 

Dans l'exemple ci-dessus, nous avons un constructeur qui prend un int et qui prend String. Le constructeur qui prend un String convertit le String en int puis délègue au constructeur int.

Notez qu'un appel à un autre constructeur ou à un constructeur de superclasse (super()) doit être la première ligne d'un constructeur. Jetez peut-être un coup d'œil à this pour une explication plus détaillée de la surcharge du constructeur.

Answer 5

Appel this appelle essentiellement le constructeur de la classe. Par exemple, si vous étendons quelque chose, que le long avec add(JComponent), vous pouvez faire: this.add(JComponent).

Answer 6

Constructor Surcharge:

ex:

public class Test{ 

    Test(){ 
     this(10); // calling constructor with one parameter 
     System.out.println("This is Default Constructor"); 
    } 

    Test(int number1){ 
     this(10,20); // calling constructor with two parameter 
     System.out.println("This is Parametrized Constructor with one argument "+number1); 
    } 

    Test(int number1,int number2){ 
     System.out.println("This is Parametrized Constructor with two argument"+number1+" , "+number2); 
    } 


    public static void main(String args[]){ 
     Test t = new Test(); 
     // first default constructor,then constructor with 1 parameter , then constructor with 2 parameters will be called 
    } 

} 

Answer 7

this(); est constructeur qui est utilisé pour appeler un autre constructeur dans une classe, par exemple: -

class A{ 
    public A(int,int) 
    { this(1.3,2.7);-->this will call default constructor 
    //code 
    } 
public A() 
    { 
    //code 
    } 
public A(float,float) 
    { this();-->this will call default type constructor 
    //code 
    } 
} 

Note: Je n'ai pas utilisé le constructeur this() dans le constructeur par défaut car cela conduirait à un état de blocage.

Espérons que cela vous aidera :)

Answer 8

Il est à peu près la même

public class Test { 
    public Test(int i) { /*construct*/ } 

    public Test(int i, String s){ this(i); /*construct*/ } 

}