OOP, Klassendiagramm

Objektorientierte Programmierung

OOP: Blick in die Geschichte …

Quelle: Thomas Woodtli, Wikimedia Commons, CC-BY-SA-2.0

  • 1960er: Ole-Johan Dahl und Kristen Nygaard am Norwegian Computing Center in Oslo simulieren Schiffsbewegungen im Osloer Hafen
  • Damalige prozedurale Programiersprachen (Algol, Fortran): verfilzter Code; -> Simula (OOP)
  • 1970er: Alan Kay wollte interaktives Computersystem bauen -> Simula -> Smalltalk (OOP)

Geschichte: Schiffe

Santa Maria, Schiff von Kolumbus 1492, Wikimedia Commons, vermutlich von Edward H. Hart, public domain

Mayflower, 1620, Wikimedia Commons, CC0 1.0 public domain

Geschichte: Schiffe

RMS Titanic 1912, Francis Godolphin Osbourne Stuart gest. 1923, Wikimedia Commons, public domain

Ziele

Grundpfeiler der objektorientierten Programmierung (OOP) verstehen und anwenden können:

  • Kapselung, Vererbung, Polymorphie, Interfaces
  • UML-Notation
  • Zugriffsmodifikatoren
  • Einführung in Pseudocode mit OOP-Konzepten

OOP: Was ist eine Klasse?

  • Eine Klasse ist ein Bauplan für die Erstellung von Objekten.
  • Klasse definiert Attribute und Methoden eines Objekts
    • Attribute: Eigenschaften, Variablen; repräsentieren den Zustand
    • Methoden: Funktionen; repräsentieren das Verhalten
  • Klasse ermöglicht Erstellung mehrerer Objekte mit ähnlichen Merkmalen und Verhaltensweisen

OOP: Was ist ein Objekt?

  • eine konkrete Instanz einer Klasse
  • besitzt die Attribute und Methoden, die in seiner Klasse definiert sind
  • Jedes Objekt hat seinen eigenen Satz von Werten für die Attribute.
  • Attribute -> Zustand des Objekts
  • Methoden -> Verhalten des Objekts, das auf diesem Zustand operiert
  • Ein Objekt ist eine Verkapselung von Daten (Zustand) und den dazu gehörenden Operationen (Verhalten).

OOP: Grundideen

  • Kapselung (Encapsulation)
  • Vererbung
  • Polymorphie
  • Interfaces

OOP: Kapselung (Encapsulation)

  • interne Daten eines Objekts werden vor direktem Zugriff geschützt
  • Zugriff erfolgt über definierte Methoden (Getter/Setter)
  • Zugriffsmodifikatoren steuern die Sichtbarkeit:
    public, private, protected, package
  • schafft Datenintegrität: Manipulation nur auf sichere, kontrollierte Weise
  • verbessert Wartbarkeit: Änderungen an der internen Implementierung der Klasse beeinflussen nicht die Programmteile, die die Klasse verwenden

OOP vs. prozedurale Programmierung

OOP

  • Daten und Funktionen werden zu Objekten zusammengefasst
  • Objekt kann Attribute (Daten) und Methoden (Funktionen) enthalten

Prozedurale Programmierung

  • Programm führt eine Reihe von Aufgaben aus: Prozeduren
  • Prozeduren operieren auf Daten
  • Daten sind getrennt von Prozeduren; Prozeduren bearbeiten die Daten

Prozedur vs. Funktion

Funktion

  • Codeblock, der eine spezifische Aufgabe ausführt
  • liefert in der Regel einen Wert zurück

Prozedur

  • Codeblock, der eine spezifische Aufgabe ausführt
  • liefert in der Regel keinen Wert zurück
  • Prozedur führt Aufgabe aus und kehrt dann zur aufrufenden Stelle im Code zurück

OOP: Kapselung - Zugriffsmodifikatoren

Zugriffsmodifikatoren bestimmen, wo auf Klassen, Methoden und Variablen zugegriffen werden kann.

Zugriffs-
modifikator		 Symbol
public
 		 +
private
 		 -
protected
 		 #
package ~
Bedeutung
 
Zugriff überall erlaubt, sowohl innerhalb als auch außerhalb der Klasse
Zugriff nur innerhalb der Klasse erlaubt, in der sie definiert sind
Zugriff nur innerhalb der Klasse, des Pakets und von abgeleiteten Klassen erlaubt
Zugriff ist innerhalb der Klasse und in allen Klassen desselben Pakets erlaubt

