Geavanceerde klassenfuncties

TypeScript biedt verschillende geavanceerde functies voor klassen waarmee je modulaire, schaalbare en onderhoudbare objectgeoriënteerde code kunt schrijven.

In deze les leer je meer over toegangsmodificatoren, abstracte klassen, statische leden en meer.

Inleiding tot geavanceerde klassenfuncties

TypeScript biedt verschillende geavanceerde functies voor klassen waarmee je modulaire, schaalbare en onderhoudbare objectgeoriënteerde code kunt schrijven.

In deze les leer je meer over toegangsmodificatoren, abstracte klassen, statische leden en meer.

TypeScript biedt drie toegangsmodificatoren om de zichtbaarheid van leden van een klasse te regelen:

• public: overal toegankelijk (standaard).
• private: alleen toegankelijk binnen de klasse.
• protected: toegankelijk binnen de klasse en de subklassen ervan.

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
  }
}

Abstracte klassen dienen als blauwdruk voor andere klassen. Je kunt ze niet rechtstreeks instantiëren en ze kunnen abstracte methoden bevatten.

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 leden behoren tot de klasse zelf en niet tot een instantie van de klasse. Je benadert ze met de naam van de klasse.

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

Met getters en setters kun je bepalen hoe eigenschappen in een klasse worden benaderd of aangepast.

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

De modificator readonly zorgt ervoor dat een eigenschap alleen tijdens de initialisatie kan worden ingesteld en daarna niet meer kan worden aangepast.

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.

Klassen kunnen private of protected constructors hebben om te bepalen hoe en waar ze worden geïnstantieerd.

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);

Maak een klasse met een protected-constructor en breid die uit in een subklasse. Voeg methoden toe om toegang te krijgen tot de beschermde eigenschappen in de subklasse.

Je hebt geavanceerde klassenfuncties geleerd, zoals toegangsmodificatoren, abstracte klassen, statische leden en meer. Oefen deze concepten om nette en efficiënte objectgeoriënteerde TypeScript-code te schrijven!