que - overloading java

¿Qué significa el método "this()"?

Question

Me encontré con este bloque de código, y hay una línea que no dejo de entender el significado o lo que está haciendo.

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

Entiendo lo que son this.method() o this.variable , pero ¿qué es this() ?

Answer 1

Es casi lo mismo

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

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

}

Answer 2

Este fragmento de código es un constructor.

Esta llamada a this llama a otro constructor de la misma clase

public App(int input) {
}

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

En el ejemplo anterior tenemos un constructor que toma un int y uno que toma un String . El constructor que toma una String convierte la String en una int y luego delega en el constructor int .

Tenga en cuenta que una llamada a otro constructor o un constructor de superclase ( super() ) debe ser la primera línea en un constructor.

Tal vez eche un vistazo a this para una explicación más detallada de la sobrecarga del constructor.

Answer 3

Esto es sobrecarga de constructor:

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

Puedes decir que este código es un constructor y no un método por la falta de un tipo de devolución. Esto es muy similar a llamar a super() en la primera línea del constructor para inicializar la clase extendida. Debería llamar a this() (o cualquier otra sobrecarga de this() ) en la primera línea de su constructor y así evitar las duplicaciones de código de constructor.

También puedes echar un vistazo a esta publicación: Sobrecarga de constructores en Java: mejor práctica

Answer 4

Llamar a this esencialmente llama a la clase Constructor. Por ejemplo, si está ampliando algo, que junto con add(JComponent) , podría hacer: this.add(JComponent).

Answer 5

Otro constructor de la clase Digraph con un parámetro int.

Digraph(int param) { /*  */ }

Answer 6

Sobrecarga del Constructor:

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

Usando this () como una función como esa, esencialmente llama al Constructor de la clase. Esto le permite todas las inicializaciones genéricas en un constructor y tiene especializaciones en otros. Entonces, en este fragmento de código, por ejemplo, la llamada a this(in.readInt()) llama al constructor Digraph que tiene un argumento int.

Answer 8

this(); es un constructor que se usa para llamar a otro constructor en una clase, por ejemplo:

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

Nota: no usé this() constructor en el constructor predeterminado porque conducirá al estado de interbloqueo.

Espero que esto te ayudará:)