Jeder kann coden / Programmieren & TicTacToe / Objektorientierte Programmierung
Grundlagen der objektorientierten Programmierung (OOP) in C#¶
|
|
|
Link zur Microsoft Dokumentation Link zum roten Faden auf Miro Link zu Tutorial auf w3schools |
Die objektorientierte Programmierung (OOP) in C# ermöglicht es, komplexe Systeme durch das Erstellen und Verwalten von Objekten zu modellieren, was auch in der Umweltinformatik hilfreich ist, um reale Entitäten wie Flüsse, Seen und andere Umweltkomponenten zu repräsentieren. C# verwendet dabei die Prinzipien Klassen und Objekte, Vererbung, Polymorphismus, Kapselung und Abstraktion. Im Folgenden wird jedes Prinzip ausführlich erklärt, und wir betrachten auch die Verwendung des Operators new, der eine Schlüsselrolle bei der Instanziierung von Objekten spielt.
Klassen und Objekte¶
In der OOP werden Klassen als Baupläne für Objekte verwendet. Eine Klasse definiert Eigenschaften (Daten) und Methoden (Verhalten) von Objekten. Objekte sind Instanzen dieser Klassen, die mit konkreten Daten versehen sind.
💡 Dies ist eines der grundlegenden Konzepte der objektorientierten Programmierung.
Beispiel:¶
Angenommen, wir möchten einen Fluss in der Umweltinformatik modellieren. Dafür erstellen wir eine Fluss-Klasse mit Eigenschaften wie Name, Laenge und Durchfluss.
public class Fluss
{
protected string Name { get; set; } // Name des Flusses
protected double Laenge { get; set; } // Länge in Kilometern
protected double Durchfluss { get; set; } // Durchfluss in Kubikmeter pro Sekunde
public Fluss(string Name, double Laenge, double Durchfluss)
{
this.Name = Name;
this.Laenge = Laenge;
this.Durchfluss = Durchfluss;
}
public void FlussInformation()
{
Console.WriteLine($"{Name} hat eine Länge von {Laenge / 1000} km und einen Durchfluss von {Durchfluss} m³/s.");
}
public Fluss durchFlussÜberflutet( double zusätzlicherDurchfluss) {
Durchfluss += zusätzlicherDurchfluss;
return this;
}
}
Verwendung von new:¶
Der Operator new wird verwendet, um eine Instanz der Klasse zu erstellen, also ein Objekt. Der Operator reserviert Speicherplatz und initialisiert das Objekt.
Fluss fluss1 = new Fluss("Rhein", 1233000, 2900);
fluss1.FlussInformation();
fluss1.durchFlussÜberflutet(500).FlussInformation();
fluss1.FlussInformation();
Rhein hat eine Länge von 1233 km und einen Durchfluss von 2900 m³/s. Rhein hat eine Länge von 1233 km und einen Durchfluss von 3400 m³/s. Rhein hat eine Länge von 1233 km und einen Durchfluss von 3400 m³/s.
Hier erzeugt new Fluss(...) ein neues Fluss-Objekt und weist es der Variablen rhein zu. Dieses rhein-Objekt repräsentiert einen spezifischen Fluss und kann über die Methoden und Eigenschaften der Klasse angesprochen werden.
Objekte anlegen und aufräumen¶
≝ Definitionen¶
Klasse¶
Eine Klasse ist ein Bauplan oder eine Vorlage für Objekte. Sie definiert die Eigenschaften (Felder) und das Verhalten (Methoden), die ein Objekt haben soll.
Beispiel in C#:
public class Auto
{
public string Marke { get; set; }
public void Fahren()
{
Console.WriteLine("Das Auto fährt.");
}
}
Instanz¶
Eine Instanz ist ein konkretes Objekt, das auf Basis einer Klasse erstellt wurde. Sie ist eine "reale Umsetzung" der Klasse im Speicher.
Beispiel in C#:
Auto meinAuto = new Auto();
Instanziierung¶
Der Prozess des Erstellens einer Instanz aus einer Klasse. Dies geschieht mit dem new-Schlüsselwort in C#.
Beispiel in C#:
Auto meinAuto = new Auto(); // Instanziierung
Objekt¶
Ein Objekt ist eine konkrete Ausprägung einer Klasse. Es besitzt spezifische Werte für seine Eigenschaften und kann Methoden ausführen. Ein Objekt wird durch Instanziierung erzeugt.
Beispiel in C#:
Auto meinAuto = new Auto();
meinAuto.Marke = "Tesla"; // Objekt mit spezifischen Werten
meinAuto.Fahren();
Zusammengefasst:
- Eine Klasse ist die Vorlage.
- Eine Instanz ist eine konkrete Umsetzung der Klasse.
- Die Instanziierung ist der Vorgang, eine Instanz zu erzeugen.
- Ein Objekt ist das Ergebnis der Instanziierung, also die reale Umsetzung der Klasse.
static¶
Das Schlüsselwort static in C# ist ein Modifier, der sich auf Klassen, Methoden, Felder oder Eigenschaften anwenden lässt. Es bedeutet, dass ein Mitglied oder eine Klasse zur Klasse selbst gehört und nicht zu einer Instanz der Klasse. Du hast bereits gelernt, dass du mit new Objekte erstellst. Objekte gehören zu einer Instanz der Klasse. static hingegen gehört direkt zur Klasse und benötigt keine Instanz.
Unterschied zwischen static und Instanzbasiert¶
- Instanzbasiert: Mit
newerzeugst du eine Instanz, und die Instanz hat ihre eigenen Daten. - Static: Etwas, das
staticist, gehört allen Instanzen gemeinsam oder nur der Klasse selbst.
Wann verwendet man static?¶
- Wenn ein Wert oder eine Funktion unabhängig von einer bestimmten Instanz sein soll.
- Wenn du globale Funktionen oder Konstanten brauchst, die für das gesamte Programm gelten.
Beispiel 1: static Feld¶
class UmweltDaten
{
public static int MaxTemperatur = 50; // Gilt für alle Instanzen gleichermaßen
public int AktuelleTemperatur; // Instanzspezifisch
public void SetzeTemperatur(int temperatur)
{
if (temperatur > MaxTemperatur)
{
Console.WriteLine("Temperatur überschreitet das Maximum!");
AktuelleTemperatur = MaxTemperatur;
}
else
{
AktuelleTemperatur = temperatur;
}
}
}
UmweltDaten.MaxTemperatur = 45; // Zugriff direkt über die Klasse
UmweltDaten sensor1 = new UmweltDaten();
UmweltDaten sensor2 = new UmweltDaten();
sensor1.SetzeTemperatur(40);
sensor2.SetzeTemperatur(50); // Gibt eine Warnung aus, da MaxTemperatur = 45
Console.WriteLine($"MaxTemperatur: {UmweltDaten.MaxTemperatur}");
Console.WriteLine($"Temperatur sensor1: {sensor1.AktuelleTemperatur}");
Console.WriteLine($"Temperatur sensor2: {sensor2.AktuelleTemperatur}");
Console.WriteLine($"Temperatur sensor2: {sensor1.AktuelleTemperatur}");
Temperatur überschreitet das Maximum! MaxTemperatur: 45 Temperatur sensor1: 40 Temperatur sensor2: 45 Temperatur sensor2: 40
class MatheHelfer
{
public static int Addiere(int a, int b)
{
return a + b;
}
}
int ergebnis = MatheHelfer.Addiere(5, 10); // Direkt über die Klasse aufrufen
Console.WriteLine($"Ergebnis: {ergebnis}");
Ergebnis: 15
Erklärung:¶
- Du kannst
Addieredirekt überMatheHelferverwenden, ohne ein Objekt der Klasse zu erstellen.
Einschränkungen von static¶
staticMethoden und Felder können nicht auf Instanzmitglieder zugreifen, da sie nicht wissen, welche Instanz sie verwenden sollen.- Sie gehören immer zur Klasse und sind daher für alle gleich.
static und nicht-static¶
Vererbung¶
Vererbung ermöglicht es, von einer Basisklasse (Elternklasse) zu erben und eine abgeleitete Klasse (Kindklasse) zu erstellen, die zusätzliche oder spezialisierte Eigenschaften und Methoden hat. Das spart Wiederholungen im Code und hilft dabei, gemeinsame Eigenschaften in der Basisklasse zu definieren.
💡 Dies ist eines der grundlegenden Konzepte der objektorientierten Programmierung.
Beispiel:¶
Erstellen einer abgeleiteten Klasse VerschmutzterFluss, die von der Basisklasse Fluss erbt und eine zusätzliche Eigenschaft zur Schadstoffkonzentration hat.
public class VerschmutzterFluss : Fluss
{
public double Schadstoffkonzentration { get; set; } // Schadstoffkonzentration in mg/L
public VerschmutzterFluss(string name, double laenge, double durchfluss, double schadstoffkonzentration)
: base(name, laenge, durchfluss)
{
Schadstoffkonzentration = schadstoffkonzentration;
}
public void VerschmutzungsInfo()
{
Console.WriteLine($"{Name} hat eine Schadstoffkonzentration von {Schadstoffkonzentration} mg/L.");
}
}
Verwendung von new:¶
Auch hier wird new verwendet, um eine Instanz der abgeleiteten Klasse VerschmutzterFluss zu erstellen.
VerschmutzterFluss main = new VerschmutzterFluss("Main", 524, 200, 3.5);
main.FlussInformation();
main.VerschmutzungsInfo();
Main hat eine Länge von 0,524 km und einen Durchfluss von 200 m³/s. Main hat eine Schadstoffkonzentration von 3,5 mg/L.
Kapselung¶
Kapselung bedeutet, dass Daten und Methoden einer Klasse geschützt werden und nur über bestimmte Schnittstellen darauf zugegriffen werden kann. Das hilft, die Datenintegrität zu bewahren.
Beispiel:¶
Wir verhindern, dass die Schadstoffkonzentration eines VerschmutzterFluss-Objekts negativ sein kann.
public class VerschmutzterFluss : Fluss
{
private double schadstoffkonzentration;
public double Schadstoffkonzentration
{
get { return schadstoffkonzentration; }
set
{
if (value >= 0)
schadstoffkonzentration = value;
else
throw new ArgumentException("Schadstoffkonzentration muss positiv sein.");
}
}
public VerschmutzterFluss(string name, double laenge, double durchfluss, double schadstoffkonzentration)
: base(name, laenge, durchfluss)
{
Schadstoffkonzentration = schadstoffkonzentration;
}
}
Die Schadstoffkonzentration-Eigenschaft wird über eine Zugriffsmethode geschützt, die sicherstellt, dass keine negativen Werte gesetzt werden können.
Polymorphismus¶
Polymorphismus (auch Polymorphie genannt) ermöglicht es, Objekte der abgeleiteten Klasse auf die gleiche Weise wie Objekte der Basisklasse zu behandeln. Es vereinfacht das Arbeiten mit mehreren Objekten, die sich zwar in Details unterscheiden, aber eine gemeinsame Schnittstelle oder Basisklasse haben.
💡 Dies ist eines der grundlegenden Konzepte der objektorientierten Programmierung.
Beispiel:¶
Eine Methode, die Informationen über verschiedene Fluss-Objekte (verschmutzt oder nicht) anzeigt, ohne die genaue Typzugehörigkeit zu kennen.
public void ZeigeFlussInfo(Fluss fluss)
{
fluss.FlussInformation();
if (fluss is VerschmutzterFluss verschmutzterFluss)
{
verschmutzterFluss.VerschmutzungsInfo();
}
}
(6,28): error CS1061: "VerschmutzterFluss" enthält keine Definition für "VerschmutzungsInfo", und es konnte keine zugängliche VerschmutzungsInfo-Erweiterungsmethode gefunden werden, die ein erstes Argument vom Typ "VerschmutzterFluss" akzeptiert (möglicherweise fehlt eine using-Direktive oder ein Assemblyverweis).
Verwendung:¶
Durch Polymorphismus können wir verschiedene Objekte, die die gleiche Basisklasse teilen, in derselben Methode verwenden.
Fluss donau = new Fluss("Donau", 2850, 6500);
VerschmutzterFluss elbe = new VerschmutzterFluss("Elbe", 1094, 700, 2.8);
ZeigeFlussInfo(donau);
ZeigeFlussInfo(elbe);
(4,1): error CS0103: Der Name "ZeigeFlussInfo" ist im aktuellen Kontext nicht vorhanden. (5,1): error CS0103: Der Name "ZeigeFlussInfo" ist im aktuellen Kontext nicht vorhanden.
Abstraktion¶
Abstraktion hilft dabei, nur die wichtigen Eigenschaften und Methoden einer Klasse freizugeben und unnötige Details auszublenden. Dadurch bleibt der Code übersichtlich und verständlich.
💡 Dies ist eines der grundlegenden Konzepte der objektorientierten Programmierung.
Beispiel:¶
Wir erstellen eine abstrakte Basisklasse Gewaesser, die die gemeinsamen Eigenschaften und Methoden aller Gewässer enthält.
public abstract class Gewaesser
{
public string Name { get; set; }
public abstract void ZeigeGewaesserInfo();
}
public class See : Gewaesser
{
public double Flaeche { get; set; } // Fläche in Quadratkilometern
public See(string name, double flaeche)
{
Name = name;
Flaeche = flaeche;
}
public override void ZeigeGewaesserInfo()
{
Console.WriteLine($"Der See {Name} hat eine Fläche von {Flaeche} km².");
}
}
public class Fluss : Gewaesser
{
public double Laenge { get; set; }
public Fluss(string name, double laenge)
{
Name = name;
Laenge = laenge;
}
public override void ZeigeGewaesserInfo()
{
Console.WriteLine($"Der Fluss {Name} hat eine Länge von {Laenge} km.");
}
}
Verwendung:¶
Wir erstellen eine Liste von Gewaesser-Objekten, ohne uns um die Details jedes spezifischen Gewässers zu kümmern.
List<Gewaesser> gewaesserListe = new List<Gewaesser>
{
new See("Bodensee", 536),
new Fluss("Rhein", 1233)
};
foreach (var gewaesser in gewaesserListe)
{
gewaesser.ZeigeGewaesserInfo();
}
Der See Bodensee hat eine Fläche von 536 km². Der Fluss Rhein hat eine Länge von 1233 km.
Polymorphie & Abstaktion zusammen am Beispiel von geometrischen Formen¶
Cheatsheet Klassen in C#¶
Zusammenfassung¶
In der OOP ermöglicht der new-Operator das Erstellen neuer Objekte und damit das Modellieren von Umweltkomponenten in der Softwareentwicklung. Klassen und Objekte, Vererbung, Polymorphismus, Kapselung und Abstraktion helfen, komplexe Systeme realistisch abzubilden und strukturierte, wartbare Software zu entwickeln.