Question Comment appeler un constructeur d'un autre en Java?


Est-il possible d'appeler un constructeur d'un autre (dans la même classe, pas d'une sous-classe)? Si oui comment? Et quelle pourrait être la meilleure façon d'appeler un autre constructeur (s'il y a plusieurs façons de le faire)?


1823
2017-11-12 20:10


origine


Réponses:


Oui c'est possible:

public class Foo {
    private int x;

    public Foo() {
        this(1);
    }

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

Pour chaîner un constructeur de superclasse particulier au lieu d'un dans la même classe, utilisez super au lieu de this. Notez que vous pouvez seulement enchaîner à un constructeur, et il doit être la première déclaration dans votre corps de constructeur.

Voir également cette question connexe, qui est à propos de C #, mais où les mêmes principes s'appliquent.


2464
2017-11-12 20:12



En utilisant this(args). Le modèle préféré est de travailler du plus petit constructeur au plus grand.

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

Vous pouvez également utiliser une approche préconisée plus récemment de valueOf ou simplement "of":

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

Pour appeler une super classe, utilisez super(asdf). L'appel à super doit être le premier appel dans le constructeur ou vous obtiendrez une erreur de compilation.


198
2018-03-11 20:33



[Note: Je veux juste ajouter un aspect, que je n'ai pas vu dans les autres réponses: comment surmonter les limitations de l'exigence que this () doive être sur la première ligne).]

En Java, un autre constructeur de la même classe peut être appelé depuis un constructeur via this(). Notez cependant que this doit être sur la première ligne.

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

Cette this doit apparaître sur la première ligne ressemble à une grande limitation, mais vous pouvez construire les arguments des autres constructeurs via des méthodes statiques. Par exemple:

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



Quand j'ai besoin d'appeler un autre constructeur à l'intérieur du code (pas sur la première ligne), j'utilise généralement une méthode d'assistance comme celle-ci:

class MyClass {
   int field;


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

Mais le plus souvent, j'essaie de faire le contraire en appelant les constructeurs les plus complexes à partir des plus simples de la première ligne, dans la mesure du possible. Pour l'exemple ci-dessus

class MyClass {
   int field;

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

36
2018-05-26 15:09



Au sein d'un constructeur, vous pouvez utiliser le this mot-clé pour invoquer un autre constructeur dans la même classe. Cela s'appelle un invocation de constructeur explicite.

Voici une autre classe Rectangle, avec une implémentation différente de celle de la section 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;
    }

}

Cette classe contient un ensemble de constructeurs. Chaque constructeur initialise certaines ou toutes les variables membres du rectangle.


23
2018-05-07 22:52



Comme tout le monde l'a déjà dit, vous utilisez this(…), qui s'appelle un invocation de constructeur explicite.

Cependant, gardez à l'esprit que dans une telle déclaration d'invocation de constructeur explicite vous ne pouvez pas vous référer à

  • tout variables d'instance ou
  • tout méthodes d'instance ou
  • tout classes internes déclaré dans cette classe ou toute superclasse, ou
  • this ou
  • super.

Comme indiqué dans JLS (§8.8.7.1).


12
2017-11-21 13:14



Je vais vous dire un moyen facile

Il y a deux types de constructeurs:

  1. Constructeur par défaut
  2. Constructeur paramétré

Je vais expliquer dans un exemple

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

Dans l'exemple ci-dessus, j'ai montré 3 types d'appels

  1. this () appel à this doit être la première instruction dans le constructeur
  2. C'est Nom moins Objet. ceci appelle automatiquement le constructeur par défaut. 3.Cela appelle le constructeur Parameterized.

Remarque: ceci doit être la première déclaration dans le constructeur.


7
2017-11-27 19:01



Vous pouvez un constructeur d'un autre constructeur de même classe en utilisant "this" mot-clé. Exemple -

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

Sortie - chaîne comme constructeur d'arg .. Constructeur par défaut .. int comme constructeur d'arg ..


5
2018-03-03 09:27



Appel de constructeur à partir d'un autre constructeur

class MyConstructorDemo extends ConstructorDemo
{
    MyConstructorDemo()
    {
        this("calling another constructor");
    }
    MyConstructorDemo(String arg)
    {
        System.out.print("This is passed String by another constructor :"+arg);
    }
}

Vous pouvez également appeler le constructeur parent en utilisant super() appel


5
2017-09-13 05:48