TS: Extensão da categoria ES6

1. Modificadores públicos, privados e protegidos

No TypeScript, os membros das classes padrão ES6 foram estendidos, ou seja, os public,private,protected,readonlymembros podem ser modificados para limitar seus domínios de uso.

Entenda a diferença entre protegido e privado:

O membro protegido ainda pode ser acessado em sua classe derivada (subclasse);

Se o construtor estiver marcado como protegido, isso significa que essa classe não pode mais ser instanciada fora de sua classe, mas pode ser herdada:

class Person {
        
        
    protected name : string;
    protected constructor(theName : string){
        
        
        this.name = theName;
    }
}
// Employee 能够继承 Person
class Employee extends Person {
        
        
    private department: string;

    constructor(name: string, department: string) {
        
        
        super(name);	// 可以实现
        this.department = department;
    }

    public getElevatorPitch() {
        
        
        return `Hello, my name is ${
          
          this.name} and I work in ${
          
          this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");	// ok，Employee类继承了Person，拥有自己的构造方法
let john = new Person("John"); // 错误: 'Person' 的构造函数是被保护的.

2. Atributos de parâmetro

No exemplo acima, definimos um nome e um construtor cujo parâmetro é theName na classe e atribuímos theName a name. Os atributos de parâmetro podem combinar os dois;

Os atributos de parâmetro são declarados adicionando um qualificador de acesso na frente dos parâmetros do construtor.

class Person {
      
      
    constructor(readonly name : string) {
      
      };
}

3. Acessor

O TypeScript oferece suporte ao uso de getters e setters para interceptar o acesso aos membros do objeto.

Veja um exemplo de configuração de senha:

class ID {
      
      
    private _password : number;
    
    get password() : number{
      
      
        return this._password;
    }
    
    set password(oldPwd: number ,newPwd : number){
      
      
        if(oldPwd && oldPwd === _password){
      
      
            this._password = newPwd;
        }else{
      
      
            console.log("Error : old password is not valid");
        }
    }
}

4. Propriedades estáticas

Como o Java, o TypeScript também oferece suporte 类名.属性ao acesso direto a propriedades estáticas.

class Person {
      
      
    static proto : string = 'human';
}

console.log(Person.proto);	// 'human'

5. Aula abstrata

As classes abstratas são usadas como classes básicas para outras classes derivadas. Eles geralmente não são instanciados diretamente;

Como Java, os métodos abstratos de classes abstratas não precisam fornecer implementações específicas, mas devem ser implementados em classes derivadas;

abstract class Person {
      
      
    constructor(public name : string){
      
      };
   	printName() : void {
      
      
        console.log('my name is ' + this.name);
    }
    
    abstract printMeeting() : void;	// 必须在子类中实现
}

class Employee extends Person{
      
      
    constructor(){
      
      
        super('yivi');
    }
    printMeeting(): void{
      
      
        console.log('I am Employee ' + this.name);
    }
    printReports(): void{
      
      
        console.log('I am not exist');
    }
}

let p : Person;	// ok,允许创建一个对抽象类型的引用
p = new Person(); 	// error,不允许创建一个抽象类的实例’
p = new Employee();	// ok
p.printName();
p.printMeeting();
p.printReports();	//error,方法在生命的抽象类中不存在。

6. Use a classe como uma interface

Como as classes podem criar tipos com i, podemos usar classes onde as interfaces são permitidas.

class Point {
      
      
    x : number;
    y : number;
}

interface Point3D extends Point {
      
      
    z : number;
}

let point : Point3D = {
      
      
    x : 1,
    y : 2,
    z : 3
}