Praktische Anwendung der Vererbung

PythonPythonBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden Sie lernen, wie Sie Vererbung (inheritance) nutzen können, um erweiterbares Code zu schreiben und eine praktische Anwendung zu erstellen, die Daten in verschiedenen Formaten ausgibt. Sie werden auch verstehen, wie Sie abstrakte Basisklassen (abstract base classes) und deren konkrete Implementierungen verwenden können.

Darüber hinaus werden Sie ein Fabrikmuster (factory pattern) implementieren, um die Klassenauswahl zu vereinfachen. Die Datei, die Sie ändern werden, ist tableformat.py.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/ObjectOrientedProgrammingGroup(["Object-Oriented Programming"]) python/FunctionsGroup -.-> python/function_definition("Function Definition") python/ObjectOrientedProgrammingGroup -.-> python/classes_objects("Classes and Objects") python/ObjectOrientedProgrammingGroup -.-> python/inheritance("Inheritance") python/ObjectOrientedProgrammingGroup -.-> python/polymorphism("Polymorphism") subgraph Lab Skills python/function_definition -.-> lab-132495{{"Praktische Anwendung der Vererbung"}} python/classes_objects -.-> lab-132495{{"Praktische Anwendung der Vererbung"}} python/inheritance -.-> lab-132495{{"Praktische Anwendung der Vererbung"}} python/polymorphism -.-> lab-132495{{"Praktische Anwendung der Vererbung"}} end

Das Problem verstehen

In diesem Lab werden wir uns mit Vererbung (inheritance) in Python befassen und lernen, wie sie uns dabei helfen kann, Code zu schreiben, der sowohl erweiterbar als auch anpassungsfähig ist. Vererbung ist ein mächtiges Konzept in der objektorientierten Programmierung, bei dem eine Klasse Attribute und Methoden von einer anderen Klasse erben kann. Dies ermöglicht es uns, Code wiederzuverwenden und auf bestehendem Code komplexere Funktionen aufzubauen.

Beginnen wir damit, uns die vorhandene Funktion print_table() anzusehen. Diese Funktion werden wir verbessern, um sie in Bezug auf die Ausgabeformate flexibler zu gestalten.

Zunächst müssen Sie die Datei tableformat.py im WebIDE - Editor öffnen. Der Pfad zu dieser Datei lautet wie folgt:

/home/labex/project/tableformat.py

Sobald Sie die Datei geöffnet haben, sehen Sie die aktuelle Implementierung der Funktion print_table(). Diese Funktion ist dazu ausgelegt, tabellarische Daten zu formatieren und auszugeben. Sie nimmt zwei Hauptparameter entgegen: eine Liste von Datensätzen (die Objekte sind) und eine Liste von Feldnamen. Basierend auf diesen Eingaben gibt sie eine schön formatierte Tabelle aus.

Jetzt testen wir diese Funktion, um zu sehen, wie sie funktioniert. Öffnen Sie ein Terminal im WebIDE und führen Sie die folgenden Python - Befehle aus. Diese Befehle importieren die erforderlichen Module, lesen Daten aus einer CSV - Datei und verwenden dann die Funktion print_table(), um die Daten anzuzeigen.

import stock
import reader
import tableformat

portfolio = reader.read_csv_as_instances('portfolio.csv', stock.Stock)
tableformat.print_table(portfolio, ['name', 'shares', 'price'])

Nachdem Sie diese Befehle ausgeführt haben, sollten Sie die folgende Ausgabe sehen:

      name     shares      price
---------- ---------- ----------
        AA        100       32.2
       IBM         50       91.1
       CAT        150      83.44
      MSFT        200      51.23
        GE         95      40.37
      MSFT         50       65.1
       IBM        100      70.44

Die Ausgabe sieht gut aus, aber diese Funktion hat eine Einschränkung. Derzeit unterstützt sie nur ein Ausgabeformat, nämlich einfachen Text. In realen Szenarien möchten Sie möglicherweise Ihre Daten in verschiedenen Formaten wie CSV, HTML oder anderen ausgeben.

