Qué son los modificadores de acceso en TypeScript

Los modificadores de acceso son palabras clave que se utilizan para controlar la visibilidad y accesibilidad de las propiedades y métodos dentro de una clase.

Estos modificadores permiten definir qué partes de una clase pueden ser accedidas desde fuera de la clase y cuáles deben permanecer ocultas, facilitando la encapsulación y el diseño más seguro del código.

Los tres principales modificadores de acceso disponibles en TypeScript: son public, private y protected.

Modificador public

El modificador public es el valor predeterminado en TypeScript y permite que las propiedades y métodos sean accesibles desde cualquier parte del código.

Esto significa que se pueden leer y modificar desde fuera de la clase en la que están definidos.

class Estudiante {
    public nombre: string;
    public edad: number;

    constructor(nombre: string, edad: number) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public mostrarInfo(): void {
        console.log(`Nombre: ${this.nombre}, Edad: ${this.edad}`);
    }
}

const estudiante = new Estudiante("Carlos", 21);
console.log(estudiante.nombre);  // Acceso público
estudiante.mostrarInfo();        // Método público

Modificador private

El modificador private oculta las propiedades y métodos de una clase, de modo que solo puedan ser accedidos y modificados desde dentro de la propia clase.

Los miembros private no son accesibles desde fuera de la clase ni desde sus clases derivadas.

class CuentaBancaria {
    private saldo: number;

    constructor(saldoInicial: number) {
        this.saldo = saldoInicial;
    }

    public mostrarSaldo(): void {
        console.log(`Saldo: ${this.saldo}`);
    }

    public depositar(cantidad: number): void {
        if (cantidad > 0) {
            this.saldo += cantidad;
        }
    }
}

const cuenta = new CuentaBancaria(1000);
cuenta.mostrarSaldo();    // Salida: Saldo: 1000
cuenta.depositar(500);
cuenta.mostrarSaldo();    // Salida: Saldo: 1500

console.log(cuenta.saldo);  // Error: Property 'saldo' is private and only accessible within class 'CuentaBancaria'.

Modificador protected

El modificador protected permite que las propiedades y métodos sean accesibles dentro de la clase en la que están definidos y en sus clases derivadas, pero no desde fuera de estas clases.

Esto es útil para permitir que las clases derivadas accedan a miembros que no deberían ser públicos.

class Vehiculo {
    protected marca: string;

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

class Coche extends Vehiculo {
    public modelo: string;

    constructor(marca: string, modelo: string) {
        super(marca);
        this.modelo = modelo;
    }

	// la clase coche puede usar .marca
    public mostrarDetalles(): void {
        console.log(`Marca: ${this.marca}, Modelo: ${this.modelo}`);
    }
}

const coche = new Coche("Toyota", "Corolla");
coche.mostrarDetalles();  // Salida: Marca: Toyota, Modelo: Corolla

// el programa no puede usar marca directamente
console.log(coche.marca);  // Error: Property 'marca' is protected and only accessible within class 'Vehiculo' and its subclasses.