ABAP VALUE und NEW: Konstruktorausdrücke für Daten und Objekte

VALUE <typ>( [Komponenten/Zeilen] )
VALUE #( [Komponenten/Zeilen] )  " Typ wird abgeleitet

TYPES: BEGIN OF ty_person,
         name  TYPE string,
         age   TYPE i,
         city  TYPE string,
       END OF ty_person.

" Klassisch (alt)
DATA: ls_person TYPE ty_person.
ls_person-name = 'Max'.
ls_person-age = 30.
ls_person-city = 'Berlin'.

" Modern mit VALUE
DATA(ls_person2) = VALUE ty_person(
  name = 'Max'
  age  = 30
  city = 'Berlin'
).

" Mit Typ-Ableitung (#)
DATA: ls_target TYPE ty_person.
ls_target = VALUE #( name = 'Anna' age = 25 city = 'München' ).

TYPES: ty_names TYPE TABLE OF string WITH EMPTY KEY.

" Tabelle mit Werten füllen
DATA(lt_names) = VALUE ty_names(
  ( `Anna` )
  ( `Bernd` )
  ( `Clara` )
).

" Strukturierte Tabelle
DATA(lt_persons) = VALUE ty_persons(
  ( name = 'Max'   age = 30 city = 'Berlin' )
  ( name = 'Anna'  age = 25 city = 'München' )
  ( name = 'Peter' age = 35 city = 'Hamburg' )
).

DATA: lt_numbers TYPE TABLE OF i.

lt_numbers = VALUE #( ( 1 ) ( 2 ) ( 3 ) ).

" Weitere Zeilen hinzufügen mit BASE
lt_numbers = VALUE #(
  BASE lt_numbers
  ( 4 )
  ( 5 )
  ( 6 )
).

" Ergebnis: 1, 2, 3, 4, 5, 6

TYPES: BEGIN OF ty_address,
         street TYPE string,
         zip    TYPE string,
         city   TYPE string,
       END OF ty_address,

       BEGIN OF ty_customer,
         id      TYPE i,
         name    TYPE string,
         address TYPE ty_address,
       END OF ty_customer.

DATA(ls_customer) = VALUE ty_customer(
  id   = 1
  name = 'Müller GmbH'
  address = VALUE #(
    street = 'Hauptstraße 1'
    zip    = '10115'
    city   = 'Berlin'
  )
).

DATA: ls_person TYPE ty_person.

" Struktur initialisieren (alle Felder auf Initialwert)
ls_person = VALUE #( ).

" Nur bestimmte Felder setzen, Rest initial
ls_person = VALUE #( name = 'Test' ).
" age und city sind 0 bzw. leer

DATA: lt_customers TYPE TABLE OF ty_customer.

" Zeile suchen - bei Nicht-Treffer: Initialwert
DATA(ls_found) = VALUE #( lt_customers[ id = 999 ] OPTIONAL ).

" Bei Nicht-Treffer: Standardwert
DATA(ls_default) = VALUE #(
  lt_customers[ id = 999 ]
  DEFAULT VALUE #( id = 0 name = 'Unbekannt' )
).

DATA(ls_result) = VALUE ty_person(
  LET prefix = 'Dr. '
      suffix = ' (CEO)'
  IN
  name = prefix && 'Max Müller' && suffix
  age  = 45
  city = 'Frankfurt'
).
" name = 'Dr. Max Müller (CEO)'

" Tabelle aus anderer Tabelle erstellen
DATA(lt_names_only) = VALUE ty_names(
  FOR ls_p IN lt_persons
  ( ls_p-name )
).

" Mit Bedingung
DATA(lt_adults) = VALUE ty_persons(
  FOR ls_p IN lt_persons
  WHERE ( age >= 18 )
  ( ls_p )
).

" Mit Transformation
DATA(lt_upper_names) = VALUE ty_names(
  FOR ls_p IN lt_persons
  ( to_upper( ls_p-name ) )
).

NEW <klassenname>( [Konstruktorparameter] )
NEW #( [Konstruktorparameter] )  " Typ wird abgeleitet

CLASS lcl_calculator DEFINITION.
  PUBLIC SECTION.
    METHODS: add IMPORTING iv_a TYPE i iv_b TYPE i
                 RETURNING VALUE(rv_result) TYPE i.
ENDCLASS.

CLASS lcl_calculator IMPLEMENTATION.
  METHOD add.
    rv_result = iv_a + iv_b.
  ENDMETHOD.
ENDCLASS.

" Klassisch (alt)
DATA: lo_calc TYPE REF TO lcl_calculator.
CREATE OBJECT lo_calc.

" Modern mit NEW
DATA(lo_calc2) = NEW lcl_calculator( ).

" Direkt verwenden
DATA(lv_sum) = NEW lcl_calculator( )->add( iv_a = 5 iv_b = 3 ).

CLASS lcl_person DEFINITION.
  PUBLIC SECTION.
    METHODS: constructor IMPORTING iv_name TYPE string
                                   iv_age  TYPE i.
    DATA: mv_name TYPE string READ-ONLY,
          mv_age  TYPE i READ-ONLY.
ENDCLASS.

CLASS lcl_person IMPLEMENTATION.
  METHOD constructor.
    mv_name = iv_name.
    mv_age = iv_age.
  ENDMETHOD.
ENDCLASS.

" Objekt mit Parametern erstellen
DATA(lo_person) = NEW lcl_person(
  iv_name = 'Max Müller'
  iv_age  = 30
).

WRITE: / lo_person->mv_name, lo_person->mv_age.

" Integer-Referenz erstellen
DATA(lr_int) = NEW i( 42 ).
WRITE: / lr_int->*.  " 42

" String-Referenz
DATA(lr_string) = NEW string( 'Hallo Welt' ).

" Struktur-Referenz
DATA(lr_person) = NEW ty_person(
  name = 'Test'
  age  = 25
).

" Interne Tabelle als Referenz
DATA(lr_table) = NEW ty_persons(
  ( name = 'A' age = 20 )
  ( name = 'B' age = 30 )
).

LOOP AT lr_table->* INTO DATA(ls_p).
  WRITE: / ls_p-name.
ENDLOOP.

DATA: lo_obj TYPE REF TO lcl_calculator.

" Typ wird von lo_obj abgeleitet
lo_obj = NEW #( ).

" Bei Methodenparametern
METHODS: process IMPORTING io_calc TYPE REF TO lcl_calculator.

" Aufruf
process( io_calc = NEW #( ) ).

" String zu Integer
DATA(lv_int) = CONV i( '42' ).

" Integer zu String
DATA(lv_str) = CONV string( 42 ).

" Dezimalzahl
DATA(lv_dec) = CONV decfloat34( '123.456' ).

" Bei Berechnungen
DATA(lv_result) = CONV f( 10 / 3 ).  " 3.333...

" === KLASSISCH ===

" Struktur
DATA: ls_person TYPE ty_person.
ls_person-name = 'Max'.
ls_person-age = 30.

" Tabelle
DATA: lt_persons TYPE ty_persons,
      ls_temp    TYPE ty_person.
ls_temp-name = 'Max'.
ls_temp-age = 30.
APPEND ls_temp TO lt_persons.

" Objekt
DATA: lo_calc TYPE REF TO lcl_calculator.
CREATE OBJECT lo_calc.


" === MODERN ===

" Struktur
DATA(ls_person) = VALUE ty_person( name = 'Max' age = 30 ).

" Tabelle
DATA(lt_persons) = VALUE ty_persons(
  ( name = 'Max' age = 30 )
).

" Objekt
DATA(lo_calc) = NEW lcl_calculator( ).