J'ai rencontré ce bloc de code, et il y a cette seule ligne que je n'arrête pas de 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 sont this.method()
ou this.variable
, Mais qu'est-ce que this()
?
C'est la surcharge du 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 que ce code est un constructeur et non une méthode par l'absence d'un type de retour. C'est assez similaire à l'appel de 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 éviter ainsi les duplications de code constructeur.
Vous pouvez également consulter cet article: Surcharge du constructeur dans Java - meilleure pratique
Utiliser this () comme une fonction comme ça, appelle essentiellement le constructeur de la classe. Cela vous permet de toutes les initialisations génériques dans un constructeur et d'avoir des spécialisations dans d'autres. Ainsi, dans ce morceau de code par exemple, l'appel à this(in.readInt())
appelle le constructeur Digraph qui a un argument int.
Cet extrait de code est un constructeur.
Cet appel à this
appelle un autre constructeur 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 un qui prend un 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 un coup d'œil à this pour une explication plus détaillée de la surcharge du constructeur.
C'est presque pareil
public class Test {
public Test(int i) { /*construct*/ }
public Test(int i, String s){ this(i); /*construct*/ }
}
Un autre constructeur de la classe Digraph avec un paramètre int.
Digraph(int param) { /* */ }
L'appel de this
appelle essentiellement le constructeur de classe. Par exemple, si vous étendez quelque chose, avec add(JComponent)
, vous pouvez faire: this.add(JComponent).
this();
est un 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
}
}
Remarque: je n'ai pas utilisé le constructeur this()
dans le constructeur par défaut car cela entraînerait un état de blocage.
J'espère que ceci vous aidera:)
Surcharge du constructeur:
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
}
}