Exibir origem

import.css=/download/attachments/327912/newLayout.css

Objetos em TLPP podem utilizar métodos polimórficos.

Por definição, todos os métodos em TLPP são do tipo virtual.

Métodos redefinidos na classe filha tem a capacidade de mudar o comportamento da implementação feita na classe pai.

A redefinição é simples. Basta que a classe filha tenha um método com o mesmo nome que está na classe pai.

Nesse caso, quando o método é chamado em qualquer lugar da hierarquia de classes, ele assume o comportamento definido pelo objeto efetivamente instanciado.

#include "tlpp-core.th"

namespace test.tlpp.example.polymorphism

Class A
  public method New()
  // Eu vou responder com o nome da classe que está instanciada
  public method instanceOf() as character
  // E eu vou perguntar de quem é a instância
  public method whoami() as character
EndClass

Class B from A
  public method New()
  public method whoami() as character
EndClass

Class C from B
  public method New()
  public method whoami() as character
EndClass

// Os construtores A, B, C
// ---------------------------------------------------

method new() class A
Return self

method new() class B
Return self

method new() class C
Return self


// O instanceOf, somente implementado em A
// ---------------------------------------------------

method instanceof() class A
Local cWho := ::whoami() // quem vai ser chamado ? 
Return cWho



// Os três whoami, cada um com o seu comportamento
// ---------------------------------------------------

method whoami() class A
Return "class A"

method whoami() class B
Return "class B"

method whoami() class C
Return "class C"


// Quando for testar, me chame assim: test.tlpp.example.polymorphism.u_test01()
// --------------------------------------------------------------------------------

Function u_test01()

  Local objA, objB, objC as Object

  // Um objeto de cada classe
  objA := A():New()
  objB := B():New()
  objC := C():New()

  // Vamos ver as respostas polimórficas?
  Conout(objA:instanceOf()) // A resposta será 'class A'
  Conout(objB:instanceOf()) // A resposta será 'class B'
  Conout(objC:instanceOf()) // A resposta será 'class C'

  /** Lembre-se que o segredo está na função polimórfica whoami **/

Return .T.

Resultado do Exemplo

4