REPORT ZSEGUNDA_CLASE_LOCAL17.

CLASS LCL_CLASE1 DEFINITION.

PUBLIC SECTION.
"Hay un método especial en las clases que se llama automáticamente
" al crear una instancia. Es un método de instancia. Este método
" no se hereda nunca esté en la sección que esté. En abap tiene
" un nombre fijo que es CONSTRUCTOR
METHODS: CONSTRUCTOR,
metodo1,
metodo2 IMPORTING im_valor TYPE i, "Método con un parámetro
" de entrada
metodo3 IMPORTING im_valor1 TYPE i
im_valor2 TYPE i,
metodo4 IMPORTING im_x TYPE i "Dos parámetros de entrada
im_y TYPE i " y uno de salida
EXPORTING ex_resultado TYPE i,
metodo5 CHANGING ch_valor TYPE i, "Un parámetro de entrada/salida
metodo_funcional IMPORTING im_a TYPE i "Método funcional
im_b TYPE i
RETURNING VALUE(re_resultado) TYPE i.
CLASS-METHODS: metodo_estatico.
PRIVATE SECTION.
DATA x TYPE i VALUE 15.
CLASS-DATA instancias TYPE i.
ENDCLASS.

CLASS LCL_CLASE1 IMPLEMENTATION.

METHOD CONSTRUCTOR.
ADD 1 TO instancias. "Incrementamos en 1 el valor de las instancias
ENDMETHOD.

METHOD metodo1.
WRITE:/ 'El valor de x es: ', x.
ENDMETHOD.

METHOD metodo2.
"Si el parámetro coincide en nombre con un atributo de la clase,
" si ponemos solo el nombre se enterá que estamos accediendo
" al parámetro. Si queremos acceder al atributo de la clase
" tendremos que usar la variable de autoreferencia que tienen
" tadas las clases y que en abap es ME.
"EL parémtro es como si declaramos una variable dentro de este
" bloque de código. Solo existe en este bloque y cuando se
" acaba su ejecución desaparece de memória

WRITE:/ 'El valor de el parámetro es: ', im_valor.

ENDMETHOD.

METHOD metodo3.
WRITE:/ 'El valor de el parámetro 1 es: ', im_valor1, ' y el del 2 es: ', im_valor2.
ENDMETHOD.

METHOD metodo4.
ex_resultado = im_x + im_y.
ENDMETHOD.

METHOD metodo5.
ch_valor = 2 * ch_valor. "Leemos el valor del parámetros y
" modificamos su valor
ENDMETHOD.

METHOD metodo_funcional.
re_resultado = im_a + im_b.
ENDMETHOD.

METHOD metodo_estatico.
"Un método estático no puede acceder a variables y métodos de instancia
WRITE:/ 'Tenemos ', instancias, ' intancias de la clase'.
ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.

"Declaraqmos la variable de referencia

DATA: r_objeto TYPE REF TO LCL_CLASE1,
r_objeto2 TYPE REF TO LCL_CLASE1.

"Creamos la instancia y hacemos que la variable de referencia

" apunte a esta instancia en memória.
"En ABAP existe el recolector de basura. El recolector de basura
" es un proceso en segundo plano que irá comprobando las instancias
" que hay en memória y eliminará cuando crea necesario las instancias
" que no se están usando
CREATE OBJECT: r_objeto, r_objeto2.

*"Ejecutamos el método de la instancia

*r_objeto->METODO1( ).
*
*"Ejecutar un método estático
*LCL_CLASE1=>METODO_ESTATICO( ).
*
**También se puede llamar a un método de la siguiente manera:
*
*CALL METHOD r_objeto->metodo1.
*CALL METHOD LCL_CLASE1=>METODO_ESTATICO.

*Llamanda a un método solo con un parámetro de entrada

*---------------------------------------------------

*r_objeto->METODO2( "Nomenclatura larga

* EXPORTING
* IM_VALOR = 5
* ).

"En el caso de que solo haya parámetros de entrada nos podemos

" ahorrar el EXPORTING
* r_objeto->METODO2( IM_VALOR = 10 ).

"En caso de que solo haya un único parámetro de entrada nos

" podemos ahorrar también el nombre del parámetro porque
" no hay posibilidad de duda de donde hay que poner ese valor
* r_objeto->METODO2( 15 ).

*Llamanda a un método solo con varios parámetros de entrada

*---------------------------------------------------

*r_objeto->METODO3( "Nomenclatura larga

* EXPORTING
* IM_VALOR1 = 5
* IM_VALOR2 = 7
* ).

"En el caso de que solo haya parámetros de entrada nos podemos

" ahorrar el EXPORTING
* r_objeto->METODO3(
* IM_VALOR1 = 10
* IM_VALOR2 = 15
* ).

*Llamanda a un método con parámetros de salida

*---------------------------------------------------
*DATA resultado TYPE i.
*
*r_objeto->METODO4( "Nomenclatura larga
* EXPORTING
* IM_X = 5
* IM_Y = 7
* IMPORTING
* EX_RESULTADO = resultado
* ).
*
*WRITE:/ 'El resultado de la suma es: ', resultado.
*Llamada a un método con parámetros de entrada y salida
*-------------------------------------------------------

*DATA x TYPE i VALUE 10.

*
*r_objeto->metodo5(
* CHANGING
* ch_valor = x
* ).
*
*WRITE:/ 'El resultado del método es: ', x.

*Llamada a un método "funcional"

*-------------------------------

*Un método funcional va a ser un método que permite asignar a una variable el
* valor retornado por el método.
*
* Ejemplo:
* DATA x TYPE i.
* x = r_objeto->metodo_funcional( ... ).
*
*Esto lo hace ABAP con un método que tiene RETURNING.

*DATA x TYPE i.
*x = r_objeto->METODO_FUNCIONAL( im_a = 5 im_b = 10 ).
*
*WRITE:/ 'La suma de 5 + 10 es: ', x.

* RESTRICCIONES DE LOS METODOS FUNCIONALES

* ========================================
*
* - No puede haber parámetros EXPORTING o CHANGING en el método
* - Solo puede haber un parámetrro RETURNING (si necesitamos más, usar el EXPORTING)
* - Los parámetros RETURNING siempre son por valor