Überladen von C#-Konstruktoren

1. Konstruktoren in C#
2. Konstruktorüberladung in C#
3. Möglichkeiten zum Überladen von Konstruktoren

Das Überladen von Konstruktoren ist ein Thema, das in diesem Artikel in C# behandelt wird. Um zu beginnen, müssen wir zunächst verstehen, was Konstruktoren in C# sind.

Konstruktoren in C#

Ein Konstruktor ist eine bestimmte Klassenmethode, die immer dann aufgerufen wird, wenn eine Instanz dieser Klasse erzeugt wird. Diese Methode wird automatisch ausgelöst, wenn eine Instanz der Klasse erstellt wird.

Die Hauptfunktion des Konstruktors besteht darin, die privaten Felder der Klasse zu initialisieren, bevor eine Instanz der Klasse erstellt wird. Dies geschieht gleichzeitig mit der Erstellung der Instanz.

Wenn Sie keinen Konstruktor für die Klasse manuell erstellen, erledigt der Compiler dies für Sie und nennt ihn den Standardkonstruktor der Klasse. Der Wert Null wird allen numerischen Feldern der Klasse zugewiesen, und der Wert " " oder Null wird allen Zeichenfolgenklassen und Objektfeldern zugewiesen, wenn der Standardkonstruktor verwendet wird.

Konstruktorüberladung in C#

Das Erstellen zahlreicher Konstruktoren mit jeweils einer einzigartigen Kombination von Argumenten und einer unterschiedlichen Menge dieser Parameter wird als Konstruktorüberladung bezeichnet. Es ermöglicht uns, eine Klasse anders zu nutzen, als wir es normalerweise tun würden.

Das Überladen der Konstruktoren einer Klasse kann dazu führen, dass sich dieselbe Klasse je nach Kontext unterschiedlich verhält. Wenn das Objekt zuerst initialisiert wird, zeigt es möglicherweise nur eine einfache Textnachricht an.

Dennoch kann es einige mathematische Berechnungen durchführen, wenn es ein zweites Mal mit einem anderen Argument initialisiert wird. Das Überladen von Konstruktoren in C# ist möglich, genau wie das Überladen von Methoden in anderen Programmiersprachen, und um das Überladen von Konstruktoren zu nutzen, müssen zwei oder mehr Konstruktoren denselben Namen haben, aber unterschiedliche Funktionen haben.

Möglichkeiten zum Überladen von Konstruktoren

Das Überladen von Konstruktoren kann auf verschiedene Arten durchgeführt werden, beispielsweise mit unterschiedlichen Arten von Parametern, unterschiedlicher Anzahl von Parametern und unterschiedlicher Reihenfolge von Parametern.

Mit verschiedenen Arten von Parametern

Für dieses Verfahren werden wir zwei Telefonkonstruktoren entwerfen, von denen jeder die gleichen Argumente haben wird. In diesem Fall können wir Konstruktoren mit denselben Argumenten generieren, da sich der in den Parametern enthaltene Datentyp unterscheidet.

In der Klasse Phone haben wir zwei gleichnamige Konstruktoren konstruiert, die jedoch voneinander unterschiedliche Datentypen annehmen. Der erste Konstruktor akzeptiert eine Zeichenfolge als Argument, während der andere ganze Zahlen akzeptiert.

class Phone {
  Phone(string pbrand) {
    Console.WriteLine("Phone Brand is: " + pbrand);
  }
  Phone(int pprice) {
    Console.WriteLine("Phone Price is: " + pprice);
  }

Wir haben den Konstruktor in der Hauptmethode mit verschiedenen Argumenten überladen. In diesem Fall ruft das Objekt p den Konstruktor mit einem Parameter vom Typ String auf, während das Objekt p1 den Konstruktor mit einem Argument vom Typ int aufruft.

static void Main(string[] args) {
  Phone p = new Phone("iPhone x ");
  Console.WriteLine();

  Phone p1 = new Phone(10000);
  Console.ReadLine();
}
}

Vollständiger Quellcode:

using System;

namespace Shanii {
  class Phone {
    Phone(string pbrand) {
      Console.WriteLine("Phone Brand is: " + pbrand);
    }
    Phone(int pprice) {
      Console.WriteLine("Phone Price is: " + pprice);
    }

