Modificadores de Acesso - TypeScript

Os modificadores de acesso permitem ocultar o estado de um objeto do acesso externo e gerenciar o acesso a esse estado. No TypeScript, existem três modificadores: public, protected e private.

Se nenhum modificador for aplicado às propriedades e métodos das classes, essas propriedades e métodos são considerados como se fossem definidos com o modificador public. Ou seja, a seguinte definição de classe:

class Person {
    name: string;
    year: number;
}

Será equivalente a:

class Person {
    public name: string;
    public year: number;
}

private

Se o modificador private for aplicado às propriedades e métodos, não será possível acessá-los de fora ao criar um objeto dessa classe.

Por exemplo, vamos criar uma classe com propriedades e métodos privados:

class Person {
    private _name: string;
    private _year: number;

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

    public print(): void {
        console.log(`Nome: ${this._name}  Ano de nascimento: ${this._year}`);
    }

    private setYear(age: number): number {
        return new Date().getFullYear() - age;
    }
}

let tom = new Person("Tom", 24);
tom.print();
// console.log(tom._name); // não é possível acessar, pois _name é private
// tom.setYear(45);        // não é possível acessar, pois o método é private

As duas propriedades _name e _year são declaradas com o modificador private, portanto, não podemos usá-las fora da classe, por exemplo, em console.log(tom._name). O mesmo se aplica ao método setYear(). Os demais métodos estão disponíveis.

protected

O modificador protected define campos e métodos que são visíveis apenas em classes derivadas, não podendo ser acessados de fora da classe:

class Person {
    protected name: string;
    private year: number;

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

    protected printPerson(): void {
        console.log(`Nome: ${this.name}  Ano de nascimento: ${this.year}`);
    }

    private setYear(age: number): number {
        return new Date().getFullYear() - age;
    }
}

class Employee extends Person {
    protected company: string;

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

    public printEmployee(): void {
        // console.log("Year: " + this.year); // não disponível, pois year é private
        // this.setYear(25);                  // não disponível, pois setYear é private
        this.printPerson();                   // disponível, pois printPerson é protected
        console.log(`Empresa: ${this.company}`);
    }
}

let sam = new Employee("Sam", 31, "Microsoft");
sam.printEmployee();

Na classe Employee, o campo name e o método printPerson() estão disponíveis, pois possuem o modificador protected. Porém, a propriedade privada year e o método privado setYear() não estão acessíveis.

Definindo campos através do construtor

O uso de modificadores nos parâmetros do construtor permite reduzir a quantidade de código escrita. Por exemplo, suponha que temos a seguinte classe:

class Person {
    private name: string;
    private age: number;

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

    printPerson(): void {
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
}

Essa classe é equivalente à seguinte:

class Person {
    constructor(private name: string, private age: number) {}

    printPerson(): void {
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
}

Ao usar modificadores nos parâmetros do construtor, não precisamos mais criar explicitamente propriedades para esses parâmetros. As propriedades são criadas automaticamente, recebem o nome dos parâmetros e possuem os mesmos modificadores.

Da mesma forma, se quisermos tornar as propriedades públicas, devemos usar o modificador public:

class Person {
    constructor(public name: string, public age: number) {}

    printPerson(): void {
        console.log(`Nome: ${this.name}  Idade: ${this.age}`);
    }
}

Se for necessário tornar o campo somente leitura, adiciona-se o modificador readonly ao modificador de acesso:

class Person {
    constructor(private readonly name: string, private age: number) {}
}