# TypeScript Classes definieren und verwenden TypeScript Classes bieten eine klare und strukturierte Möglichkeit, Daten und Verhalten in einem **Objekt** zu organisieren. So können Sie Entitäten und Konzepte in Ihrem Code leichter modellieren. ## Wozu dienen TypeScript Classes? Klassen sind ein Schlüsselkonzept der Programmiersprache TypeScript, die auf JavaScript aufbaut. Sie stellen eine **strukturierte Methode zur Definition von Objekten** und zur Anwendung objektorientierter Programmierung (OOP) dar. TypeScript Classes ähneln Bauplänen für die Erzeugung von Objekten, die logisch zusammenhängende Daten und Methoden bündeln. [TypeScript](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/typescript/) enthält alle Funktionen von JavaScript und umfasst zusätzlich **statische Typisierung**. So können Sie Datentypen für [TypeScript Functions](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/typescript-functions/), -Variablen und -Klassen angeben, um Fehler bei der Kompilierzeit zu erkennen. TypeScript-Klassen unterstützen neben Typsicherheit auch Konzepte wie Vererbung und Abstraktion, was die Entwicklung von komplexen Anwendungen erleichtert. Mit TypeScript Classes können Sie eine klare **Hierarchie von Klassen** erstellen, die Eigenschaften und Methoden erben. So fördern Sie die Code-Wiederverwendung und Strukturierung. Konstruktoren in Klassen ermöglichen dabei die Initialisierung von Instanzen und die Sicherstellung einer konsistenten Objekterzeugung. ## Das ist die Syntax von TypeScript Classes Die Schreibweise von TypeScript-Klassen ähnelt der von **ECMAScript 6 (ES6)** und ist eine erweitere Version der JavaScript-Klassensyntax. Eine Klasse in TypeScript kann verschiedene Elemente beinhalten, um die Struktur und das Verhalten von Objekten zu definieren. Die wesentlichen Hauptbestandteile sind: - **Eigenschaften** - **Konstruktor** - **Methoden** ### Eigenschaften Eigenschaften (Properties) bestimmen den **Zustand eines Objekts**. Sie speichern Datenwerte und können mit Datentypen annotiert werden, damit sie nur gültige Werte aufweisen. ```typescript class ClassName { propertyName: propertyType; } ``` - **ClassName**: Der Name der Klasse - **propertyName**: Der Name der Eigenschaft, die Sie definieren möchten - **propertyType**: Der Datentyp der Eigenschaft Hier ist ein konkretes Beispiel: ```typescript class Person { name: string; } ``` Zuerst wird eine Klasse `Person` mit einer Eigenschaft `name` vom Typ `string` definiert. Dies bedeutet, dass Instanzen der `Person`-Klasse eine Eigenschaft `name` haben, die **Zeichenketten (Strings)** speichert. ### Konstruktor Der Konstruktor in TypeScript ist eine spezielle Methode, die beim Erzeugen einer Instanz (eines Objekts) einer Klasse aufgerufen wird. Sie benötigen ihn, um die **Initialisierung der Eigenschaften (Properties) eines Objekts** durchzuführen. Im Wesentlichen legt der Konstruktor den Anfangszustand einer Instanz fest. Sie können Parameter im Konstruktor angeben, um Werte bei der Instanziierung von TypeScript Classes zu übermitteln. Die grundlegende Syntax eines Konstruktors in TypeScript lautet: ```typescript class ClassName { constructor(parameter1: Type1, parameter2: Type2, ...) { } } ``` - **constructor**: Jede Klasse kann einen einzigen Konstruktor haben. Wenn kein Konstruktor definiert ist, wird standardmäßig ein leerer Konstruktor erstellt. - **parameter: Type**: Die Parameter sind optional, abhängig von der Klasse und ihren Anforderungen. Die Parameter sollten mit ihren Datentypen gekennzeichnet werden. Ein Beispiel für einen Konstruktor: ```typescript class Person { firstName: string; lastName: string; constructor(firstName: string, lastName: string) { this.firstName = firstName; this.lastName = lastName; } } ``` In unserem Beispiel hat die Klasse `Person` einen Konstruktor, der zwei Parameter `firstName` und `lastName` akzeptiert. Beim **Erstellen einer Instanz** dieser Klasse werden diese Parameter übergeben, und der Konstruktor initialisiert die Eigenschaften `firstName` und `lastName` der Instanz mit den entsprechenden Werten. Das Schlüsselwort `this` bezieht sich auf die aktuelle Instanz der Klasse, auf der der Code ausgeführt wird. ### Methoden In TypeScript sind Methoden Funktionen, die in Klassen definiert und auf deren Instanzen angewendet werden können. Methoden erlauben Ihnen, **bestimmte Aktionen oder Operationen** im Kontext einer Klasse durchzuführen. ```typescript class ClassName { // ... methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType { } // ... } ``` - **methodName**: Name der Methode - **parameter: Type**: Optionale Parameter, die die Methode akzeptiert - **ReturnType**: Dies ist der Datentyp, der bestimmt, welchen Wert die Methode zurückgibt. Wenn die Methode nichts zurückgibt, können Sie `void` angeben. Um auf eine Eigenschaft zuzugreifen oder eine Methode auf einer Instanz einer Klasse aufzurufen, benutzen Sie den Punktoperator `.`, gefolgt von dem Methodennamen und den erforderlichen Argumenten, falls die Methode Parameter erwartet. ```typescript class Person { firstName: string; lastName: string; constructor(firstName: string, lastName: string) { this.firstName = firstName; this.lastName = lastName; } getFullName(): string { return this.firstName + " " + this.lastName; } } const person = new Person("John", "Doe"); const fullName = person.getFullName(); ``` Die Methode `getFullName` dient dazu, den vollen Namen der Person zu erstellen und zurückzugeben. Sie greift auf die Werte der Eigenschaften `firstName` und `lastName` zu, die in der Klasse definiert und im Konstruktor initialisiert wurden. Das Objekt `person` wird durch das Schlüsselwort `new` gefolgt vom Klassennamen und den jeweiligen Parametern erzeugt. Die Methode **konkateniert beim Aufruf die beiden Zeichenketten** und gibt den vollen Namen als String zurück. Die Ausgabe für das Objekt `person` lautet daher „John Doe“. ## Beispiele für die Anwendung von TypeScript Classes TypeScript-Klassen besitzen verschiedene Mechanismen, um **die Struktur und das Verhalten von Objekten** zu organisieren und zu steuern. Im Folgenden stellen wir Ihnen einige Konzepte für den Einsatz von TypeScript Classes vor. ### Sichtbarkeit Sichtbarkeit in TypeScript-Klassen regelt den Zugriff auf Eigenschaften und Methoden innerhalb und außerhalb der Klasse. TypeScript bietet drei Sichtbarkeitsmodifikatoren: `public`, `private` und `protected`. - **public (Standard)**: Mit `public` gekennzeichnete Eigenschaften und Methoden können von überall, sowohl innerhalb als auch außerhalb der Klasse, aufgerufen werden. - **private**: `private` bezieht sich auf Eigenschaften und Methoden, die nur innerhalb der Klasse selbst aufgerufen werden können. Sie sind für externe Code-Teile unzugänglich. - **protected**: Mit `protected` versehene Eigenschaften und Methoden können von der Klasse selbst und von abgeleiteten Klassen (in der Vererbung) aufgerufen werden, aber nicht von externem Code. ```typescript class Person { private socialSecurityNumber: string; constructor(ssn: string) { this.socialSecurityNumber = ssn; } greet() { console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber); } } const person = new Person("123-45-6789"); person.greet(); ``` In diesem Beispiel ist `socialSecurityNumber` eine private Eigenschaft, auf die nur innerhalb der Klasse `Person` zugegriffen werden kann. Die Methode `greet` können Sie aber von außerhalb aufrufen. ### Vererbung Vererbung ist ein grundlegendes Konzept in der objektorientierten Programmierung (OOP), das in TypeScript und vielen anderen Internet-Programmiersprachen eingesetzt wird. Es ermöglicht die Schaffung einer neuen Klasse auf der Grundlage einer bestehenden **Basisklasse oder Superklasse**. Die abgeleitete Klasse (Subklasse) erbt dabei die Eigenschaften und Methoden der Basisklasse und kann diese erweitern oder anpassen. ```typescript class Animal { name: string; constructor(name: string) { this.name = name; } makeSound() { console.log("Some generic sound"); } } class Dog extends Animal { makeSound() { console.log(this.name + " barks"); } } const myDog = new Dog("Buddy"); myDog.makeSound(); ``` Hier erbt die Klasse `Dog` von der Basisklasse `Animal` mithilfe des Schlüsselworts `extends`. Die abgeleitete Klasse `Dog` überschreibt die Methode `makeSound`, um ein spezifisches Verhalten hinzuzufügen, während sie die Eigenschaft `name` von `Animal` übernimmt. ### Readonly Das `readonly`-Schlüsselwort können Sie benutzen, um Eigenschaften von TypeScript Classes oder Objekten als **schreibgeschützt** zu deklarieren. Das bedeutet, dass nach der Initialisierung einer schreibgeschützten Eigenschaft ihr Wert nicht mehr geändert werden kann. ```typescript class Circle { readonly pi: number = 3.14159; radius: number; constructor(radius: number) { this.radius = radius; } getArea() { return this.pi *this.radius* this.radius; } } const myCircle = new Circle(5); console.log(myCircle.getArea()); // Output: ≈ 78,54 ``` Die Eigenschaft `pi` ist in unserem Beispiel schreibgeschützt und wird im Konstruktor initialisiert. Nach der Initialisierung kann `pi` nicht mehr geändert werden. Wenn Sie versuchen, den Wert von `pi` nach der Initialisierung zu modifizieren, wird TypeScript einen Kompilierungsfehler generieren. This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/typescript-classes/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/typescript-classes/) for AI/LLM consumption.