Pregunta ¿Cómo puedo llamar a un constructor de otro en Java?


¿Es posible llamar a un constructor desde otro (dentro de la misma clase, no desde una subclase)? Si es así, ¿cómo? ¿Y cuál podría ser la mejor manera de llamar a otro constructor (si hay varias formas de hacerlo)?


1823
2017-11-12 20:10


origen


Respuestas:


Sí, es posible:

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

Para encadenar a un constructor de superclase particular en lugar de uno en la misma clase, use super en lugar de this. Tenga en cuenta que solo puedes encadenar a un constructory tiene que ser la primera declaración en tu cuerpo constructor.

Ver también esta pregunta relacionada, que es sobre C # pero donde se aplican los mismos principios.


2464
2017-11-12 20:12



Utilizando this(args). El patrón preferido es trabajar desde el constructor más pequeño hasta el más grande.

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

También puede usar un enfoque defendido más recientemente de valueOf o simplemente "de":

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

Para llamar a una súper clase, use super(asdf). La llamada a super debe ser la primera llamada en el constructor o obtendrá un error de compilación.


198
2018-03-11 20:33



[Nota: Solo quiero agregar un aspecto, que no vi en las otras respuestas: cómo superar las limitaciones del requisito de que esto () debe estar en la primera línea).]

En Java, se puede llamar a otro constructor de la misma clase desde un constructor a través de this(). Tenga en cuenta sin embargo que this tiene que estar en la primera línea.

public class MyClass {

  public MyClass(double argument1, double argument2) {
    this(argument1, argument2, 0.0);
  }

  public MyClass(double argument1, double argument2, double argument3) {
    this.argument1 = argument1;
    this.argument2 = argument2;
    this.argument3 = argument3;
  }
}

Ese this tiene que aparecer en la primera línea parece una gran limitación, pero puede construir los argumentos de otros constructores a través de métodos estáticos. Por ejemplo:

public class MyClass {

  public MyClass(double argument1, double argument2) {
    this(argument1, argument2, getDefaultArg3(argument1, argument2));
  }

  public MyClass(double argument1, double argument2, double argument3) {
    this.argument1 = argument1;
    this.argument2 = argument2;
    this.argument3 = argument3;
  }

  private static double getDefaultArg3(double argument1, double argument2) {
    double argument3 = 0;

    // Calculate argument3 here if you like.

    return argument3;

  }

}

177
2018-04-23 23:12



Cuando necesito llamar a otro constructor desde dentro del código (no en la primera línea), suelo usar un método de ayuda como este:

class MyClass {
   int field;


   MyClass() {
      init(0);
   } 
   MyClass(int value) {
      if (value<0) {
          init(0);
      } 
      else { 
          init(value);
      }
   }
   void init(int x) {
      field = x;
   }
}

Pero la mayoría de las veces trato de hacerlo al revés llamando a los constructores más complejos desde los más simples en la primera línea, en la medida de lo posible. Para el ejemplo anterior

class MyClass {
   int field;

   MyClass(int value) {
      if (value<0)
         field = 0;
      else
         field = value;
   }
   MyClass() {
      this(0);
   }
}

36
2018-05-26 15:09



Dentro de un constructor, puede usar this palabra clave para invocar a otro constructor en la misma clase. Hacer esto se llama invocación explícita del constructor.

Aquí hay otra clase Rectangle, con una implementación diferente a la de la sección Objetos.

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

}

Esta clase contiene un conjunto de constructores. Cada constructor inicializa algunas o todas las variables de miembros del rectángulo.


23
2018-05-07 22:52



Como todos ya han dicho, tú usas this(…), que se llama invocación explícita del constructor.

Sin embargo, tenga en cuenta que dentro de una declaración de invocación de constructor tan explícita no puedes referirte a

  • alguna variables de instancia o
  • alguna métodos de instancia o
  • alguna clases internas declarado en esta clase o cualquier superclase, o
  • this o
  • super.

Como se establece en JLS (§8.8.7.1).


12
2017-11-21 13:14



Te diré una manera fácil

Existen dos tipos de constructores:

  1. Constructor predeterminado
  2. Constructor parametrizado

Explicaré en un ejemplo

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

En el ejemplo anterior, mostré 3 tipos de llamadas

  1. this () llamada a esto debe ser primera instrucción en constructor
  2. Este es Name less Object. esto llama automáticamente al constructor predeterminado. 3. Esto llama al constructor parametrizado.

Nota: esta debe ser la primera declaración en el constructor.


7
2017-11-27 19:01