parámetros de un método en abap

Parámetros en métodos de ABAP

Cuando defines un método en ABAP, una de las decisiones más importantes que tomarás es cómo va a comunicarse con el exterior. ¿Qué datos necesita recibir? ¿Qué datos va a devolver? ¿Cómo gestionará los errores?

Los parámetros son el mecanismo que permite todo esto. Elegir correctamente cada tipo de parámetro es fundamental para escribir código claro, mantenible y robusto.

En este artículo vamos a ver:

  • Qué tipos de parámetros existen en ABAP
  • Para qué sirve cada uno
  • Cuándo usarlos (y cuándo NO)
  • Buenas prácticas para aplicarlos correctamente

¿Qué son los parámetros de un método?

Los parámetros son los mecanismos que permiten pasar datos hacia y desde un método, es decir, son la forma en la que un método recibe información para procesar, devuelve resultados y gestiona errores.

Cada tipo de parámetro tiene un propósito concreto.
Elegir mal el tipo hace que tu código sea más difícil de entender y mantener.

Tipos de parámetros en ABAP

En ABAP, un método puede definirse así:

METHODS: metodo
  IMPORTING ...
  EXPORTING ...
  CHANGING ...
  RETURNING VALUE(...)
  RAISING ...

Parámetros IMPORTING

Los parámetros IMPORTING se utilizan para pasar datos al método. Son los parámetros de entrada.

Características

  • Son parámetros de solo lectura – No se pueden modificar dentro del método
  • Pueden ser obligatorios u opcionales
  • Son el tipo más común en métodos que procesan datos
  • Por defecto, se pasan por referencia (a menos que uses VALUE)

Cuándo usar IMPORTING

  • Siempre que necesites datos de entrada
  • Para valores que el método necesita pero no debe modificar
CLASS lcl_calculadora DEFINITION.
  PUBLIC SECTION.
    METHODS: sumar
      IMPORTING iv_a TYPE i
                iv_b TYPE i OPTIONAL
      RETURNING VALUE(rv_resultado) TYPE i.
ENDCLASS.

CLASS lcl_calculadora IMPLEMENTATION.
  METHOD sumar.
    rv_resultado = iv_a + iv_b.
    " iv_a = 100  ❌ No se puede modificar un parámetro IMPORTING
  ENDMETHOD.
ENDCLASS.

DATA(lo_calc) = NEW lcl_calculadora( ).
DATA(resultado) = lo_calc->sumar( iv_a = 10 iv_b = 20 ).

Parámetros EXPORTING

Los parámetros EXPORTING se utilizan para devolver datos desde el método. Un método puede tener múltiples parámetros EXPORTING.

Características

  • Son parámetros de salida
  • Permiten devolver múltiples valores desde un mismo método
  • Son útiles cuando un método necesita devolver más de un resultado

Cuándo usar EXPORTING

  • Cuando necesitas devolver múltiples valores
  • Cuando el método tiene varios resultados de salida
  • En métodos que actualizan varias estructuras o tablas

Ejemplo

CLASS lcl_empleado DEFINITION.
  PUBLIC SECTION.
    METHODS: obtener_datos
      EXPORTING ev_nombre  TYPE string
                ev_apellido TYPE string
                ev_edad     TYPE i.
ENDCLASS.

CLASS lcl_empleado IMPLEMENTATION.
  METHOD obtener_datos.
    ev_nombre = 'Juan'.
    ev_apellido = 'Pérez'.
    ev_edad = 30.
  ENDMETHOD.
ENDCLASS.

DATA(lo_emp) = NEW lcl_empleado( ).
lo_emp->obtener_datos(
  EXPORTING
    ev_nombre  = DATA(nombre)
    ev_apellido = DATA(apellido)
    ev_edad    = DATA(edad)
).

⚠️ En ABAP moderno, EXPORTING se usan menos que RETURNING porque hacen el código más verboso. Si solo necesitas devolver un valor, usa RETURNING. Si necesitas múltiples valores, usa EXPORTING.

Parámetros CHANGING

Los parámetros CHANGING se utilizan para recibir un valor y modificarlo dentro del método. Son de entrada y salida al mismo tiempo.

Características

  • El valor original se modifica dentro del método
  • Combina la funcionalidad de IMPORTING y EXPORTING
  • Útil cuando quieres modificar directamente una variable existente

