o TypeScript, os modificadores de acesso controlam a visibilidade de membros de classes, como propriedades e métodos. Eles definem quais partes do código podem acessar esses membros.
Public:
O modificador padrão em TypeScript.
Permite que membros sejam acessados por qualquer classe, dentro ou fora da classe em que foram declarados.
Exemplo:
class Pessoa {
public nome: string; // Propriedade pública
constructor(nome: string) {
this.nome = nome;
}
public falar(): void {
console.log(`Olá, meu nome é ${this.nome}`);
}
}
const pessoa1 = new Pessoa('João');
console.log(pessoa1.nome); // Acessando propriedade pública
pessoa1.falar(); // Acessando método público
Private:
Restringe o acesso do membro à classe em que foi declarado.
Exemplo:
class ContaBancaria {
private saldo: number; // Propriedade privada
constructor(saldoInicial: number) {
this.saldo = saldoInicial;
}
public sacar(valor: number): void {
if (valor > this.saldo) {
console.error('Saldo insuficiente');
return;
}
this.saldo -= valor;
console.log(`Saque de R$${valor} realizado com sucesso. Saldo atual: R$${this.saldo}`);
}
// O método 'getSaldo' não tem o modificador 'public', então ele é privado
private getSaldo(): number {
return this.saldo;
}
}
const conta1 = new ContaBancaria(1000);
conta1.sacar(500); // Acessando método público
// conta1.saldo; // Erro: 'saldo' é privado e não pode ser acessado fora da classe
Protected:
Semelhante ao private, mas permite acesso de classes derivadas.
Exemplo:
TypeScript
class Animal {
protected nome: string; // Propriedade protegida
constructor(nome: string) {
this.nome = nome;
}
public falar(): void {
console.log(`Eu sou um animal e meu nome é ${this.nome}`);
}
}
class Cachorro extends Animal {
constructor(nome: string) {
super(nome);
}
public latir(): void {
console.log(`Au au! Meu nome é ${this.nome}`);
}
}
const cachorro1 = new Cachorro('Rex');
cachorro1.falar(); // Acessando método público herdado
cachorro1.latir(); // Acessando método próprio
Abstract:
Não define implementação, apenas declara um método que deve ser implementado em classes derivadas.
Classes abstratas não podem ser instanciadas diretamente.
Exemplo:
TypeScript
abstract class FiguraGeometrica {
abstract calcularArea(): number; // Método abstrato
public desenhar(): void {
console.log('Desenhando figura geométrica...');
}
}
class Retangulo extends FiguraGeometrica {
private base: number;
private altura: number;
constructor(base: number, altura: number) {
super();
this.base = base;
this.altura = altura;
}
public calcularArea(): number {
return this.base * this.altura;
}
}
const retangulo1 = new Retangulo(5, 7);
console.log(retangulo1.calcularArea()); // Acessando método implementado na classe derivada
retangulo1.desenhar(); // Acessando método herdado
| Modificado | Visibilidade | Detalhes |
|---|---|---|
| public | Acessível em qualquer lugar | Padrão para membros de classe |
| private | Somente dentro da classe | Maior encapsulamento |
| protected | Dentro da classe e classes derivadas | Promove reuso em herança |
| abstract | Sem implementação | Define um contrato para classes derivadas |
Dica :
Lembre-se de escolher o modificador de acesso adequado para cada membro da classe, considerando o nível de encapsulamento e reuso desejado.
Fontes
github.com/Mcps4/ifpi-ads-eng3-2022
https://pt.stackoverflow.com/questions/559723/quais-as-diferen%C3%A7as-entre-modificadores-public-private-protected-e-abstract-no
Source link
lol
