Surcharge du constructeur C#

Dans cet article, vous découvrirez la surcharge de constructeurs en C# à l'aide d'exemples.

En C#, comme pour la surcharge de méthodes, nous pouvons également surcharger les constructeurs. Pour la surcharge de constructeur, il doit y avoir deux constructeurs ou plus avec le même nom mais différent

nombre de paramètres
types de paramètres
ordre des paramètres

Avant d'en savoir plus sur la surcharge des constructeurs, assurez-vous de connaître les constructeurs C#.

Nous pouvons effectuer la surcharge du constructeur de la manière suivante :

1. Nombre différent de paramètres

Nous pouvons surcharger le constructeur si le nombre de paramètres dans un constructeur est différent.

 class Car {   

  Car() {
    ...
  }

  Car(string brand) {
    ...
  }
    
  Car(string brand, int price) {
    ...
  }

}

Ici, nous avons trois constructeurs dans la classe Car . Il est possible d'avoir plusieurs constructeurs car le nombre de paramètres dans les constructeurs est différent.

Remarquez que,

Car() { } - n'a pas de paramètre
Car(string brand) { } - a un paramètre
Car(string brand, int price) { } - a deux paramètres

Exemple :surcharge du constructeur avec un nombre différent de paramètres

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with no parameter
    Car() {
      Console.WriteLine("Car constructor");
    }
     
    // constructor with one parameter
    Car(string brand) {
      Console.WriteLine("Car constructor with one parameter");
      Console.WriteLine("Brand: " + brand);
    }

    static void Main(string[] args) {

      // call with no parameter
      Car car = new Car();

      Console.WriteLine();

      // call with one parameter 
      Car car2 =  new Car("Bugatti");
     
      Console.ReadLine();
    }
  }
}

Sortie

Car constructor

Car constructor with one parameter
Brand: Bugatti

Dans l'exemple ci-dessus, nous avons surchargé Car constructeur :

un constructeur a un paramètre
un autre a deux paramètres

En fonction du numéro de l'argument passé lors de l'appel du constructeur, le constructeur correspondant est appelé.

Ici,

Objet voiture - appelle le constructeur avec un paramètre
Objet voiture2 - appelle le constructeur avec deux paramètres

2. Différents types de paramètres

class Car {   

  Car(string brand) {
    ...
   }

  Car(int price) {
    ...
  }
}

Ici, nous avons deux Voiture constructeurs avec le même nombre de paramètres. Nous pouvons créer des constructeurs avec les mêmes paramètres car le type de données à l'intérieur des paramètres est différent.

Remarquez que,

Car(string brand) { } - a le paramètre de string taper
Car(int price) { } - a le paramètre de int taper

Exemple :surcharge du constructeur avec différents types de paramètres

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with string parameter
    Car(string brand) {
      Console.WriteLine("Brand: " + brand);
    }

    // constructor  with int parameter
    Car(int price) {
      Console.WriteLine("Price: " + price);
    }

    static void Main(string[] args) {

      // call constructor  with string parameter
      Car car = new Car("Lamborghini");
      
      Console.WriteLine();

      // call constructor  with int parameter
      Car car2 =new Car(50000);
    
      Console.ReadLine();
    }
  }
}

Sortie

Brand: Lamborghini

Price: 50000

Dans le programme ci-dessus, nous avons surchargé le constructeur avec différents types de paramètres.

Ici,

Objet voiture - appelle le constructeur avec string paramètre de type
Objet voiture2 - appelle le constructeur avec int paramètre de type

3. Ordre différent des paramètres

Car {

  Car(string brand, int price) {
    ...
  }

  Car(int speed, string color) {
    ... 
  }

}

Ici, nous avons deux constructeurs avec le même nombre de paramètres. Cela est possible car l'ordre des types de données dans les paramètres est différent.

Remarquez que,

Car(string brand, int price) { } - string le type de données vient avant int
Car(int speed, string color) { } - int le type de données vient avant string

Exemple :surcharge du constructeur avec un ordre différent des paramètres

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with string and int parameter
    Car(string brand, int price) {

      Console.WriteLine("Brand: " + brand);
      Console.WriteLine("Price: " + price);
    }
    
    // constructor with int and string parameter
    Car(int speed, string color) {
      
      Console.WriteLine("Speed: " + speed + " km/hr");
      Console.WriteLine("Color: " + color);
    }
    static void Main(string[] args) {

      // call constructor  with string and int parameter
      Car car = new Car("Bugatti", 50000);
      
      Console.WriteLine();

      // call constructor with int and string parameter
      Car car2 =new Car(60, "Red");
    
      Console.ReadLine();
    }
  }
}

Sortie

Brand: Bugatti
Price: 50000

Speed: 60 km/hr
Color: Red

Dans le programme ci-dessus, nous avons surchargé les constructeurs avec différents ordres de paramètres.

Ici,

Objet voiture - appelle le constructeur avec string et int paramètre respectivement
Objet voiture2 - appelle le constructeur avec int et string paramètre respectivement

Surcharge de méthode C# C# en utilisant

Langue C