Anfang des Inhaltsbereichs

Programmlokale Datentypen Dokument im Navigationsbaum lokalisieren

Jedes ABAP-Programm kann seine eigenen Datentypen definieren und innerhalb eines Programms können Prozeduren nochmals eigene lokale Datentypen definieren.

Programmlokale Datentypen werden mit der Anweisung

TYPES <t> ... [TYPE <type>|LIKE <obj>] ...

definiert. Der Name des Datentyps <t> kann bis zu 30 Zeichen lang sein. Es können alle Ziffern, Buchstaben und der Unterstrich verwendet werden. Der Name darf nicht aus Ziffern alleine bestehen. Die Sonderzeichen + . , : ( ) - < > dürfen nicht verwendet werden. Die übrigen Sonderzeichen sind für den internen Gebrauch reserviert. Die Namen der eingebauten ABAP-Typen (C, D, F, I, N, P, T, X, STRING, XSTRING) dürfen nicht verwendet werden, ebensowenig der Name des generischen Typs TABLE. Es sollten keine Namen verwendet werden, die mit einem Schlüsselwort oder einem Zusatz von ABAP-Anweisungen übereinstimmen. Es sollten

Programmlokale Datentypen werden entweder mit Bezug auf bekannte Datentypen definiert oder neu konstruiert.

Ein bekannter Typ kann sein

Die bekannte Typen müssen an der Definitionstelle sichtbar sein. Falls der bekannte Datentyp generisch ist, können mit weiteren Zusätzen die noch offenen Eigenschaften des Typs <t> spezifiziert werden.

Elementare Datentypen

Programmlokale elementare Datentypen werden ausschließlich durch Bezug auf eingebaute elementare Typen definiert. Die Syntax für die Definition elementarer Datentypen ist:

TYPES <t>[(<length>)] [TYPE <type>|LIKE <obj>] [DECIMALS <dec>].

Dabei ist <type> entweder einer der eingebauten ABAP-Typen C, D, F, I, N, P, T, X, STRING oder XSTRING, ein vorher definierter elementarer programmlokaler Typ oder ein im ABAP Dictionary definiertes Datenelement. Beim Bezug auf ein Datenelement aus dem Dictionary wird dieses in einen elementaren ABAP Typ konvertiert. Beim LIKE-Bezug kann <obj> ein vorher deklariertes Datenobjekt mit elementarem Datentyp sein.

Ohne TYPE- oder LIKE-Zusatz wird implizit der eingebaute Typ C verwendet. Falls <type> einer der generischen elementaren eingebauten ABAP-Typen fixer Länge (C, N, P, X) ist, sollte mit der Option <length> die Feldlänge festgelegt werden. Ohne die Angabe von <length> wird die Feldlänge auf den entsprechenden Initialwert der Tabelle unter Eingebaute ABAP-Typen gesetzt. Falls <type> gleich P ist, kann mit der Option DECIMALS die Anzahl der Dezimalstellen festgelegt werden. Ohne die Angabe von DECIMALS wird die Anzahl der Dezimalstellen auf Null gesetzt.

Die implizite Anweisung

TYPES <t>.

Definiert also ein Characterfeld <t> der Länge 1. Sie ist eine Kurzform der expliziten Anweisung

TYPES <t>(1) TYPE C.

Es sollte aber immer die explizite Anweisung verwendet werden. Insbesondere ist die Kurzform im Umfeld von ABAP Objects, also innerhalb von Klassen, verboten.

Elementare programmlokale Datentypen können Programme transparenter und lesbarer machen. Wenn man einen programmlokalen Datentyp zur Typisierung mehrerer Datenobjekten verwendet hat, läßt sich der Datentyp all dieser Datenobjekte auf einmal ändern, indem man die Definition des Datentyps in der TYPES-Anweisung ändert. Oder wenn eine bestimmte Menge von Datentypen regelmäßig in verschiedenen Programmen benutzt werden soll, die Datentypen aber nicht systemweit im ABAP Dictionary abgelegt werden sollen, kann man sich ein Include-Programm für die Typdefinition anlegen und in die Programme einbetten.

Beispiel

