Vererbung in der OOP

Klassenbeziehungen: Vererbung von Klassen in der UML

https://bildung.social/@oerinformatik/

https://oer-informatik.de/uml-klassendiagramm-vererbung

tl/dr; (ca. 15 min Lesezeit): Zentrales Element der Code-Wiederverwendung in der objektorientierten Programmierung (OOP) ist die Vererbung. Am Beispiel eines Investments werden hier das OOP-Prinzip Vererbung und die darauf aufbauenden Konzepte (z.B. Überschreiben) erklärt. (Zuletzt geändert am 22.11.2024)

Dieser Text ist ein Teil der Infotext-Serie zu UML-Klassendiagrammen:

• Grundlagen UML-Klassendiagramm

• Sichtbarkeitsmodifikatoren

• Objektbeziehungen (Assoziation/Aggregation/Komposition)

• Klassenbeziehungen (Vererbung)

• abstrakte Klassen und Interfaces

• Polymorphie in der objektorientierten Programmierung

• UML-Klassendiagramme mit PlantUML erstellen

In der objektorientierten Programmierung (OOP) wird das Konzept Vererbung genutzt, um Struktur und Verhalten von Klassen mehrfach nutzen zu können. Man erhält so die Möglichkeit, spezialisierte Klasse auf Grundlage einer allgemeineren Klasse zu bilden. Die spezialisierten Klassen können Struktur und Verhalten der vererbenden Klasse übernehmen oder anpassen - die Implementierung der vererbenden Klasse ist die Basis, die von den erbenden Klassen übernommen werden kann.

Wir betrachten eine allgemeinere Klasse Konto und erbende Klassen PrivatKonto und GeschäftsKonto. In der UML wird die Vererbung über einen Pfeil mit nicht ausgefüllter dreieckiger Pfeilspitze, die auf die allgemeinere Klasse zeigt, notiert.

Die Klasse Konto verfügt bereits über die Basisfunktionalitäten, die ein Konto benötigt: die Attribute iban und kontostand, die Methoden einzahlen() und auszahlen().

Jedoch unterscheiden sich die spezialisierten Konten von der allgemeinen Form darin, dass sie auf unterschiedliche Weise die Kontoinhaber erfassen: der Kontoinhaber eines Privatkontos hat einen Vor- und Nachnamen, während bei einem Geschäftskonto eine Firmenbezeichnung und eine Geschäftsform zur Identifizierung dient.

In der Literatur finden sich eine Vielzahl von Bezeichnungen für diese Beziehung zwischen zwei Klassen:

Das Ausgangsbeispiel als Quelltext

Die Basisklasse Konto

Konto verfügt über zwei Attribute, drei Methoden und einen Konstruktor:

Java Python all none

public class Konto {

    private String iban;
    private double kontostand;

    public Konto(String iban) {
        this.iban = iban;
        kontostand = 0;
    }

    public void einzahlen(double betrag) {
        kontostand = kontostand + betrag;
    }

    public boolean auszahlen(double betrag) {
        if ((kontostand - betrag) > 0) {
            kontostand = kontostand - betrag;
            return true;
        } else {
            return false;
    }   }


    public double getKontostand() {
        return kontostand;
}   }

class Konto:
    def __init__(self, iban: str) -> None:
        self.__iban: str 
        self.__iban = iban
        self.__kontostand: float 
        self.__kontostand = 0
    
    @property
    def kontostand(self) -> float:
        return self.__kontostand

    def einzahlen(self, betrag: float) -> None:
        self.__kontostand += betrag

    def auszahlen(self, betrag: float) -> bool:
        if (kontostand-betrag) >= 0:
            self.__kontostand -= betrag
            return True
        else:
            return False

Das Konzept der Erweiterung in der abgeleiteten Klasse PrivatKonto

PrivatKonto verfügt über alle Methoden und Attribute von Konto, erweitert diese aber um zusätzliche Attribute und Methoden (vorname, nachname, getPrivatekundeName()). Weiterhin verfügt PrivatKonto über einen eigenen Konstruktor, der alle erforderlichen Attribute setzt:

Java Python all none

public class PrivatKonto extends Konto{
    private String vorname;
    private String nachname;

    public PrivatKonto(String iban, String vorname, String nachname){
        super(iban);
        this.vorname = vorname;
        this.nachname = nachname;
    }
     public String getPrivatkundenName(){
         return this.vorname + " " + this.nachname;
}    }

