sert - surcharge constructeur java




Comment appeler un constructeur d'un autre en Java? (11)

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 l'appel super()

Est-il possible d'appeler un constructeur d'un autre (au sein de 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)?


Assez simple

public class SomeClass{

    int number;
    String someString;

    public SomeClass(){
        number = 0;
    }

    public SomeClass(int number){
        this(); //set the class to 0
        this.setNumber(number); 
    }

    public SomeClass(int number, String someString){
        this(number); //call public SomeClass( int number )
    }

    public void setNumber(int number){
        this.number = number;
    }
    public void setString(String someString){
        this.someString = someString;
    }
    //.... add some accessors
}

Maintenant, voici un petit crédit supplémentaire:

public SomeOtherClass extends SomeClass {
    public SomeOtherClass(int number, String someString){
         super(number, someString); //calls public SomeClass(int number, String someString)
    }
    //.... Some other code.
}

J'espère que cela t'aides.


Dans un constructeur, vous pouvez utiliser le mot this clé this pour appeler 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.


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.


Je sais qu'il y a tellement d'exemples de cette question, mais ce que j'ai trouvé, c'est que je mets ici pour partager mon Idée. Il y a deux façons d'enchaîner les constructeurs. Dans la même classe, vous pouvez utiliser ce mot-clé. Dans Héritage, vous devez utiliser le super mot clé.

    import java.util.*;
    import java.lang.*;

    class Test
    {  
        public static void main(String args[])
        {
            Dog d = new Dog(); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.
            Dog cs = new Dog("Bite"); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.

            // You need to Explicitly tell the java compiler to use Argument constructor so you need to use "super" key word
            System.out.println("------------------------------");
            Cat c = new Cat();
            Cat caty = new Cat("10");

            System.out.println("------------------------------");
            // Self s = new Self();
            Self ss = new Self("self");
        }
    }

    class Animal
    {
        String i;

        public Animal()
        {
            i = "10";
            System.out.println("Animal Constructor :" +i);
        }
        public Animal(String h)
        {
            i = "20";
            System.out.println("Animal Constructor Habit :"+ i);
        }
    }

    class Dog extends Animal
    {
        public Dog()
        {
            System.out.println("Dog Constructor");
        }
        public Dog(String h)
        {
            System.out.println("Dog Constructor with habit");
        }
    }

    class Cat extends Animal
    {
        public Cat()
        {
            System.out.println("Cat Constructor");
        }
        public Cat(String i)
        {
            super(i); // Calling Super Class Paremetrize Constructor.
            System.out.println("Cat Constructor with habit");
        }
    }

    class Self
    {
        public Self()
        {
            System.out.println("Self Constructor");
        }
        public Self(String h)
        {
            this(); // Explicitly calling 0 args constructor. 
            System.out.println("Slef Constructor with value");
        }
    }

Le mot clé this peut être utilisé pour appeler un constructeur à partir d'un constructeur, lors de l'écriture de plusieurs constructeurs pour une classe, il y a des moments où vous voudriez appeler un constructeur d'un autre pour éviter le code dupliqué.

Bellow est un lien que j'explique d'autre sujet sur constructor et getters () et setters () et j'ai utilisé une classe avec deux constructeurs. J'espère que les explications et les exemples vous aideront.

Méthodes Setter ou constructeurs


Oui, il est possible d'appeler un constructeur à partir d'un autre. Mais il y a une règle à cela. Si un appel est passé d'un constructeur à un autre, alors

ce nouvel appel de constructeur doit être la première déclaration dans le constructeur en cours

public class Product {
     private int productId;
     private String productName;
     private double productPrice;
     private String category;

    public Product(int id, String name) {
        this(id,name,1.0);
    }

    public Product(int id, String name, double price) {
        this(id,name,price,"DEFAULT");
    }

    public Product(int id,String name,double price, String category){
        this.productId=id;
        this.productName=name;
        this.productPrice=price;
        this.category=category;
    }
}

Donc, quelque chose comme ci-dessous ne fonctionnera pas.

public Product(int id, String name, double price) {
    System.out.println("Calling constructor with price");
    this(id,name,price,"DEFAULT");
}

Oui, il est possible d'appeler un constructeur d'un autre avec l'utilisation de this()

class Example{
   private int a = 1;
   Example(){
        this(5); //here another constructor called based on constructor argument
        System.out.println("number a is "+a);   
   }
   Example(int b){
        System.out.println("number b is "+b);
   }

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

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 en tant que constructeur d'argument .. Constructeur par défaut .. int en tant que constructeur d'arg ..


Je vais vous dire un moyen facile

Il existe 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.

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







constructor