Anstatt die Funktion print_table() jedes Mal zu ändern, wenn wir ein neues Ausgabeformat unterstützen möchten, können wir Vererbung nutzen, um eine flexiblere Lösung zu schaffen. So werden wir vorgehen:

  1. Wir definieren eine Basisklasse TableFormatter. Diese Klasse wird Methoden haben, die zur Formatierung von Daten verwendet werden. Die Basisklasse bietet eine gemeinsame Struktur und Funktionalität, auf der alle Unterklassen aufbauen können.
  2. Wir erstellen verschiedene Unterklassen. Jede Unterklasse wird für ein anderes Ausgabeformat entworfen. Beispielsweise könnte eine Unterklasse für die CSV - Ausgabe, eine andere für die HTML - Ausgabe und so weiter verwendet werden. Diese Unterklassen erben die Methoden von der Basisklasse und können auch ihre eigene spezifische Funktionalität hinzufügen.
  3. Wir ändern die Funktion print_table(), damit sie mit jedem Formatter arbeiten kann. Dies bedeutet, dass wir verschiedene Unterklassen der Klasse TableFormatter an die Funktion print_table() übergeben können, und sie wird in der Lage sein, die entsprechenden Formatierungsmethoden zu verwenden.

Dieser Ansatz hat einen großen Vorteil. Er ermöglicht es uns, neue Ausgabeformate hinzuzufügen, ohne die Kernfunktionalität der Funktion print_table() zu ändern. Wenn sich also Ihre Anforderungen ändern und Sie mehr Ausgabeformate unterstützen müssen, können Sie dies einfach tun, indem Sie neue Unterklassen erstellen.

Erstellen einer Basisklasse und Ändern der Ausgabefunktion

In der Programmierung ist Vererbung (inheritance) ein mächtiges Konzept, das es uns ermöglicht, eine Hierarchie von Klassen zu erstellen. Um Vererbung für die Ausgabe von Daten in verschiedenen Formaten zu nutzen, müssen wir zunächst eine Basisklasse erstellen. Eine Basisklasse dient als Blaupause für andere Klassen und definiert eine gemeinsame Gruppe von Methoden, die ihre Unterklassen erben und überschreiben können.

Jetzt erstellen wir eine Basisklasse, die die Schnittstelle für alle Tabellenformatierer definiert. Öffnen Sie die Datei tableformat.py im WebIDE und fügen Sie den folgenden Code oben in der Datei hinzu:

class TableFormatter:
    """
    Base class for all table formatters.
    This class defines the interface that all formatters must implement.
    """
    def headings(self, headers):
        """
        Generate the table headings.
        """
        raise NotImplementedError()

    def row(self, rowdata):
        """
        Generate a single row of table data.
        """
        raise NotImplementedError()

Die Klasse TableFormatter ist eine abstrakte Basisklasse. Eine abstrakte Basisklasse ist eine Klasse, die Methoden definiert, aber keine Implementierungen für sie bereitstellt. Stattdessen erwartet sie, dass ihre Unterklassen diese Implementierungen liefern. Die NotImplementedError - Ausnahmen werden verwendet, um anzuzeigen, dass diese Methoden von Unterklassen überschrieben werden müssen. Wenn eine Unterklasse diese Methoden nicht überschreibt und wir versuchen, sie zu verwenden, wird ein Fehler ausgelöst.

Als Nächstes müssen wir die Funktion print_table() ändern, um die Klasse TableFormatter zu verwenden. Die Funktion print_table() wird verwendet, um eine Tabelle mit Daten aus einer Liste von Objekten auszugeben. Indem wir sie so ändern, dass sie die Klasse TableFormatter verwendet, können wir die Funktion flexibler gestalten und sie in der Lage machen, mit verschiedenen Tabellenformaten zu arbeiten.

Ersetzen Sie die vorhandene Funktion print_table() durch den folgenden Code:

def print_table(records, fields, formatter):
    """
    Print a table of data from a list of objects using the specified formatter.

    Args:
        records: A list of objects
        fields: A list of field names
        formatter: A TableFormatter object
    """
    formatter.headings(fields)
    for r in records:
        rowdata = [getattr(r, fieldname) for fieldname in fields]
        formatter.row(rowdata)

Der wichtigste Unterschied hier ist, dass print_table() jetzt einen formatter - Parameter nimmt, der eine Instanz von TableFormatter oder einer Unterklasse sein sollte. Dies bedeutet, dass wir verschiedene Tabellenformatierer an die Funktion print_table() übergeben können, und sie wird den entsprechenden Formatierer verwenden, um die Tabelle auszugeben. Die Funktion delegiert die Formatierungsaufgabe an das Formatierer - Objekt, indem sie seine Methoden headings() und row() aufruft.

Testen wir unsere Änderungen, indem wir versuchen, die Basisklasse TableFormatter zu verwenden:

import stock
import reader
import tableformat

portfolio = reader.read_csv_as_instances('portfolio.csv', stock.Stock)
formatter = tableformat.TableFormatter()
tableformat.print_table(portfolio, ['name', 'shares', 'price'], formatter)

Wenn Sie diesen Code ausführen, sollten Sie einen Fehler sehen:

Traceback (most recent call last):
...
NotImplementedError

Dieser Fehler tritt auf, weil wir versuchen, die abstrakte Basisklasse direkt zu verwenden, aber sie keine Implementierungen für ihre Methoden bereitstellt. Da die Methoden headings() und row() in der Klasse TableFormatter NotImplementedError auslösen, weiß Python nicht, was es tun soll, wenn diese Methoden aufgerufen werden. Im nächsten Schritt werden wir eine konkrete Unterklasse erstellen, die diese Implementierungen bereitstellt.

✨ Lösung prüfen und üben

Implementierung eines konkreten Formatierers

Nachdem wir unsere abstrakte Basisklasse definiert und die Funktion print_table() aktualisiert haben, ist es an der Zeit, eine konkrete Formatiererklasse zu erstellen. Eine konkrete Formatiererklasse ist eine, die tatsächliche Implementierungen für die in der abstrakten Basisklasse definierten Methoden bereitstellt. In unserem Fall werden wir eine Klasse erstellen, die Daten in eine einfache Texttabelle formatieren kann.

Fügen Sie die folgende Klasse zu Ihrer tableformat.py - Datei hinzu. Diese Klasse wird von der abstrakten Basisklasse TableFormatter erben und die Methoden headings() und row() implementieren.

class TextTableFormatter(TableFormatter):
    """
    Formatter that generates a plain - text table.
    """
    def headings(self, headers):
        """
        Generate plain - text table headings.
        """
        print(' '.join('%10s' % h for h in headers))
        print(('-'*10 + ' ')*len(headers))

    def row(self, rowdata):
        """
        Generate a plain - text table row.
        """
        print(' '.join('%10s' % d for d in rowdata))

Die Klasse TextTableFormatter erbt von TableFormatter. Das bedeutet, dass sie alle Eigenschaften und Methoden der Klasse TableFormatter erhält, aber auch eigene Implementierungen für die Methoden headings() und row() bereitstellt. Diese Methoden sind jeweils für die Formatierung der Tabellenüberschriften und -zeilen verantwortlich. Die Methode headings() gibt die Überschriften in einem schön formatierten Stil aus, gefolgt von einer Linie aus Bindestrichen, um die Überschriften von den Daten zu trennen. Die Methode row() formatiert jede Datenzeile auf ähnliche Weise.

Jetzt testen wir unseren neuen Formatierer. Wir verwenden die Module stock, reader und tableformat, um Daten aus einer CSV - Datei zu lesen und sie mit unserem neuen Formatierer auszugeben.

import stock
import reader
import tableformat

portfolio = reader.read_csv_as_instances('portfolio.csv', stock.Stock)
formatter = tableformat.TextTableFormatter()
tableformat.print_table(portfolio, ['name', 'shares', 'price'], formatter)

Wenn Sie diesen Code ausführen, sollten Sie die gleiche Ausgabe wie zuvor sehen. Dies liegt daran, dass unser neuer Formatierer so konzipiert ist, dass er die gleiche einfache Texttabelle wie die ursprüngliche Funktion print_table() erzeugt.

      name     shares      price
---------- ---------- ----------
        AA        100       32.2
       IBM         50       91.1
       CAT        150      83.44
      MSFT        200      51.23
        GE         95      40.37
      MSFT         50       65.1
       IBM        100      70.44

Diese Ausgabe bestätigt, dass unser TextTableFormatter korrekt funktioniert. Der Vorteil dieses Ansatzes besteht darin, dass wir unseren Code modularer und erweiterbarer gemacht haben. Indem wir die Formatierungslogik in eine separate Klassenhierarchie aufteilen, können wir leicht neue Ausgabeformate hinzufügen. Alles, was wir tun müssen, ist, neue Unterklassen von TableFormatter zu erstellen, ohne die Funktion print_table() zu ändern. Auf diese Weise können wir in Zukunft verschiedene Ausgabeformate wie CSV oder HTML unterstützen.

✨ Lösung prüfen und üben

Erstellen zusätzlicher Formatierer