class Privatkonto(Konto):

    def __init__(self, iban, vorname: str, nachname: str) -> None:
        super().__init__(iban)
        self.__vorname: str 
        self.__vorname = vorname
        self.__nachname: str 
        self.__nachname = nachname
    
    @property
    def privatkundenname(self) ->str:
        return self.__vorname + " " + self.__nachname

Die vorhandene Basisklasse Konto wird durch eine Methode, einen Konstruktor und zwei Attribute erweitert.

Auf die Attribute iban und kontostand der Basisklasse kann die Klasse PrivatKonto nicht zugreifen, da diese die Sichtbarkeit private haben. Der Zugriff kann nur über die öffentlichen Methoden von Konto erfolgen (in Python: über die Properties).

Das Konzept Überschreiben - die abgeleitete Klasse GeschäftsKonto

In der Klasse GeschaeftsKonto wird die Basisklasse Konto wieder um einige Attribute (firmenname, verfuegungsrahmen) und Methoden (Konstruktor, Getter und Setter) erweitert.

Zusätzlich wird jedoch auch eine Methode überschrieben: Die Methode auszahlen() wird in Geschäftskonto neu implementiert. Es soll hier zusätzlich der Verfügungsrahmen geprüft werden.

Java Python all none

public class GeschaeftsKonto extends Konto {

    private String firmenname;

    private double verfuegungsrahmen;
    public double getVerfuegungsrahmen() {return verfuegungsrahmen;}
    public void setVerfuegungsrahmen(double verfuegungsrahmen) {this.verfuegungsrahmen = verfuegungsrahmen;}

    public GeschaeftsKonto(String iban, String firmenname, double verfuegungsrahmen) {
        super(iban);
        this.firmenname = firmenname;
        this.setVerfuegungsrahmen(verfuegungsrahmen);
    }

    @Override
    public boolean auszahlen(double betrag) {
      if (betrag > verfuegungsrahmen) {
          return false;
      } else {
          return super.auszahlen(betrag);
}  }  }

class Geschaeftskonto(Konto):
    def __init__(self, iban, firmenname: str, verfuegungsrahmen: float) -> None:
        super().__init__(iban)
        self.__firmenname: str 
        self.__firmenname = firmenname
        self.__verfuegungsrahmen: float
        self.__verfuegungsrahmen = verfuegungsrahmen
    
    @property
    def verfuegungsrahmen(self) ->float:
        return self.__verfuegungsrahmen
    
    @verfuegungsrahmen.setter
    def verfuegungsrahmen(self, verfuegungsrahmen):
        self.__verfuegungsrahmen = verfuegungsrahmen

    def auszahlen(self, betrag: float) -> bool:
        if (betrag) > self.__verfuegungsrahmen:
            return False
        else:
            return super().auszahlen(betrag)

Da Geschäftskonto aufgrund der Sichtbarkeitsmodifikatoren in Konto den Kontostand nicht selbst verändern kann nutzt es die Methoden von Konto, um die Auszahlung durchzuführen. Über die super-Referenz wird wieder auf die Superklasse verwiesen und mit super.auszahlung(betrag) eine Methode aufgerufen, die den Kontostand ändern darf (da sie Bestandteil von Konto ist und somit auf private Attribute von Konto zugreifen darf).

Das Konzept der partiellen Sichtbarkeit (protected)

Eine erbende Klasse von Konto kann das Attribut kontostand nicht verändern. Wenn wir für eine neue Klasse SparKonto eine Methode verzinse() schreiben wollen, so kann diese derzeit nicht direkt den Kontostand um die aufgelaufenen Zinsen erhöhen.

