TypeScript: Polymorphie

Was ist Polymorphie?

Polymorphie ist ein Konzept in der objektorientierten Programmierung (OOP), das die Möglichkeit beschreibt, dass mehrere Klassen dieselben Methoden haben, aber jede dieser Methoden in jeder Klasse unterschiedlich implementiert werden kann.

Das bedeutet, dass ein Objekt mehrere Formen annehmen kann, abhängig von der Klasse, von der es erstellt wurde. Eine Methode, die auf ein Objekt angewendet wird, kann also unterschiedliches Verhalten aufweisen, je nachdem, welche Klasse das Objekt repräsentiert.

Dies ermöglicht es, dass ein Algorithmus oder eine Methode unabhängig von der spezifischen Klasse arbeitet, die das Objekt repräsentiert, so dass es allgemeiner und wiederverwendbarer ist.

Ein Beispiel dafür ist ein Programm, das verschiedene Arten von geometrischen Formen wie Kreise, Quadrate und Dreiecke verarbeitet. Jede dieser Formen kann eine Methode haben, die die Fläche berechnet, aber jede dieser Methoden muss in jeder Klasse unterschiedlich implementiert werden. Das Programm kann jedoch trotzdem eine allgemeine Methode verwenden, um die Fläche jeder Form zu berechnen, da es davon ausgeht, dass jede Form eine Methode zur Berechnung der Fläche hat.

Überladung von Klassen und Methoden

Die Überladung hingegen, beschreibt eine Möglichkeit, Methoden mit dem gleichen Namen in der gleichen Klasse zu definieren, aber mit unterschiedlichen Parameterlisten. Dadurch kann eine Methode in unterschiedlichen Situationen unterschiedlich verwendet werden. Dies ermöglicht es, dass man die gleiche Methode benutzen kann, um unterschiedliche Aufgaben zu erfüllen, basierend auf den übergebenen Parametern.

Hier ein Beispiel zu der Überladung von Klassen / Methoden:

// Basisklasse "Shape"
class Shape {
    // Polymorphie: Jede Unterklasse implementiert diese Methode auf ihre eigene Weise
    public getArea(): number {
        return 0;
    }
}

// Unterklasse "Circle", die von "Shape" erbt
class Circle extends Shape {
    constructor(private radius: number) {
        super();
    }

    // Überschreibt die Methode "getArea" von der Basisklasse
    public getArea(): number {
        return Math.PI * this.radius * this.radius;
    }
}

// Unterklasse "Rectangle", die von "Shape" erbt
class Rectangle extends Shape {
    constructor(private width: number, private height: number) {
        super();
    }

    // Überschreibt die Methode "getArea" von der Basisklasse
    public getArea(): number {
        return this.width * this.height;
    }
}

// Funktion, die die Fläche einer Form berechnet
function calculateArea(shape: Shape) {
    return shape.getArea();
}

// Beispielaufrufe
const circle = new Circle(5);
console.log(calculateArea(circle)); // 78.53981633974483

const rectangle = new Rectangle(10, 5);
console.log(calculateArea(rectangle)); // 50

In diesem Beispiel haben wir eine Basisklasse „Shape“ definiert, die eine Methode „getArea“ enthält. Diese Methode wird von jeder Unterklasse, die von „Shape“ erbt, überschrieben, um die Fläche der jeweiligen Form zu berechnen. Das ist Polymorphie, denn die Methode getArea() hat für jede Unterklasse eine andere Implementierung.

Außerdem haben wir eine Funktion „calculateArea“ definiert, die die Fläche einer Form berechnet, indem sie die Methode „getArea“ auf ein Objekt anwendet. Diese Funktion ist unabhängig von der spezifischen Klasse, die das Objekt repräsentiert, und kann daher jede Form verarbeiten, solange diese von der Basisklasse „Shape“ erbt.

Es gibt keine Überladung von Methode in diesem Beispiel, aber das kann man in der gleichen Art und Weise machen, indem man beispielsweise eine Methode mit gleichem Namen aber unterschiedlichen Parametern in der gleichen Klasse definiert wie in folgendem Beispiel:

class Calculator {
    // Methodenüberladung: Es gibt mehrere Methoden mit dem gleichen Namen, aber unterschiedlichen Parametern
    public add(a: number, b: number): number;
    public add(a: string, b: string): string;
    public add(a: any, b: any): any {
        if (typeof a === "string" && typeof b === "string") {
            return a + b;
        } else {
            return a + b;
        }
    }
}

const calculator = new Calculator();
console.log(calculator.add(1, 2)); // 3
console.log(calculator.add("Hello, ", "world!")); // "Hello, world!"

In diesem Beispiel haben wir eine Klasse „Calculator“ definiert, die eine Methode „add“ enthält, die zwei Argumente entgegennimmt und ihre Summe zurückgibt. Aber in diesem Fall wurde die Methode add() überladen, d.h es gibt mehrere Methoden mit dem gleichen Namen, aber unterschiedlichen Parametern. In dem Beispiel gibt es zwei Methoden die add aufrufen. Eine Methode die nimmt zwei numerische Argumente und eine Methode die zwei string Argumente nimmt.

Im ersten Fall, wenn die Methodenadd mit zwei numerischen Argumenten aufgerufen wird, addiert sie die beiden Argumente einfach und gibt ihre Summe zurück. Im zweiten Fall, wenn die Methode mit zwei String Argumenten aufgerufen wird, verbindet sie die beiden Argumente und gibt das Ergebnis zurück. Das ist die Überladung der Methode add().

Beachte, dass die Überladung von Methoden in TypeScript durch das Schreiben mehrerer Methoden mit dem gleichen Namen und unterschiedlichen Parameterlisten erreicht wird, wobei die Implementierung der Methode in der letzten Methode definiert wird.

Zusammengefasst, Polymorphie bezieht sich auf das Verhalten von Methoden, die von verschiedenen Klassen geerbt wurden, während Überladung sich auf das Verhalten von Methoden in der gleichen Klasse bezieht. In beiden Fällen geht es darum, Code wiederverwendbar und flexibler zu machen und sie ergänzen sich in vielen Szenarios und verbessern die Code-Design und -lesbarkeit

Ich hoffe ich konnte dir einen guten Einblick in die Konzepte Polymorphie und Überladung von Methoden / Klassen vermitteln.