In der Programmierung ist Vererbung (inheritance) ein mächtiges Konzept, das es uns ermöglicht, neue Klassen auf der Grundlage bestehender zu erstellen. Dies hilft bei der Wiederverwendung von Code und macht unsere Programme erweiterbarer. In diesem Teil des Experiments werden wir Vererbung nutzen, um zwei neue Formatierer für verschiedene Ausgabeformate zu erstellen: CSV und HTML. Diese Formatierer werden von einer Basisklasse erben, was bedeutet, dass sie einige gemeinsame Verhaltensweisen teilen, während sie ihre eigenen einzigartigen Methoden zur Datenformatierung haben.

Jetzt fügen wir die folgenden Klassen zu Ihrer tableformat.py - Datei hinzu. Diese Klassen werden definieren, wie Daten in CSV - und HTML - Formaten formatiert werden sollen.

class CSVTableFormatter(TableFormatter):
    """
    Formatter that generates CSV formatted data.
    """
    def headings(self, headers):
        """
        Generate CSV headers.
        """
        print(','.join(headers))

    def row(self, rowdata):
        """
        Generate a CSV data row.
        """
        print(','.join(str(d) for d in rowdata))

class HTMLTableFormatter(TableFormatter):
    """
    Formatter that generates HTML table code.
    """
    def headings(self, headers):
        """
        Generate HTML table headers.
        """
        print('<tr>', end=' ')
        for header in headers:
            print(f'<th>{header}</th>', end=' ')
        print('</tr>')

    def row(self, rowdata):
        """
        Generate an HTML table row.
        """
        print('<tr>', end=' ')
        for data in rowdata:
            print(f'<td>{data}</td>', end=' ')
        print('</tr>')

Die Klasse CSVTableFormatter ist dafür konzipiert, Daten im CSV - Format (Comma - Separated Values, Komma - getrennte Werte) zu formatieren. Die Methode headings nimmt eine Liste von Überschriften und gibt sie getrennt durch Kommas aus. Die Methode row nimmt eine Liste von Daten für eine einzelne Zeile und gibt sie ebenfalls getrennt durch Kommas aus.

Die Klasse HTMLTableFormatter hingegen wird verwendet, um HTML - Tabellen - Code zu generieren. Die Methode headings erstellt die Tabellenüberschriften mit HTML - <th> - Tags, und die Methode row erstellt eine Tabellenzeile mit HTML - <td> - Tags.

Testen wir diese neuen Formatierer, um zu sehen, wie sie funktionieren.

  1. Zuerst testen wir den CSV - Formatierer:
import stock
import reader
import tableformat

portfolio = reader.read_csv_as_instances('portfolio.csv', stock.Stock)
formatter = tableformat.CSVTableFormatter()
tableformat.print_table(portfolio, ['name', 'shares', 'price'], formatter)

In diesem Code importieren wir zunächst die erforderlichen Module. Dann lesen wir Daten aus einer CSV - Datei namens portfolio.csv und erstellen Instanzen der Klasse Stock. Als Nächstes erstellen wir eine Instanz der Klasse CSVTableFormatter. Schließlich verwenden wir die Funktion print_table, um die Portfolio - Daten im CSV - Format auszugeben.

Sie sollten die folgende CSV - formatierte Ausgabe sehen:

name,shares,price
AA,100,32.2
IBM,50,91.1
CAT,150,83.44
MSFT,200,51.23
GE,95,40.37
MSFT,50,65.1
IBM,100,70.44
  1. Jetzt testen wir den HTML - Formatierer:
formatter = tableformat.HTMLTableFormatter()
tableformat.print_table(portfolio, ['name', 'shares', 'price'], formatter)

Hier erstellen wir eine Instanz der Klasse HTMLTableFormatter und verwenden erneut die Funktion print_table, um die Portfolio - Daten im HTML - Format auszugeben.

Sie sollten die folgende HTML - formatierte Ausgabe sehen:

<tr> <th>name</th> <th>shares</th> <th>price</th> </tr>
<tr> <td>AA</td> <td>100</td> <td>32.2</td> </tr>
<tr> <td>IBM</td> <td>50</td> <td>91.1</td> </tr>
<tr> <td>CAT</td> <td>150</td> <td>83.44</td> </tr>
<tr> <td>MSFT</td> <td>200</td> <td>51.23</td> </tr>
<tr> <td>GE</td> <td>95</td> <td>40.37</td> </tr>
<tr> <td>MSFT</td> <td>50</td> <td>65.1</td> </tr>
<tr> <td>IBM</td> <td>100</td> <td>70.44</td> </tr>

