Jeder kann coden / Zahlensysteme / Prozedurale Programmierung
Objektorientierte Programmierung¶
Wir können die Prinzipien der objektorientierten Programmierung anhand eines Ökosystems veranschaulichen. In einem Ökosystem gibt es viele verschiedene Elemente wie Pflanzen, Tiere und Gewässer. Diese Elemente interagieren miteinander, und jedes hat bestimmte Eigenschaften und Verhaltensweisen. Lass uns die OOP-Konzepte hier anwenden:
1. Klassen und Objekte¶
Analogie: Stell dir vor, wir möchten verschiedene Lebewesen in einem Ökosystem darstellen. Die Klasse Lebewesen ist wie eine Vorlage für alle Lebewesen und beschreibt allgemeine Eigenschaften und Verhaltensweisen. Daraus können wir dann Objekte wie Bäume oder Tiere erstellen.
Diagramm:
classDiagram
class Lebewesen {
+name : String
+alter : int
+wachsen() : void
}
class Pflanze {
+leben() : void
}
class Tier {
+leben() : void
}
Lebewesen <|-- Pflanze
Lebewesen <|-- Tier
class Eiche {
+Photosynthese() : void
}
class Reh {
+atmen() : void
}
Pflanze <|-- Eiche
Tier <|-- Reh
Codebeispiel:
class Lebewesen:
def __init__(self, name, alter):
self.name = name
self.alter = alter
def wachsen(self):
print(f"{self.name} wächst.")
Bäume und Tiere sind beides Lebewesen, also können wir Instanzen der Klasse Lebewesen erstellen:
baum = Lebewesen("Eiche", 50)
tier = Lebewesen("Reh", 5)
baum.wachsen()
tier.wachsen()
# Ausgabe:
# Eiche wächst.
# Reh wächst.
Eiche wächst. Reh wächst.
2. Kapselung¶
Analogie: Angenommen, ein Baum hat seine eigenen Prozesse wie Photosynthese. Das ist ein interner Prozess, der nicht direkt sichtbar ist. Andere Lebewesen müssen nicht wissen, wie Photosynthese genau funktioniert – sie sehen nur das Ergebnis, dass der Baum wächst.
Diagramm:
classDiagram
class Baum {
+String name
+int alter
-bool __photosynthese_aktiv
+wachsen()
-__photosynthese_starten()
}
Codebeispiel:
class Baum:
def __init__(self, name, alter):
self.name = name
self.alter = alter
self.__photosynthese_aktiv = False # Diese Information ist privat
def wachsen(self):
self.__photosynthese_starten()
print(f"{self.name} wächst.")
def __photosynthese_starten(self):
self.__photosynthese_aktiv = True
print("Photosynthese gestartet.")
Hier ist __photosynthese_aktiv ein privates Attribut, und __photosynthese_starten ist eine Methode, die nur intern verwendet wird. Der Baum führt die Photosynthese nur für sich selbst aus, ohne dass andere Lebewesen eingreifen können.
eiche = Baum("Eiche", 50)
eiche.wachsen()
# Ausgabe:
# Photosynthese gestartet.
# Eiche wächst.
3. Vererbung¶
Analogie: Innerhalb eines Ökosystems gibt es verschiedene Arten von Lebewesen. Zum Beispiel könnten wir eine allgemeine Klasse Tier haben, und davon abgeleitet spezielle Klassen wie Vogel oder Säugetier. Diese Spezies haben gemeinsame Eigenschaften (wie "Atmung"), aber auch individuelle Unterschiede.
Diagramm:
classDiagram
class Lebewesen {
-name: String
-alter: int
+wachsen(): void
}
class Tier {
+atmen(): void
}
class Vogel {
+fliegen(): void
}
class Säugetier {
+laufen(): void
}
Lebewesen <|-- Tier
Tier <|-- Vogel
Tier <|-- Säugetier
Codebeispiel:
class Tier(Lebewesen):
def __init__(self, name, alter, art):
super().__init__(name, alter)
self.art = art
def atmen(self):
print(f"{self.name} atmet.")
class Vogel(Tier):
def __init__(self, name, alter):
super().__init__(name, alter, "Vogel")
def fliegen(self):
print(f"{self.name} fliegt.")
Vogel erbt die atmen-Methode von Tier, aber es hat auch eine eigene Methode, fliegen.
spatz = Vogel("Spatz", 2)
spatz.atmen() # Ausgabe: Spatz atmet.
spatz.fliegen() # Ausgabe: Spatz fliegt.
4. Polymorphismus¶
Analogie: In einem Ökosystem sind Pflanzen, Tiere und Pilze unterschiedliche Lebewesen. Alle "leben" auf ihre Weise, aber Pflanzen betreiben Photosynthese, Tiere atmen, und Pilze zersetzen organisches Material. Polymorphismus bedeutet, dass sie alle eine Methode leben haben können, die jeweils unterschiedlich funktioniert.
Diagramm:
classDiagram
class Lebewesen {
+name: str
+alter: int
+leben()
}
class Pflanze {
+leben()
"Photosyntehese"
}
class Tier {
+leben()
"Atmung"
}
class Pilz {
+leben()
"Zersetzung"
}
Lebewesen <|-- Pflanze
Lebewesen <|-- Tier
Lebewesen <|-- Pilz
Codebeispiel:
class Pflanze(Lebewesen):
def leben(self):
print(f"{self.name} wächst durch Photosynthese.")
class Tier(Lebewesen):
def leben(self):
print(f"{self.name} atmet.")
class Pilz(Lebewesen):
def leben(self):
print(f"{self.name} zersetzt organisches Material.")
Jetzt können wir jedes Lebewesen-Objekt durch leben beschreiben, ohne genau zu wissen, wie es funktioniert. So funktioniert Polymorphismus – wir rufen die Methode leben auf, und jedes Objekt führt es auf seine Weise aus.
pflanze = Pflanze("Eiche", 50)
tier = Tier("Reh", 5)
pilz = Pilz("Champignon", 1)
lebewesen = [pflanze, tier, pilz]
for leb in lebewesen:
leb.leben()
# Ausgabe:
# Eiche wächst durch Photosynthese.
# Reh atmet.
# Champignon zersetzt organisches Material.
Zusammenfassung mit dem Ökosystem-Beispiel:¶
- Klassen und Objekte: Eine Klasse ist wie ein Entwurf für Lebewesen, und Objekte sind konkrete Pflanzen, Tiere, usw.
- Kapselung: Interne Prozesse wie Photosynthese sind privat und nur für das jeweilige Lebewesen sichtbar.
- Vererbung: Lebewesen wie Tiere und Pflanzen haben gemeinsame Eigenschaften, aber auch eigene Besonderheiten.
- Polymorphismus: Verschiedene Lebewesen "leben" auf ihre Weise, und der gleiche Aufruf (
leben) kann unterschiedliche Ergebnisse haben.
Dieses Modell hilft, verschiedene Lebewesen in einem Ökosystem strukturiert und flexibel darzustellen und ihr Verhalten klar zu definieren, was für die Modellierung und Simulation in der Umweltinformatik nützlich ist.