JavaScript - Polymorphism

Hallo zusammen, zukünftige JavaScript-Zauberer! Heute machen wir uns auf eine aufregende Reise in die Welt der Polymorphie in JavaScript. Keine Sorge, wenn dieses Wort abschreckend klingt - bis zum Ende dieser Lektion werdet ihr Polymorphie wie ein Profi einsetzen können!

Polymorphie in JavaScript

Lassen Sie uns mit den Grundlagen beginnen. Polymorphie ist ein schicker Ausdruck, der aus dem Griechischen stammt und "viele Formen" bedeutet. In der Programmierung bezieht er sich auf die Fähigkeit von Objekten, mehrere Formen oder Verhaltensweisen anzunehmen. Denkt daran wie ein Chamäleon, das seine Farbe ändert, um sich an verschiedene Umgebungen anzupassen.

In JavaScript ermöglicht Polymorphie die Verwendung einer einzigen Schnittstelle, um verschiedene Arten von Objekten darzustellen. Es ist wie ein Universal-Fernbedienung, die verschiedene Geräte - euer Fernseher, DVD-Player und Soundsystem - alle mit den gleichen Tasten bedienen kann.

Hier ist ein einfaches Beispiel, um dieses Konzept zu veranschaulichen:

function makeSound(animal) {
console.log(animal.sound());
}

let dog = {
sound: function() {
return "Wuff!";
}
};

let cat = {
sound: function() {
return "Miau!";
}
};

makeSound(dog); // Ausgabe: Wuff!
makeSound(cat); // Ausgabe: Miau!

In diesem Beispiel haben wir eine makeSound-Funktion, die mit verschiedenen Tierobjekten arbeiten kann. Sowohl dog als auch cat haben eine sound-Methode, aber sie erzeugen unterschiedliche Ausgaben. Dies ist Polymorphie in Aktion!

Methoden-Überschreibung

Ein zentraler Aspekt der Polymorphie ist die Methoden-Überschreibung. Dies tritt auf, wenn eine Unterklasse eine spezifische Implementierung für eine Methode bereitstellt, die bereits in ihrer Oberklasse definiert ist.

Sehen wir uns ein Beispiel an:

class Animal {
makeSound() {
return "Das Tier macht einen Laut";
}
}

class Dog extends Animal {
makeSound() {
return "Der Hund bellt";
}
}

class Cat extends Animal {
makeSound() {
return "Die Katze miaut";
}
}

let animal = new Animal();
let dog = new Dog();
let cat = new Cat();

console.log(animal.makeSound()); // Ausgabe: Das Tier macht einen Laut
console.log(dog.makeSound());    // Ausgabe: Der Hund bellt
console.log(cat.makeSound());    // Ausgabe: Die Katze miaut

Hier haben wir eine Animal-Klasse mit einer makeSound-Methode. Die Dog- und Cat-Klassen erweitern Animal und überschreiben die makeSound-Methode mit eigenen Implementierungen. Dies ermöglicht es jedem Tier, seinen eigenen einzigartigen Klang zu haben, während sie noch Teil der Animal-Familie sind.

Beispiele

Lassen Sie uns tiefer einsteigen mit mehr Beispielen, um unser Verständnis der Polymorphie in JavaScript wirklich zu festigen.

Beispiel 1: Shape Calculator

Stellen wir uns vor, wir bauen einen Formenrechner. Wir möchten die Fläche verschiedener Formen mit demselben Methodennamen berechnen.

class Shape {
calculateArea() {
return 0;
}
}

class Circle extends Shape {
constructor(radius) {
super();
this.radius = radius;
}

calculateArea() {
return Math.PI * this.radius * this.radius;
}
}

class Rectangle extends Shape {
constructor(width, height) {
super();
this.width = width;
this.height = height;
}

calculateArea() {
return this.width * this.height;
}
}

function printArea(shape) {
console.log("Die Fläche beträgt: " + shape.calculateArea());
}

let circle = new Circle(5);
let rectangle = new Rectangle(4, 6);

printArea(circle);    // Ausgabe: Die Fläche beträgt: 78.53981633974483
printArea(rectangle); // Ausgabe: Die Fläche beträgt: 24

In diesem Beispiel haben wir eine Basis-Shape-Klasse und zwei abgeleitete Klassen, Circle und Rectangle. Jede Klasse implementiert ihre eigene calculateArea-Methode. Die printArea-Funktion kann mit jedem Formenobjekt arbeiten, was Polymorphie zeigt.

Beispiel 2: Employee Payroll System

Lassen Sie uns ein einfaches Mitarbeiterlohnsystem erstellen, um die Polymorphie weiter zu veranschaulichen:

class Employee {
constructor(name, salary) {
this.name = name;
this.salary = salary;
}

calculateBonus() {
return this.salary * 0.1;
}
}

class Manager extends Employee {
calculateBonus() {
return this.salary * 0.2;
}
}

class Developer extends Employee {
calculateBonus() {
return this.salary * 0.15;
}
}

function printBonus(employee) {
console.log(`${employee.name}'s Bonus ist: $${employee.calculateBonus()}`);
}

let john = new Employee("John", 50000);
let jane = new Manager("Jane", 70000);
let bob = new Developer("Bob", 60000);

printBonus(john); // Ausgabe: Johns Bonus ist: $5000
printBonus(jane); // Ausgabe: Janes Bonus ist: $14000
printBonus(bob);  // Ausgabe: Bob's Bonus ist: $9000

In diesem Beispiel haben wir verschiedene Arten von Mitarbeitern mit unterschiedlichen Bonusberechnungsregeln. Die printBonus-Funktion arbeitet mit jedem Mitarbeiterobjekt, was Polymorphie zeigt.

Vorteile der Verwendung von Polymorphie in JavaScript

Nun, da wir Polymorphie in Aktion gesehen haben, lassen uns über die Gründe sprechen, warum es so großartig ist:

1. Code-Wiederverwendbarkeit: Polymorphie ermöglicht es uns, generischeren und wiederverwendbaren Code zu schreiben. Unsere printArea- und printBonus-Funktionen können mit jeder Formen- oder Mitarbeiterobjekt arbeiten.

2. Flexibilität: Es ist einfacher, neue Arten von Objekten hinzuzufügen, ohne bestehenden Code zu ändern. Wir könnten eine Triangle-Klasse zu unserem Formenrechner hinzufügen, ohne die printArea-Funktion zu ändern.

3. Wartbarkeit: Polymorphie kann zu saubereren, besser organisierten und einfacher zu wartenden und zu erweiternden Code führen.

4. Abstraktion: Es ermöglicht uns, mit Objekten auf einer höheren Abstraktionsebene zu arbeiten, uns auf das zu konzentrieren, was Objekte tun, anstatt darauf, wie sie es tun.

Hier ist eine Tabelle, die die Schlüsselmethode, die wir in unseren Beispielen verwendet haben, zusammenfasst:

Methode	Beschreibung
calculateArea()	Berechnet die Fläche einer Form
calculateBonus()	Berechnet den Bonus für einen Mitarbeiter
makeSound()	Gibt den Laut eines Tieres zurück
sound()	Gibt den Laut eines Tieres zurück (im objektorientierten Beispiel)

Denkt daran, junge Padawans, Polymorphie ist wie ein Schweizer Army Knife in eurem Coding-Werkzeugkasten. Es ist vielseitig, mächtig und kann euren Code eleganter und effizienter machen. Übt weiter, und bald werdet ihr Polymorphie zu JavaScript-Meisterheit führen!

Credits: Image by storyset