Wie Sie sehen können, erzeugt jeder Formatierer Ausgabe in einem anderen Format, aber sie alle teilen die gleiche Schnittstelle, die von der Basisklasse TableFormatter definiert wird. Dies ist ein großartiges Beispiel für die Macht von Vererbung und Polymorphismus. Wir können Code schreiben, der mit der Basisklasse arbeitet, und er wird automatisch mit jeder Unterklasse funktionieren.

Die Funktion print_table() muss nichts über den spezifischen verwendeten Formatierer wissen. Sie ruft einfach die in der Basisklasse definierten Methoden auf, und die entsprechende Implementierung wird basierend auf der Art des bereitgestellten Formatierers ausgewählt. Dies macht unseren Code flexibler und leichter zu warten.

✨ Lösung prüfen und üben

Erstellen einer Fabrikfunktion

Beim Verwenden von Vererbung besteht eine häufige Herausforderung darin, dass Benutzer sich die Namen der spezifischen Formatiererklassen merken müssen. Dies kann recht mühsam sein, insbesondere wenn die Anzahl der Klassen wächst. Um diesen Prozess zu vereinfachen, können wir eine Fabrikfunktion erstellen. Eine Fabrikfunktion ist eine spezielle Art von Funktion, die Objekte erstellt und zurückgibt. In unserem Fall wird sie den entsprechenden Formatierer basierend auf einem einfachen Formatnamen zurückgeben.

Fügen Sie die folgende Funktion zu Ihrer tableformat.py - Datei hinzu. Diese Funktion nimmt einen Formatnamen als Argument und gibt das entsprechende Formatiererobjekt zurück.

def create_formatter(format_name):
    """
    Create a formatter of the specified type.

    Args:
        format_name: Name of the formatter ('text', 'csv', 'html')

    Returns:
        A TableFormatter object

    Raises:
        ValueError: If format_name is not recognized
    """
    if format_name == 'text':
        return TextTableFormatter()
    elif format_name == 'csv':
        return CSVTableFormatter()
    elif format_name == 'html':
        return HTMLTableFormatter()
    else:
        raise ValueError(f'Unknown format {format_name}')

Die Funktion create_formatter() ist eine Fabrikfunktion. Sie überprüft das von Ihnen bereitgestellte Argument format_name. Wenn es 'text' ist, erstellt und gibt sie ein TextTableFormatter - Objekt zurück. Wenn es 'csv' ist, gibt sie ein CSVTableFormatter - Objekt zurück, und wenn es 'html' ist, gibt sie ein HTMLTableFormatter - Objekt zurück. Wenn der Formatname nicht erkannt wird, löst sie eine ValueError - Ausnahme aus. Auf diese Weise können Benutzer einen Formatierer einfach durch Angabe eines einfachen Namens auswählen, ohne die spezifischen Klassennamen kennen zu müssen.

Jetzt testen wir die Fabrikfunktion. Wir verwenden einige vorhandene Funktionen und Klassen, um Daten aus einer CSV - Datei zu lesen und sie in verschiedenen Formaten auszugeben.

import stock
import reader
from tableformat import create_formatter, print_table

portfolio = reader.read_csv_as_instances('portfolio.csv', stock.Stock)

## Test with text formatter
formatter = create_formatter('text')
print("\nText Format:")
print_table(portfolio, ['name', 'shares', 'price'], formatter)

## Test with CSV formatter
formatter = create_formatter('csv')
print("\nCSV Format:")
print_table(portfolio, ['name', 'shares', 'price'], formatter)

## Test with HTML formatter
formatter = create_formatter('html')
print("\nHTML Format:")
print_table(portfolio, ['name', 'shares', 'price'], formatter)

In diesem Code importieren wir zunächst die erforderlichen Module und Funktionen. Dann lesen wir Daten aus der Datei portfolio.csv und erstellen ein portfolio - Objekt. Danach testen wir die Funktion create_formatter() mit verschiedenen Formatnamen: 'text', 'csv' und 'html'. Für jedes Format erstellen wir ein Formatiererobjekt, geben den Formatnamen aus und verwenden dann die Funktion print_table(), um die portfolio - Daten im angegebenen Format auszugeben.

Wenn Sie diesen Code ausführen, sollten Sie Ausgabe in allen drei Formaten sehen, getrennt durch den Formatnamen:

Text Format:
      name     shares      price
