Olá pessoal, tudo bem ?

Hoje vou falar um pouco sobre o programação orientada a objetos (POO) dentro da linguagem ADVPL.

O ADVPL é uma linguagem baseada no Clipper, sendo assim, uma linguagem estruturada.

Com a evolução das linguagens, a TOTVS buscou aprimorar sua linguagem, e com o passar do tempo, e trouxe a orientação a objetos para dentro do ADVPL.

Então, como todas as linguagens POO, ela possui Classes, Propriedades, Métodos, Herança, Encapsulamento, Polimorfismo e Abstração.

Vou explicar um pouco de cada parte do conceito de POO na linguagem ADVPL.

Primeiramente vamos começar com a definição da classe.

#INCLUDE 'TOTVS.CH'
/*/-----------------------------------------------------------
{Protheus.doc} ExemploClass
Classe de exemplo ADVPL

Uso: Geral

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
CLASS ExemploClass From LongClassName
  
  // Defina os parâmetros que sua classe deverá possuir
  Data cPropStr
  Data nPropNum
  Data dPropData
  Data oPropObj
  Data aPropArray
  Data lActive
  
  METHOD New() CONSTRUCTOR
  METHOD Activate()
  METHOD Deactivate()
  METHOD Executar()
  // Demais métodos pertinentes a sua classe 
  
ENDCLASS

Nesta primeira primeira parte de definição da classe vamos colocar o nome da classe logo após a palavra reservada CLASS e o nome da classe pai que nossa classe vai herdar após a palavra reservada From.

Como não estamos herdando essa classe de nenhuma classe especifica vamos herdar a classe LongClassName que permite a utilização de nomes longos.

Logo abaixo começamos a definir as propriedades da classe, utilizando a palavra reservada Data, seguido do nome da propriedade.

Logo abaixo vamos definir as assinaturas dos métodos existentes em nossa classe. Repare que definimos um método New que será o construtor da nossa classe, utilizando a palavra reservada CONSTRUCTOR.

E por fim, encerramos a definição da classe utilizando a palavra reservada ENDCLASS.

Com nossa classe definida, começamos a realizar a construção de nossos métodos dentro da classe.

Primeiramente vamos definir o método construtor e  entender sua importância.

/*/-----------------------------------------------------------
{Protheus.doc} New()
Construtor da classe

Uso: ExemploClass

@sample
//ExemploClass():New()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD New() CLASS ExemploClass

  ::cPropStr      := " "
  ::nPropNum      := 0
  ::dPropData     := Date()
  Self:oPropObj   := NIL
  Self:aPropArray := {}
  Self:lActive    := .F.

Return Self

O método New, é importante para a iniciação base das propriedades da classe, ou seja seus valores default, desta forma vamos garantir a integridade do funcionamento da classe.

Também podemos definir a obrigatoriedade do preenchimento dos parâmetros da classe, obrigando a passagem deles por parâmetro do método. Isso deve ser feito da mesma forma que é feito em uma função comum do ADVPL.

Muito importante que o retorno deste método seja a palavra reservada Self, que representa o objeto da instância da nossa classe.

Ou seja nosso método New tem a função de criar a instância em que iremos trabalhar, possibilitando a utilização de todos os métodos e propriedades existentes em nossa classe.

Note que para manipularmos ou acessarmos propriedades de dentro de nossa classe podemos utilizar a palavra reservada Self ou ::, as duas formas indicam que estamos acessando propriedades ou métodos de nossa classe corrente. Isso só pode ser utilizado dentro do escopo da classe, ou seja, dentro dos métodos da mesma.

Outros métodos importantes de utilizamos são os métodos Activate e o Deactivate.

Com o método Activate podemos definir que nossa classe esta pronta para executar determinados métodos e realizar uma pré-validação de suas execução.

E o método Deactivate é importante para realizarmos a destruição dos objetos e informações correntes, já que o ADVPL não destrói essas informações automáticamente, deixando as mesmas em memória até a finalização da thread corrente.

Vamos defini-los :

/*/-----------------------------------------------------------
{Protheus.doc} Activate()
Ativa a classe

Uso: ExemploClass

@sample
//ExemploClass():Activate()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Activate() CLASS ExemploClass
  
  If !Empty(::cPropStr) .AND. ::nPropNum > 0
    ::lActive := .T.
  EndIf
Return ::lActive

/*/-----------------------------------------------------------
{Protheus.doc} Deactivate()
Desativa a classe

Uso: ExemploClass

@sample
//ExemploClass():Deactivate()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Deactivate() CLASS ExemploClass
    
    If ::oPropObj <> NIL 
        ::oPropObj:DeActivate()  
        FreeObj(::oPropObj)
        ::oPropObj := Nil	
    EndIf
    
    ::lActive := .F.
Return

Vamos agora criar um exemplo de métodos de execução:

/*/-----------------------------------------------------------
{Protheus.doc} Executar()
Método exemplo de execução na classe.

Uso: ExemploClass

@sample
//ExemploClass():Executar()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Executar() CLASS ExemploClass
  Local cRet := ""
    
  If ::lActive 
     If ::nPropNum > 10 
       cRet := "Data de Execução do método - " + DTOS(dPropData) + "Texto: "+ ::cPropStr
     Else
       cRet := " Propriedade numerica é menor ou igual a 10 "
     EndIf
  Else
    cRet := "A Classe não está ativa"
  EndIf
    
Return cRet

No exemplo a seguir vamos aprender a instanciar e executar métodos da classe.

/*/-----------------------------------------------------------
{Protheus.doc} ExecClas()
Utilizando classe de Exemplo 

Uso: ExemploClass

@sample
//U_ExecClas()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
User Function ExecClas()
  Local oObjClass  := NIL
  Local cTextoRet  := ""
  
   // Cria instancia da classe 
   oObjClass := ExemploClass():New() 
   
   // Preenche propriedades 
   oObjClass:cPropStr := "Teste 1"
   oObjClass:nPropNum := 20
   
   // Ativa a classe
   oObjClass:Activate()
   
   // Executa métodos
   cTextoRet := oObjClass:Executar() 
   Conout(cTextoRet)
   
   // Desativa e destroi a classe
   oObjClass:Deactivate()
   FreeObj(oObjClass)
   oObjClass := NIL
    
Return

Com essas estruturas podemos definir os métodos que quisermos e compartilhar as propriedades existentes na classe, entre eles.

Tenho certeza que com a utilização da orientação a objetos você vai economizar e reutilizar muitos códigos em seus futuros desenvolvimentos.

Espero que gostem…

Até a próxima!!!