TypeScript: Herança e Polimorfismo (TypeScript: 继承与多态)

Herança (继承)

Herança é quando uma classe estende outra e herda seus membros: 继承是指一个类扩展另一个类并继承其成员：

class EntidadeBase {
  constructor(
    public id: string,
    public criadoEm: Date = new Date()
  ) {}

  toString(): string {
    return `[${this.id}]`;
  }
}

class EventoFiscal extends EntidadeBase {
  constructor(
    id: string,
    public tenantId: string,
    public competencia: string
  ) {
    super(id); // obrigatório chamar super (必须调用 super)
  }
}

class EventoReinf extends EventoFiscal {
  constructor(
    id: string,
    tenantId: string,
    competencia: string,
    public codigoEvento: string
  ) {
    super(id, tenantId, competencia);
  }
}

Polimorfismo (多态)

Polimorfismo é a capacidade de tratar objetos de tipos diferentes de forma uniforme através de um tipo base: 多态是指通过基类以统一的方式处理不同类型对象的能力：

abstract class TransmissorFiscal {
  abstract transmitir(payload: unknown): Promise<Protocolo>;
}

class TransmissorReinf extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    return api.post("/reinf", payload);
  }
}

class TransmissorEFinanceira extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    return api.post("/efinanceira", payload);
  }
}

// função que aceita qualquer transmissor — polimorfismo
// 接受任何传输器的函数 — 多态
async function executarTransmissao(
  transmissor: TransmissorFiscal,
  payload: unknown
) {
  return transmissor.transmitir(payload); // não importa qual é (无论具体是哪种实现)
}

// chamadas polimórficas (多态调用)
executarTransmissao(new TransmissorReinf(), payload);
executarTransmissao(new TransmissorEFinanceira(), payload);

O código que usa TransmissorFiscal não precisa saber qual implementação está recebendo — isso é o coração do polimorfismo. 使用 TransmissorFiscal 的代码无需知道它接收的是哪种具体实现——这就是多态的核心。