Introduction to Advanced Class Features

TypeScript offers several advanced class features that help you write modular, scalable, and maintainable object-oriented code.

In this lesson, you'll learn about access modifiers, abstract classes, static members, and more.

Introduction to Advanced Class Features

TypeScript offers several advanced class features that help you write modular, scalable, and maintainable object-oriented code.

In this lesson, you'll learn about access modifiers, abstract classes, static members, and more.

Access Modifiers

TypeScript provides three access modifiers to control the visibility of class members:

• public: Accessible anywhere (default).
• private: Accessible only within the class.
• protected: Accessible within the class and its subclasses.

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

Abstract Classes

Abstract classes are used as blueprints for other classes. They cannot be instantiated directly and may include abstract methods.

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

Static Members

Static members belong to the class itself rather than any instance of the class. They are accessed using the class name.

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

Getters and Setters

Getters and setters allow you to control how properties are accessed or modified in a class.

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

Readonly Properties

The readonly modifier ensures that a property can only be set during initialization and not modified later.

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 and Protected Constructors

Classes can have private or protected constructors to control how and where they are instantiated.

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

Practice Task

Create a class with a protected constructor and extend it in a subclass. Add methods to access the protected properties in the subclass.

Congratulations!

You’ve learned advanced class features like access modifiers, abstract classes, static members, and more. Practice these concepts to write clean and efficient object-oriented TypeScript code!