OOP: Kapselung - Zugriffsmodifikatoren

IHK-Standard in Prüfungen

Zugriffs-
modifikator		 Symbol Bedeutung Verwendung
private - Zugriff nur innerhalb der Klasse erlaubt, in der sie definiert sind Attribute
public + Zugriff überall erlaubt, sowohl innerhalb als auch außerhalb der Klasse Operation / Methode

UML-Beispiel

+------------------------------+
|          Konto               |
|------------------------------|
| - kontostand: double         |
|------------------------------|
| + getKontostand(): double    |
| + einzahlen(betrag: double)  |
| + abheben(betrag: double)    |
+------------------------------+
  • Niemand darf direkt auf den Kontostand (private) zugreifen und ihn verändern
  • Veränderung nur über die public-Methoden einzahlen() und abheben(), die eine Validierung durchführen

OOP: Vererbung

  • Schlüsselprinzip: ermöglicht, neue Klassen aus bereits existierenden Klassen zu erzeugen
  • eine Klasse (Kindklasse) kann Attribute und Methoden einer anderen Klasse (Elternklasse) übernehmen
  • fördert Wiederverwendbarkeit und Hierarchiebildung; vermeidet Redundanz
  • Kindklasse heißt auch abgeleitete Klasse oder Unterklasse
  • Elternklasse heißt auch Oberklasse, Basisklasse oder Superklasse

Vererbung: Python-Beispiel

# Elternklasse = Basisklasse = Oberklasse

class Haustier:
    def __init__(self, name):
        self.name = name
        self._energie = 100  # Unterstrich: 
        # Konvention für geschütztes Attribut

    def spielen(self):
      ...
# Kindklasse = abgeleitete Klasse = Unterklasse

class Hund(Haustier):
    pass    # erbt alles unverändert
# Anwendung

bello = Hund("Bello")
bello.spielen()   # nutzt die geerbte Methode

Vererbung: UML

+----------------------------+
|       Fahrzeug             |
|----------------------------|
| # marke: String            |
| # baujahr: int             |
|----------------------------|
| + beschreibung(): String   |
+----------------------------+
         ^                ^
         |                |
    erbt von         erbt von
         |                |
+------------------+  +--------------------+
|     PKW          |  |       LKW          |
|------------------|  |--------------------|
| - anzahlSitze    |  | - ladekapazitaet   |
|------------------|  |--------------------|
| + beschreibung() |  | + beschreibung()   |
+------------------+  +--------------------+
  • PKW und LKW erben von Fahrzeug
  • Beide übernehmen die protected-Attribute marke und baujahr
  • Beide erhalten jeweils ein eigenes privates Attribut (anzahlSitze bzw. ladekapazität)

Vererbung: Begriffe

  • Oberklasse (Superklasse) – Klasse, von der geerbt wird

  • Unterklasse (Subklasse) – Klasse, die erbt

  • super – Zugriff auf Methoden/Konstruktor der Oberklasse

  • Ist-ein-Beziehung – PKW ist ein Fahrzeug (Vererbung)

  • Hat-ein-Beziehung – Fahrzeug hat einen Motor (Komposition, keine Vererbung; wird später vertieft)

  • Durch Vererbung müssen gemeinsame Attribute (marke, baujahr) und Methoden nur einmal in der Elternklasse definiert werden.

  • Kindklassen fügen spezifische Attribute hinzu und können Methoden überschreiben.

OOP: Polymorphie (“Vielgestaltigkeit”)

Definition: Polymorphie (Vielgestaltigkeit) bedeutet, dass Objekte verschiedener Klassen über eine gemeinsame Schnittstelle angesprochen werden können und sich unterschiedlich verhalten.

  • Wie wird das unterschiedliche Verhalten der Objekte ausgelöst?
    durch den Datentyp oder die Klasse
  • Klassen teilen Methoden, aber die Implementierungen der Methoden können variieren
  • Wann wird entschieden, welche Implementierung ausgeführt wird? Zur Laufzeit! Tatsächlicher Objekttyp entscheidet
  • verbessert Flexibilität
  • erhöht Wiederverwendbarkeit von Code
  • erleichtert standardisierte Schnittstellen

Polymorphie: Zwei Arten


Art Beschreibung Beispiel
Überladen (Overloading) Gleicher Methodenname, verschiedene Parameter
statische Polymorphie		 berechne(a) und berechne(a, b)
Überschreiben (Overriding) Kindklasse überschreibt Methode der Elternklasse
dynamische Polymorphie		 Hund.sprechen() statt Tier.sprechen()

