Desenvolvimento Código Aberto

Os objetos definem sua interação com o mundo exterior através dos métodos que eles expõem. Métodos formam a interface do objeto com o mundo exterior; os botões na parte frontal do seu aparelho de televisão, por exemplo, são a interface entre você e a fiação elétrica do outro lado do seu invólucro de plástico. Você aperta o botão “Power” para ligar e desligar a televisão.

Na sua forma mais comum, uma interface é um conjunto de métodos relacionados com corpos vazios

A implementação de uma interface permite que uma classe se torne mais formal sobre o comportamento que promete proporcionar. Interfaces formam um contrato entre a classe e o mundo exterior, e este contrato é imposto em tempo de compilação.

Se sua classe reivindica implementar uma interface, todos os métodos definidos por essa interface deve aparecer em seu código-fonte antes da classe ser compilada com sucesso.

Em ABAP  a palavra chave interface é realmente levada ao pé da letra, obrigando o programador a referenciar a interface na instrução entre o objeto e o método.

Sintaxe:

CALL METHOD Objeto->Interface~Método.

Lembrando que a interface obriga a classe na qual foi implementada a cumprir o que nela foi declarado. Caso não cumpra o determinado pela interface obterá o seguinte erro de compilação:

Erro: Implementention missing for method “Interface~Method”.

Conceito de interfaces

• Não pode ser instanciada.
• Só pode possuir assinaturas de métodos de instância, públicos e abstratos (sem corpo).
• Não pode possuir métodos concretos (com corpo), nem métodos estáticos.

Uso Comum de Interface

Já que sabemos que os objetos Abap são baseados em C++ e Java, vamos fazer uma curta analogia para que você entenda perfeitamente o uso de interfaces. As classes Abap separam a implementação da definição, assim como C++, mas também assim como Java não permitem heranças múltiplas.

Na linguagem de programação C++ pode se utilizar uma interface abstrata, mas este uso não é muito comum, pois a convenção de classes C++ já contempla que a interface seja separada da implementação na criação da própria classe, utilizando arquivos diferentes (.h e .cpp). Além da linguagem C++ permitir múltiplas heranças tornando raro a necessidade do uso de interfaces abstratas.

Java e Abap utilizam a interface pois não permitem múltiplas heranças, então a interface se torna necessária para criar um efeito deste tipo, por exemplo, imagine que temos a classe Casa e queremos que esta classe herde as classes Portas e Janelas, isto não será possível em Java e Abap, mas é possível em C++.

Para garantir que teremos os métodos paras portas e janelas na classe Casa, precisamos utilizar a interface Portas e a Interface Janelas, ainda não garantindo como em C++ os tipos de portas e janelas já que as interfaces são abstratas e não métodos concretos, Mas este recurso permite que a classe Casa tenha obrigatoriamente, portas e janelas de qualquer tipo.

Este também é o motivo de uso de uma interface abstrata em C++, quando queremos métodos abstratos para uma classe dizendo que você permite portas e janelas de qualquer tipo. Nota-se assim que C++ é uma linguagem mais flexível em termos de recursos na criação de objetos

Exemplo:

Neste exemplo simulamos um programa de I/O de arquivos, criamos uma interface contendo os métodos obrigatórios para qualquer classe, que reivindicar a interface:

Abap

*&---------------------------------------------------------------------*
*& Report  ZINTERFACE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Interfaces
*&---------------------------------------------------------------------*

REPORT  ZINTERFACE.

* Declara Interface

INTERFACE Acao.

   METHODS :
          ABRE   IMPORTING ARQUIVO TYPE STRING,
          GRAVA  IMPORTING ARQUIVO TYPE STRING,
          DELETA IMPORTING ARQUIVO TYPE STRING.

ENDINTERFACE.

* Declara Classe

CLASS ARQUIVO DEFINITION.

   PUBLIC SECTION.

      INTERFACES ACAO.

ENDCLASS.

* Declara Implementação da Classe

CLASS ARQUIVO IMPLEMENTATION.

   METHOD ACAO~ABRE.

      " ... Implementa método para abrir o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'em uso'.

   ENDMETHOD.

   METHOD ACAO~GRAVA.

      " ... Implementa método para gravar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Gravado com sucesso'.

   ENDMETHOD.

   METHOD ACAO~DELETA.

      " ... Implementa método para deletar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Deletado com sucesso'.

   ENDMETHOD.

ENDCLASS.

* Cria Objetos

START-OF-SELECTION.
DATA ARQ1 TYPE REF TO ARQUIVO.
CREATE OBJECT ARQ1.

ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~GRAVA( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~DELETA( EXPORTING ARQUIVO = 'Texto.txt' ).

* ou

CALL METHOD ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
* ...