C# Constructor Overbelasting

In dit artikel leer je aan de hand van voorbeelden over constructor overloading in C#.

In C# kunnen we, net als bij methode-overloading, constructors ook overbelasten. Voor overbelasting van constructeurs moeten er twee of meer constructeurs zijn met dezelfde naam, maar verschillend

• aantal parameters
• type parameters
• volgorde van parameters

Voordat u meer te weten komt over overbelasting van constructors, moet u eerst meer weten over C#-constructors.

We kunnen constructor overloading op de volgende manieren uitvoeren:

1. Ander aantal parameters

We kunnen de constructor overbelasten als het aantal parameters in een constructor verschillend is.

 class Car {   

  Car() {
    ...
  }

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

}

Hier hebben we drie constructeurs in de klasse Auto . Het is mogelijk om meer dan één constructor te hebben omdat het aantal parameters in constructors verschillend is.

Merk op dat,

• Car() { } - heeft geen parameter
• Car(string brand) { } - heeft één parameter
• Car(string brand, int price) { } - heeft twee parameters

Voorbeeld:Overbelasting van constructor met verschillend aantal parameters

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

Uitvoer

Car constructor

Car constructor with one parameter
Brand: Bugatti

In het bovenstaande voorbeeld hebben we de Auto . overbelast constructeur:

1. één constructor heeft één parameter
2. een andere heeft twee parameters

Op basis van het nummer van het argument dat is doorgegeven tijdens de constructor-aanroep, wordt de corresponderende constructor aangeroepen.

Hier,

• Object auto - roept constructor aan met één parameter
• Object car2 - roept constructor aan met twee parameters

2. Verschillende soorten parameters

class Car {   

  Car(string brand) {
    ...
   }

  Car(int price) {
    ...
  }
}

Hier hebben we twee Auto constructeurs met hetzelfde aantal parameters. We kunnen constructors maken met dezelfde parameters omdat het gegevenstype binnen de parameters anders is.

Merk op dat,

• Car(string brand) { } - heeft parameter van string typ
• Car(int price) { } - heeft parameter van int typ

Voorbeeld:Constructor overbelasting met verschillende soorten parameters

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

Uitvoer

Brand: Lamborghini

Price: 50000

In het bovenstaande programma hebben we de constructor overladen met verschillende soorten parameters.

Hier,

1. Object auto - roept constructor aan met string type parameter
2. Object car2 - roept constructor aan met int type parameter

3. Andere volgorde van parameters

Car {

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

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

}

Hier hebben we twee constructors met hetzelfde aantal parameters. Dit is mogelijk omdat de volgorde van het gegevenstype in parameters anders is.

Merk op dat,

• Car(string brand, int price) { } - string gegevenstype komt vóór int
• Car(int speed, string color) { } - int gegevenstype komt voor string

Voorbeeld:Constructor overbelasting met verschillende volgorde van parameters

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

Uitvoer

Brand: Bugatti
Price: 50000

Speed: 60 km/hr
Color: Red

In het bovenstaande programma hebben we de constructeurs overladen met verschillende volgordes van parameters.

Hier,

1. Object auto - roept constructor aan met string en int parameter respectievelijk
2. Object car2 - roept constructor aan met int en string parameter respectievelijk