Einführung in erweiterte Klassenfeatures

TypeScript bietet mehrere erweiterte Klassenfeatures, mit denen Sie modularen, skalierbaren und wartbaren objektorientierten Code schreiben können.

In dieser Lektion lernen Sie Zugriffsmodifizierer, abstrakte Klassen, statische Member und mehr kennen.

Einführung in erweiterte Klassenfeatures

TypeScript bietet mehrere erweiterte Klassenfeatures, mit denen Sie modularen, skalierbaren und wartbaren objektorientierten Code schreiben können.

In dieser Lektion lernen Sie Zugriffsmodifizierer, abstrakte Klassen, statische Member und mehr kennen.

Zugriffsmodifizierer

TypeScript stellt drei Zugriffsmodifizierer bereit, um die Sichtbarkeit von Klassenmitgliedern zu steuern:

• public: Überall zugänglich (Standard).
• private: Nur innerhalb der Klasse zugänglich.
• protected: Innerhalb der Klasse und ihrer Unterklassen zugänglich.

class Person {
  public name: string;
  private age: number;
  protected role: string;

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

class Employee extends Person {
  getRole(): string {
    return this.role; // Accessible because it's protected
  }
}

Abstrakte Klassen

Abstrakte Klassen dienen als Vorlagen für andere Klassen. Sie können nicht direkt instanziiert werden und dürfen abstrakte Methoden enthalten.

abstract class Shape {
  abstract getArea(): number;
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

const circle = new Circle(5);
console.log(circle.getArea()); // 78.54

Statische Member

Statische Member gehören zur Klasse selbst und nicht zu einer Instanz der Klasse. Der Zugriff erfolgt über den Klassennamen.

class MathUtils {
  static PI = 3.14;

  static calculateCircleArea(radius: number): number {
    return this.PI * radius ** 2;
  }
}

console.log(MathUtils.PI); // 3.14
console.log(MathUtils.calculateCircleArea(5)); // 78.5

Getter und Setter

Getter und Setter ermöglichen es Ihnen, zu steuern, wie auf Eigenschaften in einer Klasse zugegriffen und wie sie geändert werden.

class Person {
  private _name: string;

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

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

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

const person = new Person('Alice');
console.log(person.name); // Alice
person.name = 'Bob';
console.log(person.name); // Bob

Schreibgeschützte Eigenschaften

Der Modifizierer readonly stellt sicher, dass eine Eigenschaft nur während der Initialisierung gesetzt und später nicht mehr geändert werden kann.

class Vehicle {
  readonly make: string;

  constructor(make: string) {
    this.make = make;
  }
}

const car = new Vehicle('Toyota');
console.log(car.make); // Toyota
// car.make = 'Honda'; // Error: Cannot assign to 'make' because it is a read-only property.

Private und protected Konstruktoren

Klassen können private oder protected Konstruktoren besitzen, um zu steuern, wie und wo sie instanziiert werden.

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  static getInstance(): Singleton {
    if (!this.instance) {
      this.instance = new Singleton();
    }
    return this.instance;
  }
}

const singleton = Singleton.getInstance();
console.log(singleton);

Übungsaufgabe

Erstellen Sie eine Klasse mit einem protected-Konstruktor und leiten Sie eine Unterklasse davon ab. Fügen Sie Methoden hinzu, um in der Unterklasse auf die geschützten Eigenschaften zuzugreifen.

Herzlichen Glückwunsch!

Sie haben fortgeschrittene Klassenfunktionen wie Zugriffsmodifizierer, abstrakte Klassen, statische Member und vieles mehr gelernt. Üben Sie diese Konzepte, um sauberen und effizienten objektorientierten TypeScript-Code zu schreiben!