ABAP INTERFACE: Interfaces para programación polimórfica

Kategorie
ABAP-Statements
Veröffentlicht
Autor
Johannes

Un INTERFACE en ABAP define un contrato que las clases deben cumplir. Establece qué métodos debe proporcionar una clase, sin prescribir su implementación.

Concepto básico

  • Un Interface define solo las firmas de métodos (y opcionalmente atributos/constantes).
  • Una Clase implementa el interface y proporciona la lógica concreta.
  • Polimorfismo: Diferentes clases pueden implementar el mismo interface pero reaccionar de manera diferente.

Sintaxis

Definir interface

INTERFACE <nombre_interface>.
  METHODS: <metodo1> [IMPORTING/EXPORTING/RETURNING ...],
           <metodo2> [...].
  DATA: <atributo> TYPE <tipo>.
  CONSTANTS: <constante> TYPE <tipo> VALUE <valor>.
ENDINTERFACE.

Implementar interface en clase

CLASS <nombre_clase> DEFINITION.
  PUBLIC SECTION.
    INTERFACES: <nombre_interface>.
    " Opcional: Alias para métodos del interface
    ALIASES: <alias> FOR <nombre_interface>~<metodo>.
ENDCLASS.


CLASS <nombre_clase> IMPLEMENTATION.
  METHOD <nombre_interface>~<metodo>.
    " Implementación
  ENDMETHOD.
ENDCLASS.

Ejemplos

1. Interface simple

" Definir interface
INTERFACE lif_printable.
  METHODS: print RETURNING VALUE(rv_output) TYPE string.
ENDINTERFACE.


" Clase 1: Documento
CLASS lcl_document DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_printable.
    METHODS: constructor IMPORTING iv_title TYPE string.
  PRIVATE SECTION.
    DATA: mv_title TYPE string.
ENDCLASS.


CLASS lcl_document IMPLEMENTATION.
  METHOD constructor.
    mv_title = iv_title.
  ENDMETHOD.


  METHOD lif_printable~print.
    rv_output = |Documento: { mv_title }|.
  ENDMETHOD.
ENDCLASS.


" Clase 2: Factura
CLASS lcl_invoice DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_printable.
    METHODS: constructor IMPORTING iv_number TYPE string
                                   iv_amount TYPE p.
  PRIVATE SECTION.
    DATA: mv_number TYPE string,
          mv_amount TYPE p DECIMALS 2.
ENDCLASS.


CLASS lcl_invoice IMPLEMENTATION.
  METHOD constructor.
    mv_number = iv_number.
    mv_amount = iv_amount.
  ENDMETHOD.


  METHOD lif_printable~print.
    rv_output = |Factura { mv_number }: { mv_amount } EUR|.
  ENDMETHOD.
ENDCLASS.


" Uso con polimorfismo
DATA: lt_printables TYPE TABLE OF REF TO lif_printable,
      lo_printable  TYPE REF TO lif_printable.


" Diferentes objetos en una lista
APPEND NEW lcl_document( 'Contrato' ) TO lt_printables.
APPEND NEW lcl_invoice( iv_number = 'R-001' iv_amount = '1500.00' ) TO lt_printables.


" Tratar todos igual
LOOP AT lt_printables INTO lo_printable.
  WRITE: / lo_printable->print( ).
ENDLOOP.


" Salida:
" Documento: Contrato
" Factura R-001: 1500.00 EUR

2. Interface con Alias

Con ALIASES puede asignar nombres más cortos a métodos del interface:

INTERFACE lif_calculator.
  METHODS: calculate IMPORTING iv_a TYPE i
                               iv_b TYPE i
                     RETURNING VALUE(rv_result) TYPE i.
ENDINTERFACE.


CLASS lcl_adder DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_calculator.
    " Alias para acceso más fácil
    ALIASES: add FOR lif_calculator~calculate.
ENDCLASS.


CLASS lcl_adder IMPLEMENTATION.
  METHOD lif_calculator~calculate.
    rv_result = iv_a + iv_b.
  ENDMETHOD.
ENDCLASS.


" Uso
DATA: lo_adder TYPE REF TO lcl_adder.
lo_adder = NEW #( ).


" Con nombre completo
DATA(lv_result1) = lo_adder->lif_calculator~calculate( iv_a = 5 iv_b = 3 ).


" Con alias (más corto)
DATA(lv_result2) = lo_adder->add( iv_a = 5 iv_b = 3 ).

3. Implementar múltiples interfaces

Una clase puede implementar múltiples interfaces:

INTERFACE lif_serializable.
  METHODS: to_json RETURNING VALUE(rv_json) TYPE string.
ENDINTERFACE.


INTERFACE lif_comparable.
  METHODS: compare_to IMPORTING io_other TYPE REF TO lif_comparable
                      RETURNING VALUE(rv_result) TYPE i.
ENDINTERFACE.


CLASS lcl_product DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_serializable,
                lif_comparable.
    METHODS: constructor IMPORTING iv_id    TYPE i
                                   iv_name  TYPE string
                                   iv_price TYPE p.
    DATA: mv_id    TYPE i READ-ONLY,
          mv_name  TYPE string READ-ONLY,
          mv_price TYPE p DECIMALS 2 READ-ONLY.
ENDCLASS.


CLASS lcl_product IMPLEMENTATION.
  METHOD constructor.
    mv_id = iv_id.
    mv_name = iv_name.
    mv_price = iv_price.
  ENDMETHOD.


  METHOD lif_serializable~to_json.
    rv_json = |{ "id": { mv_id }, "name": "{ mv_name }", "price": { mv_price } }|.
  ENDMETHOD.


  METHOD lif_comparable~compare_to.
    DATA: lo_other TYPE REF TO lcl_product.
    lo_other ?= io_other.
    IF mv_price < lo_other->mv_price.
      rv_result = -1.
    ELSEIF mv_price > lo_other->mv_price.
      rv_result = 1.
    ELSE.
      rv_result = 0.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

