Überladen des C#-Konstruktors

Überladen des C#-Konstruktors

In diesem Artikel erfahren Sie anhand von Beispielen mehr über das Überladen von Konstruktoren in C#.

In C# können wir ähnlich wie beim Überladen von Methoden auch Konstruktoren überladen. Für das Überladen von Konstruktoren müssen zwei oder mehr Konstruktoren mit demselben Namen, aber unterschiedlichen

vorhanden sein

• Anzahl Parameter
• Arten von Parametern
• Reihenfolge der Parameter

Bevor Sie etwas über das Überladen von Konstruktoren lernen, sollten Sie sich mit C#-Konstruktoren vertraut machen.

---

Wir können das Überladen von Konstruktoren auf folgende Weise durchführen:

1. Unterschiedliche Parameteranzahl

Wir können den Konstruktor überladen, wenn die Anzahl der Parameter in einem Konstruktor unterschiedlich ist.

 class Car {   

  Car() {
    ...
  }

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

}

Hier haben wir drei Konstruktoren in der Klasse Car . Es ist möglich, mehr als einen Konstruktor zu haben, da die Anzahl der Parameter in Konstruktoren unterschiedlich ist.

Beachten Sie das,

• Car() { } - hat keinen Parameter
• Car(string brand) { } - hat einen Parameter
• Car(string brand, int price) { } - hat zwei Parameter

Beispiel:Konstruktorüberladung mit unterschiedlicher Parameteranzahl

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

Ausgabe

Car constructor

Car constructor with one parameter
Brand: Bugatti

Im obigen Beispiel haben wir Car überladen Konstruktor:

1. ein Konstruktor hat einen Parameter
2. ein anderer hat zwei Parameter

Basierend auf der Nummer des beim Konstruktoraufruf übergebenen Arguments wird der entsprechende Konstruktor aufgerufen.

Hier,

• Objekt Auto - ruft den Konstruktor mit einem Parameter auf
• Objekt car2 - ruft Konstruktor mit zwei Parametern auf

---

2. Verschiedene Arten von Parametern

class Car {   

  Car(string brand) {
    ...
   }

  Car(int price) {
    ...
  }
}

Hier haben wir zwei Autos Konstruktoren mit der gleichen Anzahl von Parametern. Wir können Konstruktoren mit denselben Parametern erstellen, da der Datentyp innerhalb der Parameter unterschiedlich ist.

Beachten Sie das,

• Car(string brand) { } - hat den Parameter string eingeben
• Car(int price) { } - hat den Parameter int eingeben

Beispiel:Konstruktorüberladung mit verschiedenen Arten von Parametern

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

Ausgabe

Brand: Lamborghini

Price: 50000

Im obigen Programm haben wir den Konstruktor mit verschiedenen Arten von Parametern überladen.

Hier,

1. Objekt Auto - ruft den Konstruktor mit string auf Typparameter
2. Objekt car2 - ruft den Konstruktor mit int auf Typparameter

---

3. Unterschiedliche Reihenfolge der Parameter

Car {

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

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

}

Hier haben wir zwei Konstruktoren mit der gleichen Anzahl von Parametern. Dies ist möglich, weil die Reihenfolge der Datentypen in Parametern unterschiedlich ist.

Beachten Sie das,

• Car(string brand, int price) { } - string Datentyp kommt vor int
• Car(int speed, string color) { } - int Datentyp kommt vor string

Beispiel:Konstruktorüberladung mit unterschiedlicher Parameterreihenfolge

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

Ausgabe

Brand: Bugatti
Price: 50000

Speed: 60 km/hr
Color: Red

Im obigen Programm haben wir die Konstruktoren mit unterschiedlichen Reihenfolgen von Parametern überladen.

Hier,

1. Objekt Auto - ruft den Konstruktor mit string auf und int Parameter
2. Objekt car2 - ruft den Konstruktor mit int auf und string Parameter