TYPES: number TYPE i,
       length TYPE p DECIMALS 2,
       code(3) TYPE c.

...

In diesem Beispiel wird ein Datentyp mit dem Namen NUMBER definiert. Er ist bis auf den Namen identisch mit dem eingebauten ABAP-Typ I und dient somit nur zur Erhöhung der Lesbarkeit des Programms.

Es wird ein Datentyp LENGTH definiert, der auf dem eingebauten generischen ABAP-Typ P basiert. LENGTH wird mit einer gegebenen Zahl von Dezimalstellen definiert. Wäre es zum Beispiel erforderlich die Genauigkeit von Längenangaben zu ändern, müßte man lediglich die TYPES-Anweisung des Programms ändern.

Es wird ein dritter Datentyp CODE definiert. CODE basiert auf dem eingebauten generischen ABAP-Typ C. Die Feldlänge wird hier mit 3 Bytes festgelegt.

Beispiel

DATA counts TYPE i.

TYPES: company    TYPE spfli-carrid,
       no_flights LIKE counts.

Dieses Beispiel zeigt, wie mit dem Zusatz TYPE auf die Spalte CARRID der Datenbanktabelle SPFLI verwiesen wird. Der Zusatz LIKE verweist auf ein bereits vorhandenes Datenobjekt.

Referenztypen

Referenztypen sind programmlokal und im ABAP Dictionary definierbar. Die Syntax für die Definition von Referenztypen ist:

TYPES <t> TYPE REF TO ...

Hier steht hinter dem TYPE-Zusatz kein Verweis auf einen anderen Datentyp, sondern ein sogenannter Typkonstruktor.

REF TO DATA

definiert die TYPES-Anweisung eine Referenz <t> auf ein Datenobjekt. Felder des Datentyps <t> können Referenzen (Zeiger) auf Datenobjekte also auf Instanzen von Datentypen enthalten (siehe auch Datenreferenzen).

REF TO <class>|<interface>

definiert die TYPES-Anweisung eine Referenz <t> auf die Klasse <class> oder das Interface <interface>. Felder des Datentyps <t> können Referenzen (Zeiger) auf Instanzen der Klasse <class> oder ihrer Unterklassen bzw. von Klassen, die das Interface <interface> implementieren, enthalten (siehe auch Behandlung von Objekten).

Komplexe Typen

Ein komplexer programmlokaler Datentyp setzt sich immer aus obigen elementaren Datentypen oder Referenztypen zusammen. Die TYPES-Anweisung ist in diesem Fall ein Konstruktionsvorschrift für den komplexen Datentyp.

Beim TYPE- oder LIKE-Bezug auf einen bekannten komplexen Typ:

TYPES <t> [TYPE <type>|LIKE <obj>].

wird der neue komplexe Typ nach Vorlage des bekannten Typs konstruiert. Beim Bezug auf die komplexen Dictionary-Typen Struktur oder Tabellentyp, die sich aus elementaren Datenelementen des Dictionarys zusammensetzen, wird der Aufbau aus dem Dictionary übernommen und die Datenelemente werden in elementare ABAP-Typen konvertiert.

Die TYPES-Anweisung ermöglicht es auch neue komplexe Datentypen ohne Bezug auf bekannte Strukturen und Tabellen zu definieren.

Strukturtypen

Für die Konstruktion eines neuen programmlokalen Strukturtyps verwendet man mehrere TYPES-Anweisungen wie im folgenden Kettensatz:

TYPES: BEGIN OF <structure>,
                ..............
                <ti> ...,
                ..............
       END OF <structure>.

Dieser Kettensatz faßt zwischen den Anweisungen

TYPES BEGIN OF <structure>. und TYPES END OF <structure>.

die in den Anweisungen

TYPES <ti>... .

definierten Datentypen <ti> zu einem Strukturtyp zusammen. Die einzelnen Komponenten <t i> können elementare Typen, Referenztypen oder durch Bezug auf bekannte komplexe Typen selber komplex sein. Die Anweisungsblöcke TYPES BEGIN OF - TYPES END OF sind auch schachtelbar, um nichtflache Strukturtypen zu konstruieren.