4. Interface con constantes y atributos

INTERFACE lif_status.
  CONSTANTS: c_new       TYPE i VALUE 1,
             c_active    TYPE i VALUE 2,
             c_completed TYPE i VALUE 3,
             c_cancelled TYPE i VALUE 4.


  DATA: mv_current_status TYPE i.


  METHODS: set_status IMPORTING iv_status TYPE i,
           get_status RETURNING VALUE(rv_status) TYPE i.
ENDINTERFACE.


CLASS lcl_order DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_status.
ENDCLASS.


CLASS lcl_order IMPLEMENTATION.
  METHOD lif_status~set_status.
    lif_status~mv_current_status = iv_status.
  ENDMETHOD.


  METHOD lif_status~get_status.
    rv_status = lif_status~mv_current_status.
  ENDMETHOD.
ENDCLASS.


" Uso de constantes del interface
DATA: lo_order TYPE REF TO lcl_order.
lo_order = NEW #( ).


lo_order->lif_status~set_status( lif_status=>c_active ).

5. Herencia de interfaces (Interface compuesto)

Los interfaces pueden incluir otros interfaces:

INTERFACE lif_readable.
  METHODS: read RETURNING VALUE(rv_data) TYPE string.
ENDINTERFACE.


INTERFACE lif_writable.
  METHODS: write IMPORTING iv_data TYPE string.
ENDINTERFACE.


" Interface compuesto
INTERFACE lif_read_write.
  INTERFACES: lif_readable,
              lif_writable.
  METHODS: clear.
ENDINTERFACE.


" Una clase que implementa lif_read_write
" debe implementar todos los métodos de los tres interfaces
CLASS lcl_buffer DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_read_write.
  PRIVATE SECTION.
    DATA: mv_buffer TYPE string.
ENDCLASS.


CLASS lcl_buffer IMPLEMENTATION.
  METHOD lif_readable~read.
    rv_data = mv_buffer.
  ENDMETHOD.


  METHOD lif_writable~write.
    mv_buffer = iv_data.
  ENDMETHOD.


  METHOD lif_read_write~clear.
    CLEAR mv_buffer.
  ENDMETHOD.
ENDCLASS.

6. Inyección de dependencias con interfaces

Los interfaces permiten acoplamiento débil y mejor testeabilidad:

" Interface para acceso a base de datos
INTERFACE lif_customer_repository.
  METHODS: get_customer IMPORTING iv_id TYPE i
                        RETURNING VALUE(rs_customer) TYPE zcustomer
                        RAISING   cx_not_found.
ENDINTERFACE.


" Implementación productiva
CLASS lcl_db_customer_repository DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_customer_repository.
ENDCLASS.


CLASS lcl_db_customer_repository IMPLEMENTATION.
  METHOD lif_customer_repository~get_customer.
    SELECT SINGLE * FROM zcustomer
      WHERE id = @iv_id
      INTO @rs_customer.
    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE cx_not_found.
    ENDIF.
  ENDMETHOD.
ENDCLASS.


" Mock para Unit Tests
CLASS lcl_mock_customer_repository DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_customer_repository.
ENDCLASS.


CLASS lcl_mock_customer_repository IMPLEMENTATION.
  METHOD lif_customer_repository~get_customer.
    rs_customer = VALUE #( id = iv_id name = 'Cliente Test' ).
  ENDMETHOD.
ENDCLASS.


" El servicio usa el interface (no la clase concreta)
CLASS lcl_customer_service DEFINITION.
  PUBLIC SECTION.
    METHODS: constructor IMPORTING io_repository TYPE REF TO lif_customer_repository,
             get_customer_name IMPORTING iv_id TYPE i
                               RETURNING VALUE(rv_name) TYPE string.
  PRIVATE SECTION.
    DATA: mo_repository TYPE REF TO lif_customer_repository.
ENDCLASS.


CLASS lcl_customer_service IMPLEMENTATION.
  METHOD constructor.
    mo_repository = io_repository.
  ENDMETHOD.


  METHOD get_customer_name.
    TRY.
        DATA(ls_customer) = mo_repository->get_customer( iv_id ).
        rv_name = ls_customer-name.
      CATCH cx_not_found.
        rv_name = 'Desconocido'.
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Interface vs. Clase abstracta

AspectoInterfaceClase abstracta
Herencia múltipleSí (múltiples interfaces)No (solo una clase padre)
ImplementaciónNingunaPuede implementar parcialmente
AtributosSí (pero poco común)Sí
ConstructorNoSí
AplicaciónContratos, polimorfismoLógica base compartida

Verificación de tipo y casting

DATA: lo_object    TYPE REF TO object,
      lo_printable TYPE REF TO lif_printable.


lo_object = NEW lcl_document( 'Test' ).


" Verificar si implementa el interface
IF lo_object IS INSTANCE OF lif_printable.
  " Downcast al interface
  lo_printable ?= lo_object.
  WRITE: / lo_printable->print( ).
ENDIF.

Notas importantes / Mejores prácticas

  • Los interfaces a menudo comienzan con lif_ (local) o zif_ / if_ (global).
  • Usar interfaces para acoplamiento débil y mejor testeabilidad.
  • Preferir interfaces sobre herencia para polimorfismo.
  • Mantener interfaces pequeños y enfocados (Interface Segregation Principle).
  • Usar ALIASES para métodos de interface frecuentemente usados.
  • Las constantes de interface son útiles para códigos de estado y enumeraciones.
  • Combinar interfaces con TRY...CATCH para manejo robusto de errores.
  • Usar CLASS para la implementación de interfaces.