OOP: Schnittstellen (Interfaces)

  • definieren, welche Methoden eine Klasse implementieren muss
  • lassen offen, wie
  • ermöglichen lose Kopplung und Austauschbarkeit von Komponenten

Schnittstellen: UML-Notation

+-------------------+
| <<interface>>     |
| Druckbar          |
|-------------------|
|                   |
|-------------------|
| + drucke(): void  |
+-------------------+
        ^
        |
  implementiert
        |       
+-------------------+
| Rechnung          |
|-------------------|
| + drucke(): void  |
+-------------------+

Klassendiagramm

Klassendiagramm: Beispiel

Vererbung & Polymorphie: UML

+----------------------------+
|         Haustier           |
|----------------------------|
| - name : String            |
| - energie : int            |
|----------------------------|
| + spielen() : void         |
| + ausruhen() : void        |
+----------------------------+
         ^            ^
         |            |
         |            |
+----------------+  +----------------+
|      Hund      |  |     Katze      |
|----------------|  |----------------|
| + spielen()    |  | + spielen()    |
| + ausruhen()   |  | + ausruhen()   |
+----------------+  +----------------+

Klassendiagramm: Beziehungen

  • Vererbung: Pfeil zeigt auf Oberklasse
  • Assoziation: Beziehung zwischen Klassen; kann gerichtet oder ungerichtet sein
    • Beispiele ungerichtet: Lehrer - Schüler; Produkt - Kategorie
    • Beispiele gerichtet: Email -> Empfänger; Rechnung -> Kunde
  • Aggregation und Komposition: Beziehung Teil - Ganzes
    • Aggregation: Teil kann ohne das Ganze existieren, z. B. Schüler (Teil) - Unterricht
    • Komposition: Teile existenziell vom Ganzen abhängig, z. B. Raum - Haus

Klassendiagramm: Kardinalitäten

Definition Kardinalitäten = Multiplizitäten: Wie viele Instanzen einer Klasse können mit einer Instanz einer anderen Klasse in Beziehung stehen?

Schreibweise Bedeutung Erklärung
0..* oder * Null bis beliebig viele Die Beziehung ist optional. Es können keine oder unendlich viele Objekte verknüpft sein.
1..* Eins bis beliebig viele Mindestens ein Objekt muss existieren (Pflichtbeziehung).
0..1 Null oder eins Optional, aber maximal ein Objekt (z. B. ein Profil für einen Nutzer).
1 oder 1..1 Genau eins Exakt ein Objekt muss verknüpft sein
n..m, z. B. 2..5 Bestimmte Spanne Mindestens n und maximal m Objekte

Komposition, Aggregation

Quelle: Kakashi-Madara, Wikimedia Commons

  • Raum kann nicht ohne Gebäude existieren: starke Beziehung, Komposition
  • Student kann ohne Vorlesung existieren: lose Beziehung, Aggregation
  • Kardinalitäten beachten

Komposition vs. Aggregation

Aggregation

  • lose Beziehung zwischen zwei Klassen
  • eine Klasse (das Ganze) enthält Sammlung oder Gruppe von Objekten einer anderen Klasse (die Teile)
  • Beziehung zwischen dem Ganzen und den Teilen ist optional: das Ganze kann ohne die Teile existieren

Komposition

  • starke Beziehung zwischen zwei Klassen
  • eine Klasse (das Ganze) besteht aus einer anderen Klasse (dem Teil)
  • Teile können nur als Teil des Ganzen existieren und haben keine eigenständige Existenz
  • Wenn das Ganze zerstört wird, werden auch die Teile zerstört

Klassendiagramm: Erläuterung

Das Klassendiagramm zeigt Klassen, ihre Attribute und Methoden sowie Beziehungen zwischen Klassen.

  • Klassen und Objekte: Welche Klassen gibt es und welche Objekte repräsentieren sie?
  • Attribute und Operationen: Welche Eigenschaften und Verhaltensweisen haben die Klassen?
  • Beziehungen: Wie sind die Klassen miteinander verknüpft (z. B. durch Assoziationen und Vererbungen)?
  • Sichtbarkeit: Welche Attribute und Operationen sind öffentlich, privat oder geschützt?
  • Kardinalität: Wie viele Instanzen einer Klasse können mit einer anderen in Beziehung stehen?

Viel Erfolg!

Zurück zur Übersicht LF8