Cuándo usar CHANGING

  • Cuando necesitas modificar directamente una variable existente
  • En lógica muy controlada donde el método debe actualizar un valor
  • Para operaciones como acumuladores, contadores, o transformaciones in-place

Ejemplo

METHODS: incrementar
  CHANGING cv_contador TYPE i.

DATA(contador) = 1.

obj->incrementar(
  CHANGING
    cv_contador = contador
).

Parámetros RETURNING

Los parámetros RETURNING se utilizan para devolver un único valor desde el método. Es la forma más moderna y limpia de devolver resultados.

Características

  • Un método solo puede tener un parámetro RETURNING
  • El valor se devuelve directamente, como una función
  • Hace el código más legible y expresivo
  • Es el estándar en ABAP moderno

Cuándo usar RETURNING

  • Siempre que necesites devolver un único resultado
  • Para métodos que actúan como funciones (ej. calcular, obtener, validar)
  • Para simplificar el código y hacerlo más legible

Ejemplo

CLASS lcl_calculadora DEFINITION.
  PUBLIC SECTION.
    METHODS: sumar
      IMPORTING iv_a TYPE i
                iv_b TYPE i
      RETURNING VALUE(rv_resultado) TYPE i.
ENDCLASS.

CLASS lcl_calculadora IMPLEMENTATION.
  METHOD sumar.
    rv_resultado = iv_a + iv_b.
  ENDMETHOD.
ENDCLASS.

DATA(lo_calc) = NEW lcl_calculadora( ).
DATA(resultado) = lo_calc->sumar( 10, 20 ).  " resultado = 30

" También se puede encadenar
DATA(resultado2) = lo_calc->sumar( 5, lo_calc->sumar( 3, 2 ) ).

Excepciones: RAISING

Los parámetros RAISING no son parámetros de datos, sino que declaran qué excepciones puede lanzar el método. Se utilizan para gestionar errores dentro de un método.

Características

  • Permiten gestionar errores de forma controlada
  • Separan la lógica normal de la lógica de error
  • Usan clases de excepción (CX_…)

Cuándo usar RAISING

  • Siempre que un método pueda encontrar una situación de error
  • Para evitar que los objetos queden en estados inválidos
  • En lugar de usar SY-SUBRC (estilo antiguo)

Ejemplo

CLASS lcl_calculadora DEFINITION.
  PUBLIC SECTION.
    METHODS: dividir
      IMPORTING iv_dividendo TYPE i
                iv_divisor   TYPE i
      RETURNING VALUE(rv_resultado) TYPE p DECIMALS 2
      RAISING cx_sy_zerodivide.
ENDCLASS.

CLASS lcl_calculadora IMPLEMENTATION.
  METHOD dividir.
    IF iv_divisor = 0.
      RAISE EXCEPTION TYPE cx_sy_zerodivide.
    ENDIF.
    rv_resultado = iv_dividendo / iv_divisor.
  ENDMETHOD.
ENDCLASS.

DATA(lo_calc) = NEW lcl_calculadora( ).
TRY.
    DATA(resultado) = lo_calc->dividir( iv_dividendo = 10 iv_divisor = 0 ).
  CATCH cx_sy_zerodivide.
    WRITE: 'Error: No se puede dividir entre cero'.
ENDTRY.

Comparativa de parámetros

TipoEntradaSalidaModificaNº valoresUso principal
IMPORTING✅❌❌MúltiplesDatos de entrada
EXPORTING❌✅❌MúltiplesMúltiples salidas
CHANGING✅✅✅MúltiplesModificar datos
RETURNING❌✅❌UnoValor principal
RAISING––––Gestión de errores

Buenas prácticas con parámetros

1. Prefiere RETURNING sobre EXPORTING para valores únicos

2. Usa nombres de parámetros con prefijos estándar

PrefijoSignificadoEjemplo
IV_Importing Valueiv_id, iv_nombre
EV_Exporting Valueev_resultado, ev_mensaje
CV_Changing Valuecv_contador, cv_acumulado
RV_Returning Valuerv_total, rv_valido

3. Haz los parámetros obligatorios por defecto

4. Declara las excepciones que puede lanzar el méto

Los parámetros son el puente de comunicación entre un método y el código que lo llama. Recuerda las reglas de oro:

  • IMPORTING para datos de entrada
  • EXPORTING para múltiples salidas
  • RETURNING para un valor principal
  • CHANGING solo cuando realmente necesitas modificar
  • RAISING para gestionar errores

Entradas relacionadas