Es gibt viele vergleichbare Anwendungsfälle, in denen wichtig ist, dass auch die erbenden Klassen Zugriff auf geschützte Attribute und Methoden haben. Daher stellt die UML (und viele OOP-Sprachen, jedoch nicht Python) einen weiteren Sichtbarkeitsmodifikator zur Verfügung, der Zugriff innerhalb der Klasse und für alle erbenden Klassen einräumt: protected (im UML-Klassendiagramm: #).

Im obigen UML-Klassendiagramm ist kontostand als protected notiert (mit #). Somit hat die über PrivatKonto erbende Klasse Sparkonto Zugriff auf das Attribut kontostand.

Java Python all none

    protected double kontostand;

public class SparKonto extends PrivatKonto{
    private double zinssatz;
    public double getZinssatz() {return zinssatz;}
    public void setZinssatz(double zinssatz) {this.zinssatz = zinssatz;}

    public SparKonto(String iban , String vorname, String nachname, double startzins ){
        super(iban, vorname, nachname);
        this.setZinssatz(startzins);
    }

    public void verzinse(){
        this.kontostand = this.kontostand * (1+zinssatz);
}  }

class Konto:
    def __init__(self, iban: str) -> None:
        self._iban: str 
        self._iban = iban  # von außen über kontoobject._iban zugreifbar, defacto public
        self.__kontostand: float 
        self.__kontostand = 0

class Konto:

    @property
    def kontostand(self) -> float:
        return self.__kontostand

    @kontostand.setter
    def kontostand(self, betrag):
        self.__kontostand = betrag

class Sparkonto(Privatkonto):
    def __init__(self, iban, vorname: str, nachname: str, startzins: float) -> None:
        super().__init__(iban, vorname, nachname)
        self.__zinssatz: float 
        self.__zinssatz = startzins
    
    @property
    def zinssatz(self) ->float:
        return self.__zinssatz

    @zinssatz.setter
    def zinssatz(self, zinssatz):
        self.__zinssatz = zinssatz

    def verzinse(self):
        # Variante 2: Property
        self.kontostand = self.kontostand * (1+self.zinssatz)
        # bei Variante 1 würde es lauten:
        # self._kontostand = self._kontostand * (1+self.zinssatz)

Das ganze Beispiel als Java-Code

Wer versucht hat, das ganze per UML geplante OOP-Programm in Java nachzuvollziehen, sollte etwa diesen Quelltext am Ende vor sich haben und ausführen können: Gesamtquelltext ein/ausblenden

package de.oerinformatik.crm;

import java.util.ArrayList;

public class Konto{
    private String iban;
    protected double kontostand;

    static ArrayList<Konto> kontenListe = new ArrayList<>();
    
    public String getIban() {
        return iban;
      }
    
    public void setIban(String iban) {
        this.iban = iban;
    }

    void einzahlen(double betrag) {
      kontostand = kontostand + betrag;
    }

    boolean auszahlen(double betrag) {
        if (kontostand - betrag > 0){
            kontostand = kontostand - betrag;
            return true;
        }else{
            return false;
        }
    }
    
    static String listeStatusAllerKonten(){
        String ausgabe ="";
        for (Konto einKonto: kontenListe){
            ausgabe = ausgabe + "\n" + einKonto.kontostatus();
        }
        return ausgabe;
    }
    
    String kontostatus(){
        return "KontoNr "+this.iban+" Kontostand: "+this.kontostand.toString();
    }

    Konto(String iban){
        this.iban = iban;
        kontostand =0.0;
        kontenListe.add(this);
    }

    Konto(String ktn, String blz){
        this.iban = "DE__"+blz+ktn;
        kontenListe.add(this);
    }

    public double getKontostand() {
        return kontostand;
    }
  }

  class PrivatKonto extends Konto{
    private String vorname;
    private String nachname;

    public PrivatKonto(String iban, String vorname, String nachname){
        super(iban);
        this.vorname = vorname;
        this.nachname = nachname;
    }
    public String getPrivatkundenName(){
      return this.vorname + " " + this.nachname;
    }   
}

class GeschaeftsKonto extends Konto {

    private String firmenname;

    private double verfuegungsrahmen;

    public double getVerfuegungsrahmen() {
        return verfuegungsrahmen;
    }

    public void setVerfuegungsrahmen(double verfuegungsrahmen) {
        this.verfuegungsrahmen = verfuegungsrahmen;
    }

    public GeschaeftsKonto(String iban, String firmenname, double verfuegungsrahmen) {
        super(iban);
        this.firmenname = firmenname;
        this.setVerfuegungsrahmen(verfuegungsrahmen);
    }

    @Override
    public boolean auszahlen(double betrag) {
      if (betrag > verfuegungsrahmen) {
          return false;
      } else {
          return super.auszahlen(betrag);
      }  
    }  
  }

class SparKonto extends PrivatKonto{
    private double zinssatz;
    public double getZinssatz() {return zinssatz;}
    public void setZinssatz(double zinssatz) {this.zinssatz = zinssatz;}

    public SparKonto(String iban , String vorname, String nachname, double startzins ){
        super(iban, vorname, nachname);
        this.setZinssatz(startzins);
    }

    public void verzinse(){
        this.kontostand = this.kontostand * (1+zinssatz);
    }  
}

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Klassenbeziehungen: Vererbung von Klassen in der UML” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/uml-klassendiagramm-vererbung veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/uml/umlklasse. Stand: 22.11.2024.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]