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!!!