What are access modifiers in TypeScript

Access modifiers are keywords used to control the visibility and accessibility of properties and methods within a class.

These modifiers allow you to define which parts of a class can be accessed from outside the class and which should remain hidden, facilitating encapsulation and safer code design.

The three main access modifiers available in TypeScript are public, private, and protected.

Public Modifier

The public modifier is the default in TypeScript and allows properties and methods to be accessible from anywhere in the code.

This means they can be read and modified from outside the class in which they are defined.

class Student {
    public name: string;
    public age: number;

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

    public showInfo(): void {
        console.log(`Name: ${this.name}, Age: ${this.age}`);
    }
}

const student = new Student("Carlos", 21);
console.log(student.name);  // Public access
student.showInfo();        // Public method

In this example, both the properties name and age, as well as the method showInfo, are public, meaning they can be accessed and used outside the Student class.

Private Modifier

The private modifier hides the properties and methods of a class so that they can only be accessed and modified from within the class itself.

private members are not accessible from outside the class or from its derived classes.

class BankAccount {
    private balance: number;

    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }

    public showBalance(): void {
        console.log(`Balance: ${this.balance}`);
    }

    public deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
        }
    }
}

const account = new BankAccount(1000);
account.showBalance();    // Output: Balance: 1000
account.deposit(500);
account.showBalance();    // Output: Balance: 1500

console.log(account.balance);  // Error: Property 'balance' is private and only accessible within class 'BankAccount'.

Here, the property balance is private, which means it cannot be accessed directly from outside the BankAccount class. Only the class methods, like deposit and showBalance, can access and modify balance.

Protected Modifier

The protected modifier allows properties and methods to be accessible within the class they are defined in and in their derived classes, but not from outside these classes.

This is useful to allow derived classes to access members that should not be public.

class Vehicle {
    protected brand: string;

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

class Car extends Vehicle {
    public model: string;

    constructor(brand: string, model: string) {
        super(brand);
        this.model = model;
    }

    // the car class can use .brand
    public showDetails(): void {
        console.log(`Brand: ${this.brand}, Model: ${this.model}`);
    }
}

const car = new Car("Toyota", "Corolla");
car.showDetails();  // Output: Brand: Toyota, Model: Corolla

// the program cannot use brand directly
console.log(car.brand);  // Error: Property 'brand' is protected and only accessible within class 'Vehicle' and its subclasses.

In this example, the property brand is protected, so it can only be accessed within the Vehicle class and its derived classes, like Car. It is not accessible from outside these classes.