---------- ---------- ----------
        AA        100       32.2
       IBM         50       91.1
       CAT        150      83.44
      MSFT        200      51.23
        GE         95      40.37
      MSFT         50       65.1
       IBM        100      70.44

CSV Format:
name,shares,price
AA,100,32.2
IBM,50,91.1
CAT,150,83.44
MSFT,200,51.23
GE,95,40.37
MSFT,50,65.1
IBM,100,70.44

HTML Format:
<tr> <th>name</th> <th>shares</th> <th>price</th> </tr>
<tr> <td>AA</td> <td>100</td> <td>32.2</td> </tr>
<tr> <td>IBM</td> <td>50</td> <td>91.1</td> </tr>
<tr> <td>CAT</td> <td>150</td> <td>83.44</td> </tr>
<tr> <td>MSFT</td> <td>200</td> <td>51.23</td> </tr>
<tr> <td>GE</td> <td>95</td> <td>40.37</td> </tr>
<tr> <td>MSFT</td> <td>50</td> <td>65.1</td> </tr>
<tr> <td>IBM</td> <td>100</td> <td>70.44</td> </tr>

Die Fabrikfunktion macht den Code benutzerfreundlicher, da sie die Details der Klasseninstanzierung verbirgt. Benutzer müssen nicht wissen, wie man Formatiererobjekte erstellt; sie müssen nur das gewünschte Format angeben.

Dieses Muster des Verwenden einer Fabrikfunktion zur Objekterstellung ist ein gängiges Entwurfsmuster in der objektorientierten Programmierung, bekannt als Fabrikmuster (Factory Pattern). Es bietet eine Abstraktionsschicht zwischen dem Clientcode (dem Code, der den Formatierer verwendet) und den tatsächlichen Implementierungsklassen (den Formatiererklassen). Dies macht den Code modularer und einfacher zu verwenden.

Wiederholung der Schlüsselkonzepte:

  1. Abstrakte Basisklasse: Die Klasse TableFormatter dient als Schnittstelle (Interface). Eine Schnittstelle definiert eine Reihe von Methoden, die alle Klassen, die sie implementieren, haben müssen. In unserem Fall müssen alle Formatiererklassen die in der Klasse TableFormatter definierten Methoden implementieren.

  2. Vererbung: Die konkreten Formatiererklassen wie TextTableFormatter, CSVTableFormatter und HTMLTableFormatter erben von der Basisklasse TableFormatter. Dies bedeutet, dass sie die Grundstruktur und die Methoden von der Basisklasse erhalten und ihre eigenen spezifischen Implementierungen bereitstellen können.

  3. Polymorphismus: Die Funktion print_table() kann mit jedem Formatierer arbeiten, der die erforderliche Schnittstelle implementiert. Dies bedeutet, dass Sie verschiedene Formatiererobjekte an die Funktion print_table() übergeben können, und sie wird korrekt mit jedem davon funktionieren.

  4. Fabrikmuster: Die Funktion create_formatter() vereinfacht die Erstellung von Formatiererobjekten. Sie kümmert sich um die Details der Erstellung des richtigen Objekts basierend auf dem Formatnamen, sodass sich Benutzer nicht darum kümmern müssen.

Durch die Verwendung dieser objektorientierten Prinzipien haben wir ein flexibles und erweiterbares System zur Formatierung tabellarischer Daten in verschiedenen Ausgabeformaten erstellt.

✨ Lösung prüfen und üben

Zusammenfassung

In diesem Lab haben Sie mehrere Schlüsselkonzepte der objektorientierten Programmierung gelernt. Sie haben gelernt, wie Sie Vererbung (inheritance) nutzen können, um erweiterbaren Code zu erstellen, eine abstrakte Basisklasse als Schnittstelle (Interface) zu definieren und konkrete Unterklassen zu implementieren, die von einer Basisklasse erben. Darüber hinaus haben Sie gelernt, Polymorphismus zu verwenden, um Code zu schreiben, der mit verschiedenen Typen funktioniert, und das Fabrikmuster (Factory Pattern) einzusetzen, um die Objekterstellung zu vereinfachen.

Diese Konzepte sind mächtige Werkzeuge für die Erstellung von wartbarem und erweiterbarem Code. Das von Ihnen erstellte Tabellenformatierungssystem zeigt, wie Vererbung ein flexibles System schaffen kann. Sie können diese Prinzipien auf andere Programmieraufgaben anwenden, wodurch Ihr Code modular, wiederverwendbar und an wechselnde Anforderungen anpassbar wird.