Die einzelnen Komponenten eines Strukturtyps werden im Programm mit einem Bindestrich zwischen Strukturname und Komponentenname benannt: <structure>-<ti>.

Beispiel

TYPES: spfli_type TYPE spfli,

       surname(20) TYPE c,

       BEGIN OF address,
             name       TYPE surname,
             street(30) TYPE c,
             city       TYPE spfli_type-cityfrom,
       END OF address,

       town TYPE address-city.

Dieses Beispiel zeigt die programmlokalen Definitionen zweier Strukturtypen SPFLI_TYPE und ADDRESS. Die Struktur des Datentyps SPFLI_TYPE wird von der Datenbanktabelle SPFLI aus dem ABAP Dictionary übernommen. Die einzelnen Komponenten von SPFLI_TYPE spiegeln die Spalten von SPFLI wieder. Die einzelnen Datentypen der Komponenten sind die ABAP-Entsprechungen der Datentypen der Spalten im ABAP Dictionary. Der Strukturtyp ADDRESS wird neu definiert. Die Komponente ADDRESS-NAME übernimmt den Datentyp vom vorher definierten Typ SURNAME, die Komponente ADDRESS-STREET wird neu definiert, die Komponente ADDRESS-CITY übernimmt den Datentyp der Spalte CITYFROM des Strukturtyps SPFLI_TYPE.

Beispiel

TYPES: BEGIN OF struct1,
         col1 TYPE i,
         BEGIN OF struct2,
           col1 TYPE i,
           col2 TYPE i,
         END OF struct2,
       END OF struct1.

TYPES mytype TYPE struct1-struct2-col2.

Das Beispiel zeigt, wie ein geschachtelter Strukturtyp STRUCT1 mit einer komplexen Komponente STRUCT2 durch Schachtelung der Anweisungsblöcke TYPES BEGIN OF - TYPES END OF konstruiert werden kann und wie die inneren Komponenten angesprochen werden.

Beispiel

* Programmlokale Typen,
* die auf eingebaute ABAP-Typen verweisen:

TYPES: surname(20)  TYPE c,
       street(30)   TYPE c,
       zip_code(10) TYPE n,
       city(30)     TYPE c,
       phone(20)    TYPE n,
       date         LIKE sy-datum.

* Programmlokale Struktur,
* die auf obige Typen verweist:

TYPES: BEGIN of address,
         name TYPE surname,
         code TYPE zip_code,
         town TYPE city,
         str  TYPE street,
       END OF address.

* Programmlokale geschachtelte Struktur,
* die auf obige Typen verweist:

TYPES: BEGIN of phone_list,
         adr TYPE address,
         tel TYPE phone,
       END OF phone_list.

Dieses Beispiel zeigt, wie man aus einfachen Typdefinitionen komplexe Datentypen aufbauen kannn. Nachdem eine Menge von elementaren Datentypen mit eingebauten ABAP-Typen angelegt wurde, wird ein Strukturtyp ADDRESS mit den vorher definierten Datentypen definiert. Schließlich wird ein geschachtelter Strukturtyp PHONE_LIST angelegt, dessen erste Komponente den Typ ADDRESS hat.

Tabellentypen

Programmlokale Tabellen werden auch interne Tabellen genannt. Die Syntax für die Konstruktion eines neuen internen Tabellentyps ist:

TYPES <t> TYPE|LIKE <tabkind> OF <linetype> [WITH <key>].

Wie bei Referenzen steht hier hinter dem TYPE-Zusatz kein Verweis auf einen anderen Datentyp, sondern ein Typkonstruktor. Mit dem Typkonstruktor

<tabkind> OF <linetype> [WITH <key>]

wird ein interner Tabellentyp der Zugriffsart <tabkind>, dem Zeilentyp <linetype> und dem Schlüssel <key> definiert. Der Zeilentyp <linetype> ist ein beliebiger bekannter Datentyp. Die Angaben zum Schlüssel sind optional. Interne Tabellen können also generisch sein. Für ausführliche Informationen zur Definition interner Tabellen siehe Interne Tabellen.

Ende des Inhaltsbereichs