So verwenden Sie TypeScript-Klassen mit einfachen Beispielen

TypeScript ergänzt JavaScript um leistungsstarke Funktionen, darunter das Konzept der Klassen, das objektorientierte Programmierung ermöglicht. Klassen bieten eine Blaupause für die Erstellung von Objekten, die Einkapselung von Daten und die Definition von Verhaltensweisen. Dieser Leitfaden führt Sie anhand einfacher Beispiele durch die Grundlagen von TypeScript-Klassen.

Was ist eine Klasse?

Eine Klasse ist eine Blaupause zum Erstellen von Objekten mit vordefinierten Eigenschaften und Methoden. Sie hilft beim Organisieren von Code, fördert die Wiederverwendbarkeit und erstellt skalierbare Anwendungen. Klassen in TypeScript funktionieren ähnlich wie Klassen in anderen objektorientierten Programmiersprachen.

Definieren einer Basisklasse

Um eine Klasse in TypeScript zu definieren, verwenden Sie das Schlüsselwort class, gefolgt vom Klassennamen und einer Reihe geschweifter Klammern, die Eigenschaften und Methoden enthalten.

Beispiel einer Basisklasse

Unten sehen Sie ein Beispiel einer einfachen Person-Klasse mit Eigenschaften und einer Methode:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person("Alice", 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

In diesem Beispiel hat die Klasse Person zwei Eigenschaften: name und age. Die Konstruktormethode initialisiert diese Eigenschaften und die Methode greet gibt eine Begrüßungsnachricht aus.

Zugriffsmodifizierer

TypeScript bietet drei Zugriffsmodifikatoren, um die Sichtbarkeit von Klassenmitgliedern zu steuern:

• public: Mitglieder sind von überall erreichbar (Standard).
• private: Mitglieder sind nur innerhalb der Klasse zugänglich.
• protected: Auf die Mitglieder kann innerhalb der Klasse und ihrer Unterklassen zugegriffen werden.

Verwenden von Zugriffsmodifizierern

So können Sie Zugriffsmodifikatoren in einer TypeScript-Klasse verwenden:

class Animal {
  public name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

In diesem Beispiel ist Name eine öffentliche Eigenschaft, auf die von außerhalb der Klasse zugegriffen werden kann, während Alter eine private Eigenschaft ist, auf die nur innerhalb der Klasse zugegriffen werden kann.

Vererbung in TypeScript

TypeScript unterstützt Vererbung, wodurch eine Klasse Eigenschaften und Methoden von einer anderen Klasse erben kann. Dies hilft bei der Wiederverwendung von Code und beim Erstellen einer Klassenhierarchie.

Vererbungsbeispiel

Unten sehen Sie ein Beispiel einer Klasse Hund, die von einer Basisklasse Tier erbt:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

In diesem Beispiel erweitert die Klasse Dog die Klasse Animal und überschreibt die Methode makeSound.

Getter und Setter

Mit TypeScript können Sie Getter und Setter für Eigenschaften definieren und so einen kontrollierten Zugriff auf Klassenmitglieder ermöglichen.

Beispiel für Getter und Setter

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

In diesem Beispiel wird auf die Eigenschaft name mit Getter- und Setter-Methoden zugegriffen und sie wird geändert.

Abschluss

TypeScript-Klassen sind eine leistungsstarke Möglichkeit, objektorientierten Code sauber und effizient zu schreiben. Sie bieten eine strukturierte Möglichkeit, Eigenschaften, Methoden, Zugriffsmodifikatoren, Vererbung und mehr zu definieren. Wenn Sie verstehen, wie Sie TypeScript-Klassen verwenden, können Sie robusteren und wartungsfreundlicheren Code für Ihre Anwendungen schreiben.