Jeder kann coden / Programmieren & TicTacToe / Objektorientierte Programmierung / Objektorientierte Programmierung in C#
Konstruktoren in C#¶
|
|
|
Konstruktoren in C# - Microsoft Docs (Tutorial) C# Constructors Tutorial - TutorialsTeacher this-Schlüsselwort in C# - Microsoft Docs base-Schlüsselwort in C# - Microsoft Docs |
Konstruktoren in C# sind spezielle Methoden, die beim Erstellen einer Instanz einer Klasse automatisch aufgerufen werden. Sie dienen der Initialisierung von Objekten und bieten verschiedene Funktionen, um eine ordnungsgemäße und effiziente Objektkonstruktion zu gewährleisten.
Wichtige Eigenschaften von Konstruktoren¶
- Gleicher Name wie die Klasse: Der Konstruktor muss denselben Namen wie die Klasse haben.
class MyClass
{
public MyClass() { }
}
Kein Rückgabewert: Konstruktoren haben keinen Rückgabewert, nicht einmal
void.Automatische Ausführung: Sie werden automatisch aufgerufen, wenn eine Instanz der Klasse erstellt wird:
MyClass obj = new MyClass();
- Überladbarkeit: Konstruktoren können überladen werden, um verschiedene Initialisierungsvarianten zu unterstützen.
class MyClass
{
public MyClass() { }
public MyClass(int value) { }
}
Typen von Konstruktoren¶
- Standardkonstruktor: Wenn kein Konstruktor definiert wird, stellt C# automatisch einen Standardkonstruktor bereit.
class MyClass
{
// Kein expliziter Konstruktor
}
class Program
{
static void Main()
{
MyClass obj = new MyClass(); // Standardkonstruktor wird verwendet
}
}
- Parameterisierte Konstruktoren: Ermöglichen die Initialisierung von Objekten mit bestimmten Werten.
class MyClass
{
public int Value;
public MyClass(int value)
{
Value = value;
}
}
- Statische Konstruktoren: Initialisieren statische Mitglieder einer Klasse und werden nur einmal aufgerufen.
class MyClass
{
static MyClass()
{
Console.WriteLine("Statischer Konstruktor wird aufgerufen.");
}
}
- Kopierkonstruktoren: Initialisieren ein Objekt basierend auf einem anderen Objekt derselben Klasse.
class MyClass
{
public int Value;
public MyClass(MyClass obj)
{
Value = obj.Value;
}
}
Nutzung von Schlüsselwörtern¶
this: Ruft einen anderen Konstruktor derselben Klasse auf.
class MyClass
{
public int Value;
public MyClass() : this(0) { }
public MyClass(int value)
{
Value = value;
}
}
base: Ruft den Konstruktor der Basisklasse auf.
class BaseClass
{
public BaseClass(string message)
{
Console.WriteLine(message);
}
}
class DerivedClass : BaseClass
{
public DerivedClass() : base("Hallo von der Basisklasse") { }
}
new: Erstellt eine neue Instanz und ruft den Konstruktor auf.
MyClass obj = new MyClass();
Praxisbeispiel¶
Angenommen, wir modellieren Umweltdaten-Sensoren:
class Sensor
{
public string Name { get; private set; }
public string Location { get; private set; }
// Standardkonstruktor
public Sensor()
{
Name = "Unbekannter Sensor";
Location = "Unbekannt";
}
// Parameterisierter Konstruktor
public Sensor(string name, string location)
{
Name = name;
Location = location;
}
public void DisplayInfo()
{
Console.WriteLine($"Sensor: {Name}, Standort: {Location}");
}
}
// Standardkonstruktor
Sensor defaultSensor = new Sensor();
defaultSensor.DisplayInfo();
// Parameterisierter Konstruktor
Sensor tempSensor = new Sensor("Temperatursensor", "Waldgebiet");
tempSensor.DisplayInfo();
Best Practices¶
Vermeide komplexe Logik in Konstruktoren: Konstruktoren sollten sich auf die Initialisierung beschränken.
Nutze Initialisierungslisten: Konstruktorinitialisierer (z. B.
: this(...)oder: base(...)) verbessern die Lesbarkeit und Wiederverwendbarkeit.Vermeide Abhängigkeiten: Konstruktoren sollten minimalistisch und unabhängig sein, um Testbarkeit zu fördern.
Vertiefung¶
1. this-Schlüsselwort¶
Das this-Schlüsselwort verweist auf die aktuelle Instanz der Klasse. Es wird oft verwendet, um Namenskonflikte zwischen Feldern und Parametern im Konstruktor zu lösen.
Beispiel:¶
Angenommen, wir modellieren Sensoren, die Umweltdaten erfassen.
using System;
class Sensor { public string Name { get; private set; } public string Location { get; private set; }
// Konstruktor mit this-Schlüsselwort
public Sensor(string name, string location)
{
this.Name = name; // this bezieht sich auf das aktuelle Objektfeld Name
this.Location = location;
}
public void DisplayInfo()
{
Console.WriteLine($"Sensor: {Name} befindet sich in {Location}.");
}}
class Program { static void Main() { Sensor tempSensor = new Sensor("Temperatursensor", "Waldgebiet"); tempSensor.DisplayInfo(); } }
Hier wird this.Name und this.Location verwendet, um auf die Felder der Klasse zuzugreifen.
2. new-Schlüsselwort¶
Das new-Schlüsselwort wird verwendet, um eine neue Instanz eines Objekts zu erstellen. Außerdem kann es verwendet werden, um eine Methode oder ein Mitglied in einer abgeleiteten Klasse zu verbergen.
Beispiel:¶
Hier erstellen wir eine Klasse für einen Feinstaubsensor, die von der Basisklasse Sensor erbt.
using System;
class FeinstaubSensor : Sensor { public int Partikelkonzentration { get; private set; }
public FeinstaubSensor(string name, string location, int partikelkonzentration)
: base(name, location) // base ruft den Konstruktor der Basisklasse auf
{
this.Partikelkonzentration = partikelkonzentration;
}
public new void DisplayInfo() // new verbirgt die Methode der Basisklasse
{
base.DisplayInfo();
Console.WriteLine($"Partikelkonzentration: {Partikelkonzentration} µg/m³.");
}}
class Program { static void Main() { FeinstaubSensor dustSensor = new FeinstaubSensor("Feinstaubsensor", "Innenstadt", 35); dustSensor.DisplayInfo(); } }
Hier wird new verwendet, um die DisplayInfo-Methode der Basisklasse Sensor zu verbergen und eine spezifische Ausgabe für den FeinstaubSensor bereitzustellen.
3. base-Schlüsselwort¶
Das base-Schlüsselwort wird verwendet, um auf Mitglieder der Basisklasse zuzugreifen, einschließlich des Konstruktors der Basisklasse. Es wird häufig in abgeleiteten Klassen eingesetzt, um die Initialisierung der Basisklasse zu übernehmen.
Beispiel:¶
Ein weiterer Sensor, der Temperatur- und Feinstaubdaten gemeinsam erfasst.
using System;
class TemperaturFeinstaubSensor : FeinstaubSensor { public double Temperatur { get; private set; }
public TemperaturFeinstaubSensor(string name, string location, int partikelkonzentration, double temperatur)
: base(name, location, partikelkonzentration)
{
this.Temperatur = temperatur;
}
public override void DisplayInfo()
{
base.DisplayInfo(); // Ruft die DisplayInfo der Basisklasse FeinstaubSensor auf
Console.WriteLine($"Temperatur: {Temperatur}°C.");
}}
class Program { static void Main() { TemperaturFeinstaubSensor combinedSensor = new TemperaturFeinstaubSensor("Multi-Sensor", "Industriegebiet", 40, 22.5); combinedSensor.DisplayInfo(); } }
In diesem Beispiel wird base.DisplayInfo() verwendet, um die Ausgabe der Basisklasse FeinstaubSensor zu ergänzen.