    static void Main(string[] args) {
      Phone p = new Phone("iPhone x ");
      Console.WriteLine();

      Phone p1 = new Phone(10000);
      Console.ReadLine();
    }
  }
}

Ausgang:

Phone Brand is: iPhone x
Phone Price is: 10000

Mit unterschiedlicher Anzahl von Parametern

Das folgende Beispiel zeigt, dass der Phone-Konstruktor zwei Konstruktoren hat, einen ohne Parameter und den anderen mit einem.

Wir haben zwei Phone-Konstruktoren mit demselben Namen in der Phone-Klasse erstellt. Einer benötigt keine Parameter, während der andere einen Parameter benötigt.

class Phone {
  Phone() {
    Console.WriteLine("A Phone Constructor with no parameter");
  }
  Phone(string pbrand) {
    Console.WriteLine("A Phone constructor with one parameter");
    Console.WriteLine("Phone Brand: " + pbrand);
  }
}

Nachdem wir nun Konstruktoren erstellt haben, verwenden wir sie in der Funktion Main(), um ihre jeweiligen Methoden aufzurufen. Wie Sie sehen können, rufen beide Objekte p und p1 gleichnamige Konstruktoren auf.

Der relevante Konstruktor wird basierend auf dem Wert des Parameters aufgerufen, der an den Konstruktor geliefert wird.

static void Main(string[] args) {
  Phone p = new Phone();
  Console.WriteLine();

  Phone p1 = new Phone("Samsung S22 ultra");
  Console.ReadLine();
}

Vollständiger Quellcode:

using System;
namespace Shanii {

  class Phone {
    Phone() {
      Console.WriteLine("A Phone Constructor with no parameter");
    }
    Phone(string pbrand) {
      Console.WriteLine("A Phone constructor with one parameter");
      Console.WriteLine("Phone Brand: " + pbrand);
    }

    static void Main(string[] args) {
      Phone p = new Phone();
      Console.WriteLine();

      Phone p1 = new Phone("Samsung S22 ultra");
      Console.ReadLine();
    }
  }
}

Ausgang:

A Phone Constructor with no parameter

A Phone constructor with one parameter
Phone Brand: Samsung S22 ultra

Mit unterschiedlicher Reihenfolge der Parameter

Hier gibt es zwei verschiedene Konstruktoren, die jeweils die gleiche Anzahl an Argumenten haben. Dies ist machbar, da die Reihenfolge der Datentypen in Parametern verschiedene Formen annehmen kann.

Im ersten Phone-Konstruktor kommt der String-Datentyp vor dem int-Datentyp, während im zweiten Phone-Konstruktor der int-Datentyp vor dem string-Datentyp steht, was einen Unterschied zwischen beiden macht die Telefon-Konstruktoren.

Phone(string pbrand, int pprice) {
  Console.WriteLine("Phone Brand: " + pbrand);
  Console.WriteLine("Phone Price: " + pprice);
}
Phone(int Andriodversion, string pbrand) {
  Console.WriteLine("Phone Andriod Version: " + Andriodversion);
  Console.WriteLine("Phone Brand: " + pbrand);
}

Wir haben die Konstruktoren überladen, indem wir die Argumente in unterschiedlicher Reihenfolge in der Funktion Main() übergeben haben.

static void Main(string[] args) {
  Phone p = new Phone("Samsung Galaxy s22", 10000);
  Console.WriteLine();

  Phone p1 = new Phone(15, " iPhone 13 pro");
  Console.ReadLine();
}

Vollständiger Quellcode:

using System;
namespace Shanii {
  class Phone {
    Phone(string pbrand, int pprice) {
      Console.WriteLine("Phone Brand: " + pbrand);
      Console.WriteLine("Phone Price: " + pprice);
    }
    Phone(int Andriodversion, string pbrand) {
      Console.WriteLine("Phone Andriod Version: " + Andriodversion);
      Console.WriteLine("Phone Brand: " + pbrand);
    }
    static void Main(string[] args) {
      Phone p = new Phone("Samsung Galaxy s22", 10000);
      Console.WriteLine();

      Phone p1 = new Phone(15, " iPhone 13 pro");
      Console.ReadLine();
    }
  }
}

Ausgang:

Phone Brand: Samsung Galaxy s22
Phone Price: 10000

Phone Andriod Version: 15
Phone Brand:  iPhone 13 pro