00_Titelei.fm Seite 3 Mittwoch, 4. März 2015 8:24 08
Horst Keller, Sascha Krüger
®
ABAP Objects ABAP-Programmierung mit SAP NetWeaver
358.book Page 5 Monday, September 4, 2006 8:51 AM
Auf einen Blick Vorwort .............................................................................
19
1
Einleitung ..........................................................................
23
2
Eine praktische Einführung ...............................................
55
3
ABAP-Grundlagen ............................................................. 151
4
Klassen und Objekte ........................................................ 191
5
Grundlegende ABAP-Sprachelemente .............................. 245
6
Weiterführende Konzepte von ABAP Objects ................. 369
7
Klassisches ABAP – Ereignisse und Prozeduren ............... 489
8
Fehlerbehandlung ............................................................. 523
9
GUI-Programmierung mit ABAP ....................................... 559
10
Arbeiten mit persistenten Daten ...................................... 769
11
Dynamische Programmierung ........................................... 867
12
Externe Schnittstellen ...................................................... 917
13
Test- und Analysewerkzeuge ............................................ 1023
A
Anhang .............................................................................. 1077
Die Autoren .............................................................................. 1103 Index ........................................................................................ 1107
358IVZ.fm Page 7 Monday, September 4, 2006 2:00 PM
Inhalt Vorwort ....................................................................................................
1
Einleitung ...........................................................................
23
1.1
Was ist ABAP? ....................................................................... 1.1.1 Die Evolution von ABAP ........................................... 1.1.2 Der Umfang von ABAP .............................................. 1.1.3 Die ABAP-Entwicklungsumgebung ............................ 1.1.4 Das ABAP-Programmiermodell .................................. 1.1.5 ABAP und SAP NetWeaver ........................................ 1.1.6 ABAP vs. Java? .......................................................... 1.1.7 ABAP und Java! ......................................................... Was ist das Ziel dieses Buches? .............................................. 1.2.1 Zielgruppe dieses Buches .......................................... 1.2.2 Aufbau dieses Buches ................................................ 1.2.3 Beachtung von Programmierrichtlinien ...................... 1.2.4 Verwendete Syntaxkonventionen ............................. Wie können Sie mit diesem Buch praktisch arbeiten? ............. 1.3.1 Erstellung der Beispiele ............................................. 1.3.2 Ziel der Beispiele ....................................................... 1.3.3 Verwendung der Beispiele ......................................... 1.3.4 Beschriebene Releases .............................................. 1.3.5 Verwendete Datenbanktabellen ................................
23 23 25 26 26 29 31 32 42 42 43 49 50 51 51 52 52 53 53
Eine praktische Einführung ................................................
55
2.1 2.2
56 57 57 60 63 64 65 66 70 71 72 76
1.2
1.3
2
19
2.3
2.4
Funktionalität der Beispielanwendung ................................... Erste Schritte in der ABAP Workbench ................................... 2.2.1 Einstieg über SAP Easy Access ................................... 2.2.2 Der Object Navigator ................................................ Pakete ................................................................................... 2.3.1 Paket für lokale Entwicklungsobjekte ........................ 2.3.2 Pakete für transportierbare Entwicklungsobjekte ....... 2.3.3 Paket anlegen ........................................................... 2.3.4 Transport Organizer aufrufen .................................... Datenbanktabellen ................................................................ 2.4.1 Kundentabelle anlegen ............................................. 2.4.2 Datenelement anlegen ..............................................
7
358.book Page 8 Monday, September 4, 2006 8:51 AM
Inhalt
2.4.3 Domäne anlegen ....................................................... 2.4.4 Kundentabelle fertig stellen ...................................... 2.4.5 Suchhilfe anlegen ...................................................... 2.4.6 Mietwagentabelle anlegen ........................................ 2.4.7 Reservierungstabelle anlegen .................................... Anlegen eines ABAP-Programms ........................................... 2.5.1 Hilfsprogramm anlegen ............................................. 2.5.2 ABAP-Syntax ............................................................. 2.5.3 Allgemeiner Programmaufbau ................................... 2.5.4 Zwei »Hello-World«-Programme ............................... 2.5.5 Programme kopieren ................................................. Hilfsprogramm implementieren .............................................. 2.6.1 Quelltext des Hilfsprogramms ................................... 2.6.2 Kettensätze ............................................................... 2.6.3 Datendeklarationen .................................................. 2.6.4 Wertzuweisung an die Datenobjekte ......................... 2.6.5 Datenbankzugriffe ..................................................... 2.6.6 Ausnahmebehandlung ............................................... 2.6.7 Test des Hilfsprogramms mit dem ABAP Debugger .... 2.6.8 Ergebnis des Hilfsprogramms im Data Browser .......... Benutzerdialog ...................................................................... 2.7.1 Verwendung einer Funktionsgruppe .......................... 2.7.2 Top-Include der Funktionsgruppe ............................. 2.7.3 Funktionsbausteine anlegen ...................................... 2.7.4 Funktionsbausteine testen ......................................... Anwendungslogik .................................................................. 2.8.1 Ausnahmeklassen ...................................................... 2.8.2 Anlegen einer Klasse für Reservierungen ................... 2.8.3 Anlegen einer Klasse für Kundenobjekte ................... 2.8.4 Anwendungsprogramm ............................................. 2.8.5 Transaktionscode anlegen ......................................... 2.8.6 Transaktion ausführen ............................................... 2.8.7 Reporting .................................................................. Zusammenfassung ................................................................. Verwendung der Schlüsselwortdokumentation ......................
79 80 82 83 85 87 87 89 91 93 97 97 97 100 100 101 102 102 102 104 106 107 108 112 115 118 119 120 129 135 139 141 143 145 146
ABAP-Grundlagen ..............................................................
151
3.1
151 151 152
2.5
2.6
2.7
2.8
2.9 2.10
3
8
ABAP und SAP NetWeaver .................................................... 3.1.1 SAP NetWeaver ........................................................ 3.1.2 Der Application Server ..............................................
358.book Page 9 Monday, September 4, 2006 8:51 AM
Inhalt
3.1.3 Der Application Server ABAP .................................... 3.1.4 Die ABAP-Laufzeitumgebung .................................... 3.1.5 Die Textumgebung .................................................... ABAP-Programmorganisation und -Eigenschaften .................. 3.2.1 ABAP-Programmaufbau ............................................ 3.2.2 ABAP-Programmausführung ...................................... 3.2.3 ABAP-Programmaufrufe ............................................ 3.2.4 ABAP-Programmtypen .............................................. 3.2.5 Weitere Programmeigenschaften ............................... 3.2.6 Verarbeitungsblöcke ................................................. Quelltextorganisation ............................................................ 3.3.1 Include-Programme .................................................. 3.3.2 Makros ..................................................................... Software- und Speicherorganisation des AS ABAP .................. 3.4.1 AS ABAP als System .................................................. 3.4.2 Applikationsserver .................................................... 3.4.3 Benutzersitzung ........................................................ 3.4.4 Hauptmodus ............................................................. 3.4.5 Interner Modus .........................................................
153 161 162 163 163 166 167 170 174 176 180 180 184 184 184 185 187 188 188
Klassen und Objekte ..........................................................
191
4.1 4.2 4.3
191 194 196 197 198 206 206 208 210 213 215 216 218 218 221 222 224 226 229
3.2
3.3
3.4
4
4.4
4.5 4.6
Objektorientierung ................................................................ Objektorientierte Programmierung in ABAP ........................... Klassen .................................................................................. 4.3.1 Globale und lokale Klassen ....................................... 4.3.2 Klassen anlegen ........................................................ Attribute und Methoden ....................................................... 4.4.1 Instanzkomponenten und statische Komponenten .... 4.4.2 Attribute ................................................................... 4.4.3 Methoden ................................................................. 4.4.4 Verwendung statischer Komponenten ....................... 4.4.5 Editor-Modus des Class Builder ................................. Datentypen als Komponenten von Klassen ............................ Objekte und Objektreferenzen .............................................. 4.6.1 Objekte erzeugen und referenzieren .......................... 4.6.2 Die Selbstreferenz me ............................................... 4.6.3 Referenzen zuweisen ................................................. 4.6.4 Mehrfachinstanzierung .............................................. 4.6.5 Objekterzeugung in Factory-Methode ....................... 4.6.6 Garbage Collection ....................................................
9
358.book Page 10 Monday, September 4, 2006 8:51 AM
Inhalt
4.7
Konstruktoren ....................................................................... 4.7.1 Instanzkonstruktor .................................................... 4.7.2 Statischer Konstruktor ............................................... 4.7.3 Destruktoren ............................................................. Lokale Deklarationen eines Class-Pools .................................. 4.8.1 Lokale Typen in Class-Pools ...................................... 4.8.2 Lokale Klassen in Class-Pools .................................... Verwendung von ABAP Objects auf dem AS ABAP ................ Zusammenfassung und Ausblick .............................................
231 232 234 237 238 238 239 240 243
Grundlegende ABAP-Sprachelemente ...............................
245
5.1
246 246 249 257 266 270 271 273 284 286 289 297 297 298 308 311 318 324 324 327 330 331 333 341 342
4.8
4.9 4.10
5
5.2
5.3
5.4
10
Datentypen und Datenobjekte ............................................... 5.1.1 Datenobjekte ............................................................ 5.1.2 Datentypen ............................................................... 5.1.3 Elementare Datentypen und Datenobjekte ................ 5.1.4 Strukturierte Datentypen und Datenobjekte .............. 5.1.5 Tabellentypen und interne Tabellen .......................... 5.1.6 Referenztypen und Referenzvariablen ........................ 5.1.7 Datentypen im ABAP Dictionary ............................... 5.1.8 Flache und tiefe Datentypen ..................................... 5.1.9 Generische Datentypen ............................................. 5.1.10 Mehr zu Datenobjekten ............................................ Operationen und Ausdrücke .................................................. 5.2.1 Zuweisungen ............................................................. 5.2.2 Typkonvertierungen .................................................. 5.2.3 Spezielle Zuweisungen .............................................. 5.2.4 Berechnungen ........................................................... 5.2.5 Logische Ausdrücke .................................................. Kontrollstrukturen ................................................................. 5.3.1 Bedingte Verzweigungen ........................................... 5.3.2 Schleifen ................................................................... Zeichen- und Bytekettenverarbeitung .................................... 5.4.1 Operationen mit Zeichenketten ................................. 5.4.2 Suchen und Ersetzen ................................................. 5.4.3 Teilfeldzugriff ............................................................ 5.4.4 Funktionen für die Zeichenkettenverarbeitung .......... 5.4.5 Vergleichsoperatoren für die Zeichenkettenverarbeitung ........................................
343
358.book Page 11 Monday, September 4, 2006 8:51 AM
Inhalt
5.5
6
Interne Tabellen .................................................................... 5.5.1 Eigenschaften interner Tabellen ................................ 5.5.2 Arbeiten mit internen Tabellen .................................
345 346 354
Weiterführende Konzepte von ABAP Objects ..................
369
6.1
373 373 385 389 389 391
6.2
6.3
6.4
6.5
6.6
Methodenschnittstellen und Methodenaufrufe ...................... 6.1.1 Parameterschnittstelle von Methoden ....................... 6.1.2 Methodenaufrufe ...................................................... Vererbung ............................................................................. 6.2.1 Grundlagen ............................................................... 6.2.2 Unterklassen anlegen ................................................ 6.2.3 Sichtbarkeitsbereiche und Namensräume in der Vererbung ................................................................. 6.2.4 Methodenredefinition ............................................... 6.2.5 Abstrakte Klassen und Methoden ............................. 6.2.6 Finale Klassen und Methoden ................................... 6.2.7 Statische Attribute in der Vererbung ......................... 6.2.8 Konstruktoren in der Vererbung ................................ 6.2.9 Instanzierbarkeit in der Vererbung ............................ Interfaces ............................................................................... 6.3.1 Grundlagen ............................................................... 6.3.2 Interfaces anlegen ..................................................... 6.3.3 Implementieren von Interfaces in Klassen ................. 6.3.4 Zugriff auf Interfaces in Objekten .............................. 6.3.5 Zugriff auf statische Interfacekomponenten ............... 6.3.6 Interfaces zusammensetzen ....................................... 6.3.7 Aliasnamen für Interfacekomponenten ...................... 6.3.8 Interfaces und Vererbung .......................................... Objektreferenzen und Polymorphie ....................................... 6.4.1 Statischer und dynamischer Typ ................................ 6.4.2 Zuweisungen zwischen Referenzvariablen ................. 6.4.3 Polymorphie ............................................................. Ereignisse und Ereignisbehandlung ........................................ 6.5.1 Ereignisse deklarieren ............................................... 6.5.2 Ereignisse auslösen .................................................... 6.5.3 Ereignisbehandler ..................................................... 6.5.4 Ereignisbehandler registrieren ................................... Shared Objects ...................................................................... 6.6.1 Grundlagen – Gebiete und Co. .................................. 6.6.2 Zugriff auf Shared Objects .........................................
394 396 400 403 404 405 412 413 414 416 418 422 427 427 430 434 436 436 439 448 458 461 463 464 468 470 472 473
11
358.book Page 12 Monday, September 4, 2006 8:51 AM
Inhalt
6.6.3 6.6.4 6.6.5 6.6.6
7
Gebiet anlegen .......................................................... Sperren ..................................................................... Arbeiten mit Shared Objects ..................................... Verwaltung von Shared Objects ................................
475 478 479 485
Klassisches ABAP – Ereignisse und Prozeduren ................
489
7.1
Ereignisorientierte Programmausführung .............................. 7.1.1 Ausführbare Programme ........................................... 7.1.2 Dialogtransaktionen .................................................. 7.1.3 Vergleich der klassischen Programmausführungen ..... Prozedurale Modularisierung ................................................. 7.2.1 Funktionsbausteine ................................................... 7.2.2 Unterprogramme ......................................................
491 491 498 500 502 503 516
Fehlerbehandlung ..............................................................
523
8.1
523 523 524 525 526 546 550
7.2
8
Robuste Programme .............................................................. 8.1.1 Defensive Programmierung ....................................... 8.1.2 Ausnahmesituationen ................................................ Ausnahmebehandlung ........................................................... 8.2.1 Klassenbasierte Ausnahmebehandlung ...................... 8.2.2 Klassische Ausnahmebehandlung .............................. 8.2.3 Nachrichten in der Ausnahmebehandlung ................. 8.2.4 Kombination von klassenbasierter Ausnahme behandlung und früheren Konzepten ........................ 8.2.5 Nicht abfangbare Laufzeitfehler ................................. Assertions .............................................................................. 8.3.1 Vorteile von Assertions ............................................. 8.3.2 Anwendung von Assertions .......................................
552 555 556 556 557
GUI-Programmierung mit ABAP ........................................
559
9.1
561 562 563 565 566 572 578 582
8.2
8.3
9
12
Allgemeine Dynpros .............................................................. 9.1.1 Bildschirmbild ........................................................... 9.1.2 Dynpro-Ablauflogik ................................................... 9.1.3 Dynpros und ABAP-Programme ................................ 9.1.4 Dynpro-Folgen und Dynpro-Aufrufe .......................... 9.1.5 Dynpros anlegen ....................................................... 9.1.6 Dynpro-Felder .......................................................... 9.1.7 Funktionscodes und Funktionen ................................
358.book Page 13 Monday, September 4, 2006 8:51 AM
Inhalt
9.2
9.3
9.4
9.5
9.1.8 Kontextmenüs ........................................................... 9.1.9 Dialogmodule ........................................................... 9.1.10 Datentransport ......................................................... 9.1.11 Bedingte Modulaufrufe ............................................. 9.1.12 Eingabeüberprüfungen .............................................. 9.1.13 Feldhilfe .................................................................... 9.1.14 Eingabehilfe .............................................................. 9.1.15 Dynpros und Klassen ................................................. 9.1.16 Dynpro Controls ....................................................... 9.1.17 GUI Controls ............................................................. Selektionsbilder ..................................................................... 9.2.1 Selektionsbilder anlegen ........................................... 9.2.2 Parameter ................................................................. 9.2.3 Selektionskriterien .................................................... 9.2.4 Weitere Elemente auf Selektionsbildern .................... 9.2.5 Selektionsbilder aufrufen ........................................... 9.2.6 Selektionsbildverarbeitung ........................................ 9.2.7 Funktionen von Selektionsbildern ............................. 9.2.8 Standardselektionsbilder ........................................... 9.2.9 Selektionsbilder als Programmschnittstellen .............. Klassische Listen .................................................................... 9.3.1 Listenerstellung ......................................................... 9.3.2 Bildschirmliste ........................................................... 9.3.3 Listen in ausführbaren Programmen .......................... 9.3.4 Listen und Transaktionen .......................................... 9.3.5 Funktionen auf Listen ................................................ 9.3.6 Drucklisten ............................................................... 9.3.7 Listen in ABAP Objects ............................................. Nachrichten ........................................................................... 9.4.1 Nachrichten anlegen ................................................. 9.4.2 Nachrichten senden .................................................. 9.4.3 Nachrichtentyp ......................................................... 9.4.4 Verwendung von Nachrichten ................................... Web Dynpro ABAP ................................................................ 9.5.1 Erste Schritte mit Web Dynpro ABAP ........................ 9.5.2 Query mit Web Dynpro ABAP ................................... 9.5.3 Zusammenfassung .....................................................
589 591 593 594 595 598 600 607 626 640 672 674 675 679 685 688 689 693 697 700 704 705 706 707 708 711 715 719 727 727 728 730 732 733 735 744 767
13
358.book Page 14 Monday, September 4, 2006 8:51 AM
Inhalt
10 Arbeiten mit persistenten Daten ....................................... 10.1
769
Datenbankzugriffe ................................................................. 10.1.1 Definition von Datenbanktabellen im ABAP Dictionary ....................................................... 10.1.2 Open SQL ................................................................. 10.1.3 Konsistente Datenhaltung ......................................... 10.1.4 Spezielle Abschnitte zu Datenbankzugriffen .............. Datenbankzugriffe mit Object Services ................................... 10.2.1 Persistente Klassen anlegen ....................................... 10.2.2 Persistente Objekte verwalten ................................... 10.2.3 Objektidentität GUID ................................................ 10.2.4 Transaktionsdienst .................................................... Dateischnittstellen ................................................................. 10.3.1 Dateien des Applikationsservers ................................ 10.3.2 Dateien des Präsentationsservers .............................. Daten-Cluster ........................................................................ 10.4.1 Daten-Cluster ablegen .............................................. 10.4.2 Daten-Cluster einlesen .............................................. 10.4.3 Daten-Cluster löschen ............................................... 10.4.4 Beispiel zu Daten-Clustern ........................................ Berechtigungsprüfungen ........................................................ 10.5.1 Berechtigungsobjekte und Berechtigungen ................ 10.5.2 Berechtigungsprüfung ...............................................
772 775 808 819 825 826 829 839 841 845 846 851 855 855 857 857 858 860 860 861
11 Dynamische Programmierung ............................................
867
10.2
10.3
10.4
10.5
11.1
11.2
11.3
11.4
14
Feldsymbole und Datenreferenzen ......................................... 11.1.1 Feldsymbole .............................................................. 11.1.2 Datenreferenzen ....................................................... Run Time Type Services (RTTS) .............................................. 11.2.1 Run Time Type Information (RTTI) ............................ 11.2.2 Run Time Type Creation (RTTC) ................................. Dynamische Token-Angaben ................................................. 11.3.1 Dynamische Angaben von Operanden ....................... 11.3.2 Dynamische Angaben von Klauseln ........................... 11.3.3 Spezielle dynamische Angaben von Klauseln ............. Dynamischer Prozeduraufruf .................................................. 11.4.1 Dynamischer Methodenaufruf ................................... 11.4.2 Dynamischer Funktionsbausteinaufruf .......................
770
868 869 882 893 894 898 903 904 904 905 906 907 910
358.book Page 15 Monday, September 4, 2006 8:51 AM
Inhalt
11.5
Programmgenerierung ........................................................... 11.5.1 Transiente Programmgenerierung .............................. 11.5.2 Persistente Programmgenerierung .............................
910 912 915
12 Externe Schnittstellen ........................................................
917
12.1
12.2
12.3
12.4
12.5
Synchrone und asynchrone Kommunikation .......................... 918 12.1.1 Synchrone Kommunikation ....................................... 919 12.1.2 Asynchrone Kommunikation ..................................... 919 Remote Function Call (RFC) ................................................... 921 12.2.1 RFC-Varianten ........................................................... 922 12.2.2 RFC-Kommunikationsszenarien ................................. 926 12.2.3 RFC-Programmierung auf dem AS ABAP ................... 930 12.2.4 RFC-Programmierung einer externen RFC-Schnittstelle ....................................................... 940 12.2.5 RFC-Programmierung mit JCo ................................... 948 Internet Communication Framework (ICF) ............................. 956 12.3.1 ICF im AS ABAP ........................................................ 957 12.3.2 ICF-Server-Programmierung ...................................... 958 12.3.3 ICF-Client-Programmierung ....................................... 966 ABAP-Webservices ................................................................ 971 12.4.1 Was ist ein Webservice? ............................................ 971 12.4.2 Webservices und Enterprise SOA .............................. 972 12.4.3 Standards für Webservices ........................................ 973 12.4.4 Webservices auf dem AS ABAP ................................. 975 12.4.5 Rolle der Exchange Infrastructure .............................. 976 12.4.6 Web Service Framework ........................................... 978 12.4.7 Webservice anlegen .................................................. 978 12.4.8 Webservice freigeben ................................................ 981 12.4.9 Webservice testen ..................................................... 983 12.4.10 Webservice publizieren ............................................. 985 12.4.11 Client für Webservices anlegen ................................. 986 ABAP und XML ..................................................................... 989 12.5.1 Was ist XML? ............................................................ 990 12.5.2 Die iXML-Bibliothek ................................................. 995 12.5.3 Verwendung von XSLT .............................................. 1000 12.5.4 Verwendung von Simple Transformations .................. 1009 12.5.5 Zusammenfassung ..................................................... 1021
15
358.book Page 16 Monday, September 4, 2006 8:51 AM
Inhalt
13 Test- und Analysewerkzeuge ............................................. 1023 13.1
13.2
13.3
13.4
13.5
13.6
Statische Testverfahren .......................................................... 13.1.1 Syntaxprüfung ........................................................... 13.1.2 Erweiterte Programmprüfung .................................... 13.1.3 Code Inspector .......................................................... Programmanalyse mit dem ABAP Debugger ........................... 13.2.1 Der neue ABAP Debugger mit Zwei-ProzessArchitektur ................................................................ 13.2.2 Oberfläche des ABAP Debuggers ............................... 13.2.3 Verwendung des Debuggers ...................................... Modultests mit ABAP Unit ..................................................... 13.3.1 Was ist ein Modultest? .............................................. 13.3.2 Organisation von ABAP Unit ..................................... 13.3.3 Beispiel zur Anwendung von ABAP Unit .................... 13.3.4 Ausführung und Analyse eines Testlaufs .................... 13.3.5 ABAP Unit im Code Inspector ................................... ABAP Memory Inspector ....................................................... 13.4.1 Dynamische Speicherobjekte ..................................... 13.4.2 Speicherabzüge erstellen ........................................... 13.4.3 Arbeiten mit dem Memory Inspector ........................ ABAP-Laufzeitanalyse ............................................................ 13.5.1 Aufruf der Laufzeitanalyse ......................................... 13.5.2 Auswertung der Messdatendateien ........................... 13.5.3 Tipps & Tricks ........................................................... Weitere Testwerkzeuge ......................................................... 13.6.1 Coverage Analyzer .................................................... 13.6.2 extended Computer Aided Test Tool (eCATT) ............
1025 1026 1027 1030 1036 1036 1037 1041 1048 1048 1049 1051 1056 1058 1059 1060 1063 1065 1068 1069 1071 1072 1072 1073 1075
A Anhang ............................................................................... 1077 A.1
16
Übersicht aller ABAP-Anweisungen ....................................... A.1.1 Programmeinleitende Anweisungen ......................... A.1.2 Modularisierungsanweisungen .................................. A.1.3 Deklarative Anweisungen ......................................... A.1.4 Objekterzeugung ..................................................... A.1.5 Programmeinheiten aufrufen und verlassen .............. A.1.6 Programmablaufsteuerung ....................................... A.1.7 Zuweisungen ............................................................ A.1.8 Interne Daten verarbeiten ........................................ A.1.9 Benutzerdialoge ....................................................... A.1.10 Externe Daten bearbeiten ........................................
1077 1077 1077 1078 1079 1079 1080 1081 1081 1083 1085
358.book Page 17 Monday, September 4, 2006 8:51 AM
Inhalt
A.2 A.3 A.4 A.5 A.6 A.7 A.8
A.1.11 Programmparameter ................................................ A.1.12 Programmbearbeitung ............................................. A.1.13 ABAP-Daten- und Kommunikationsschnittstellen ..... A.1.14 Erweiterungen ......................................................... ABAP-Systemfelder ................................................................ ABAP-Programmtypen .......................................................... ABAP-Namenskonventionen .................................................. Selektoren ............................................................................. Hilfsklasse für einfache Textausgaben ..................................... Webverweise ......................................................................... Installation und Anwendung der SAP NetWeaver 2004s ABAP Trial Version ................................................................
1086 1087 1087 1088 1088 1093 1095 1095 1096 1099 1100
Die Autoren ........................................................................................... 1103 Index ...................................................................................................... 1107
17
358.book Page 369 Monday, September 4, 2006 8:51 AM
Ein Arzt, ein Hochbauingenieur und ein Informatiker unterhielten sich darüber, was der älteste Beruf der Welt sei. Der Mediziner führte an: »Schon in der Bibel heißt es, dass Gott Eva aus Adams Rippe erschaffen hat. Dafür wurde natürlich die Medizin gebraucht, und so darf ich wohl behaupten, dass ich den ältesten Beruf der Welt habe.« Der Hochbauingenieur unterbrach ihn und sagte: »Aber noch vorher im Buch Genesis heißt es, dass Gott die Ordnung des Himmels und der Erde aus dem Chaos geschaffen hat. Das war der erste und wahrscheinlich der spektakulärste Einsatz des Bauingenieurwesens. Deshalb, lieber Doktor, irren Sie sich: Ich habe den ältesten Beruf der Welt.« Der Informatiker lehnte sich in seinem Stuhl zurück, lächelte und sagte dann verbindlich: »Und wer, meine Herren, glauben Sie, hat das Chaos erschaffen?« – Grady Booch, Object- Oriented Analysis and Design with Applications
6
Weiterführende Konzepte von ABAP Objects
Dieses Zitat stammt aus dem Buch Objektorientierte Analyse und Design von Grady Booch (Addison-Wesley 1995) und leitet dort das Kapitel über »Komplexität« ein. Ein Vorteil des objektorientierten Ansatzes ist die Bewältigung der Komplexität. Sie haben in Kapitel 4 bereits Klassen und Objekte als Grundlagen der Objektorientierung sowie Attribute und Methoden als deren grundlegende Komponenten kennengelernt. Fassen wir das dort Gelernte nochmals zusammen: 왘
Objekte sind das zentrale Konzept der Objektorientierung. Ein Objekt ist eine abgeschlossene Einheit mit einem durch die Werte seiner Attribute bestimmten Zustand, einem durch seine Methoden bestimmten Verhalten und einer durch seine Adresse im Speicher festgelegten Identität. Der Zugang zu einem Objekt erfolgt über Referenzvariablen, die auf diese Adresse zeigen. Ein Objekt in einem Programm, das eine Aufgabe löst, sollte ein reales Objekt der Aufgabe möglichst eins zu eins wiedergeben. Bei
369
Grundlagen
358.book Page 370 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
einem Objekt kann klar eine öffentliche Schnittstelle von den privaten und geschützten, also nach außen unsichtbaren, Komponenten unterschieden werden. Ein Objekt kann mit einem anderen interagieren, indem es in einer Methode direkt auf ihm sichtbare Attribute zugreift, Methoden aufruft oder ein Ereignis auslöst (siehe Abschnitt 6.5.2). 왘
Klassen sind Quelltext, der die Definition von möglichen Objekten enthält. Ein Objekt ist immer eine Instanz einer Klasse, die von mindestens einer Referenzvariablen adressiert wird. In einer Klasse sind alle Komponenten und Eigenschaften ihrer Objekte deklariert. Die Grundlage der Kapselung in ABAP Objects ist immer die Klasse, nicht das Objekt.1 Klassen sind entweder global für alle Programme oder lokal in einem Programm. Sie können durch Vererbung spezialisiert werden (siehe Abschnitt 6.2), und sie können als öffentliche Schnittstelle eigenständige Interfaces einbinden (siehe Abschnitt 6.3).
왘
Attribute beschreiben den Zustand eines Objekts. Technisch gesehen sind Attribute (Instanzattribute) die lokalen Variablen eines Objekts, die in der Regel nicht direkt von außen änderbar sein sollten. Zusätzlich kann eine Klasse statische Attribute enthalten, die von allen Objekten der Klasse gemeinsam verwendet werden. Neben Variablen können statische Attribute auch Konstanten sein.
왘
Methoden ermöglichen es Objekten, Operationen auszuführen. Eine Methode (Instanzmethode) arbeitet immer in einem bestimmten Objekt, d.h., sie liest und ändert dessen Zustand und kann mit anderen Objekten durch Aufruf von deren Methoden oder das Auslösen von Ereignissen interagieren. Eine Methode hat eine Parameterschnittstelle (siehe Abschnitt 6.1.1) und kann Ausnahmen weiterreichen (siehe Abschnitt 8.2). Zusätzlich kann eine Klasse statische Methoden enthalten, die nur auf statische Attribute zugreifen und statische Ereignisse auslösen können.
Vielleicht haben Sie schon erkannt, wie mächtig der Einsatz allein dieser Bestandteile von ABAP Objects bei der Programmierung von Anwendungsprogrammen sein kann. Diese Grundelemente sind jedoch bei weitem noch nicht alles, was mit ABAP Objects möglich ist. In diesem Kapitel werden wir Sie mit weiteren Konzepten 1
Für ein Objekt einer Klasse sind die privaten Komponenten eines anderen Objekts der gleichen Klasse sichtbar.
370
358.book Page 371 Monday, September 4, 2006 8:51 AM
Weiterführende Konzepte von ABAP Objects
6
bekannt machen, die für das fortgeschrittene objektorientierte Design absolut notwendig sind: 왘
Methodenschnittstellen und Methodenaufrufe In Kapitel 4 haben wir Methoden bereits in ihrer fundamentalen Rolle als die operationalen Komponenten von Klassen eingeführt. In Abschnitt 6.1.1 untersuchen wir die Parameterschnittstelle von Methoden etwas genauer und gehen außerdem auf die verschiedenen Möglichkeiten des Methodenaufrufs ein.
왘
Spezialisierung durch Vererbung ABAP Objects unterstützt die Einfachvererbung, in der eine Klasse als direkte Unterklasse genau einer Oberklasse deklariert werden kann. Alle Klassen von ABAP Objects sind Teil einer baumartigen Vererbungshierarchie, die von einer gemeinsamen Oberklasse ausgeht. Eine Unterklasse enthält neben ihren eigenen Komponenten die Komponenten ihrer direkten Oberklasse, die wiederum die Komponenten ihrer Oberklasse enthält. Die Implementierung von Oberklassenmethoden kann in Unterklassen überschrieben werden. Wir beschreiben das Konzept der Vererbung in Abschnitt 6.2.
왘
Eigenständige Interfaces Der öffentliche Sichtbarkeitsbereich einer Klasse ist deren Schnittstelle nach außen. ABAP Objects erlaubt es Ihnen, eigenständige Interfaces anzulegen, die von Klassen als Teil ihrer Schnittstelle oder sogar als ihre gesamte Schnittstelle verwendet werden können. Objekte verschiedener Klassen, die das gleiche Interface verwenden, können von außen gleichartig behandelt werden. Ein eigenständiges Interface kann auch aus mehreren anderen Interfaces zusammengesetzt sein. Wir beschreiben das Konzept von Interfaces in Abschnitt 6.3.
왘
Objektreferenzvariablen und Polymorphie Der Zugang zu Objekten in einem Programm erfolgt ausschließlich über Objektreferenzen in Objektreferenzvariablen, wobei der Typ der Objektreferenzvariablen festlegt, was ein Programm mit einem Objekt anfangen kann. Neben Klassenreferenzvariablen gibt es auch Interfacereferenzvariablen, die exklusiven Zugang zu den Interfacekomponenten einer Klasse erlauben. Die Konzepte von Vererbung und von eigenständigen Interfaces erlauben die Zuweisung von Objektreferenzen zwischen Referenzvariablen
371
Fortgeschrittene Konzepte
358.book Page 372 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
unterschiedlicher Typen nach bestimmten Regeln. Dies öffnet das Feld der Polymorphie, in der über ein und dieselbe Referenzvariable auf Objekte unterschiedlicher Klassen mit unterschiedlichem Verhalten zugegriffen werden kann. Dies beschreiben wir in Abschnitt 6.4. 왘
Ereignisse und Ereignisbehandlung Eine Methode eines Objekts wird meistens nach einem direkten Aufruf ausgeführt. Dabei sind aufrufendes und aufgerufenes Objekt eng gekoppelt. Ereignisse dienen der Entkopplung von Aufrufer und aufgerufener Methode. In ABAP Objects sind Ereignisse neben Attributen und Methoden eine weitere Komponentenart von Klassen. Ein Objekt kann in einer Methode ein solches Ereignis auslösen, und Methoden anderer Objekte können das Ereignis behandeln, was einem indirekten Methodenaufruf entspricht, da der Aufrufer nichts über eventuelle Behandler wissen muss. Wir beschreiben das Ereigniskonzept in Abschnitt 6.5.
왘
Shared Objects Objekte als Instanzen von Klassen leben im Speicherbereich eines Programms und werden spätestens mit Beendigung des Programms aus dem Speicher gelöscht. Aus diesem Grund kann normalerweise nicht programmübergreifend auf Objekte zugegriffen werden. Für den programmübergreifenden Zugriff bietet ABAP Objects die so genannten Shared Objects an. Das sind Objekte im Shared Memory eines Applikationsservers. Wir beschreiben Shared Objects in Abschnitt 6.6.
Die grundlegenden Konzepte von ABAP Objects, die wir Ihnen in Kapitel 4 vorgestellt haben, also Klassen mit Attributen und Methoden, Objekte und Objektreferenzen, finden Sie in fast jeder objektorientierten Programmiersprache. Die fortgeschrittenen Konzepte dieses Kapitels sind zum einen eine Auswahl bewährter fortgeschrittener Techniken, die ABAP Objects anhand der Vorbilder gängiger objektorientierter Programmiersprachen wie Java oder C++ übernommen hat, und zum anderen handelt es sich um spezielle Techniken, die es so nur in ABAP Objects gibt. Beim Design der Sprache wurde darauf geachtet, dass der Fokus auf betriebswirtschaftliche Anwendungen nicht verloren ging. ASAP-Prinzip
Durch einige Konzepte der objektorientierten Programmierung, wie Mehrfachvererbung, die wir z.B. in C++ finden, wäre nur die Kom-
372
358.book Page 373 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
plexität der Sprache gestiegen, ohne dass viel zusätzlicher Nutzen für SAP-Anwendungen gewonnen worden wäre. Ganz nach dem ASAPPrinzip, also »As Simple As Possible«, wurde ABAP Objects so verständlich wie möglich umgesetzt, wobei nur bewährte objektorientierte Konzepte zum Einsatz kamen. Das Interfacekonzept wurde dem Beispiel von Java folgend als Ersatz für die Mehrfachvererbung eingeführt. Die richtige Anwendung von Vererbung und Interfaces stellt die Krönung der objektorientierten Programmierung dar und erlaubt Ihnen vielfache Möglichkeiten zur Bewältigung der Komplexität.2 Die Vielfalt der Möglichkeiten, eine Parameterschnittstelle von Methoden zu definieren, ist dagegen eine ABAP-Spezialität. Genauso ist das Konzept, Ereignisse als eigenständige Komponenten von Klassen vollständig in den Sprachumfang von ABAP Objects zu integrieren, nicht in allen objektorientierten Programmiersprachen enthalten.
6.1
Methodenschnittstellen und Methodenaufrufe
In den vorausgegangenen Kapiteln haben wir schon häufig Methoden definiert und aufgerufen. Die folgenden beiden Abschnitte führen in die Feinheiten von Methoden in ABAP Objects ein.
6.1.1
Parameterschnittstelle von Methoden
Die Parameterschnittstelle einer Methode wird bei der Deklaration der Methode durch die Zusätze der Anweisungen METHODS und CLASS-METHODS bzw. durch die Auswahl von Parameter im Class Builder definiert. Im Implementierungsteil zwischen METHOD und ENDMETHOD sind keine weiteren Angaben zur Parameterschnittstelle nötig. Bei globalen Klassen kann man sich aber die Schnittstelle während der Implementierung anzeigen lassen. 2
Wir wollen aber auch nicht verschweigen, dass eine falsche oder falsch verstandene Verwendung von Konzepten wie der Vererbung zu großen Problemen führen kann. Gerade wenn komplexe Anwendungen durch die weiterführenden Konzepte der Objektorientierung bewältigt werden sollen, ist eine sorgfältige objektorientierte Modellierung unabdingbar.
373
6.1
358.book Page 374 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Formalparameter
Die Parameterschnittstelle einer Methode umfasst Formalparameter und Ausnahmen. Auf die Deklaration von Ausnahmen gehen wir in Abschnitt 8.2 ein. Formalparameter sind Schlüsselwortparameter, an die beim Aufruf der Methode ein Aktualparameter angebunden werden muss oder kann. Formalparameter können innerhalb der Methode über ihren Namen an Operandenpositionen verwendet werden, wobei die Art der Verwendung von den Parametereigenschaften abhängt. Für einen Formalparameter können folgende Eigenschaften festgelegt werden: 왘
Art des Parameters
왘
Übergabeart für den Parameter
왘
Typisierung des Parameters
왘
Versorgungsart des Parameters
Prinzipiell kann eine Parameterschnittstelle fast beliebig viele Parameter enthalten. Als Richtlinie sollte aber eine schmale Schnittstelle gelten. Die ideale Parameterschnittstelle enthält keine, einen oder nur wenige Eingabeparameter und einen Rückgabewert. Keine Überladung
An dieser Stelle sei auch angemerkt, dass Methoden in ABAP Objects nicht überladen werden können. D.h., Sie können nicht den gleichen Methodennamen mit unterschiedlichen Parameterschnittstellen verwenden, auch nicht bei der Redefinition in Unterklassen.
Parameterart Sie können folgende Parameter definieren: 왘
Eingabeparameter Eingabeparameter werden hinter dem Zusatz IMPORTING der Anweisungen METHODS oder CLASS-METHODS aufgelistet bzw. durch die Auswahl von Importing in der Spalte Art auf der ParameterRegisterkarte des Class Builder deklariert. Einem Eingabeparameter wird bei Aufruf der Methode der Wert des zugeordneten Aktualparameters zugewiesen. Eingabeparameter, für die die Referenzübergabe definiert ist, dürfen in der Methode nicht überschrieben werden. Eingabeparameter, für die die Wertübergabe definiert ist, werden beim Verlassen der Prozedur nicht an den Aktualparameter übergeben.
374
358.book Page 375 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
왘
Ausgabeparameter Ausgabeparameter werden hinter dem Zusatz EXPORTING der Anweisungen METHODS oder CLASS-METHODS aufgelistet bzw. durch die Auswahl von Exporting in der Spalte Art auf der ParameterRegisterkarte des Class Builder deklariert. Einem Ausgabeparameter, für den die Wertübergabe definiert ist, wird bei Aufruf der Methode nicht der Wert des zugeordneten Aktualparameters zugewiesen. Ausgabeparameter dürfen in der Methode überschrieben werden. Ein Ausgabeparameter wird beim fehlerfreien Verlassen der Methode über ENDMETHOD oder RETURN der Prozedur an den Aktualparameter übergeben.
왘
Ein-/Ausgabeparameter Ein-/Ausgabeparameter werden hinter dem Zusatz CHANGING der Anweisungen METHODS oder CLASS-METHODS aufgelistet bzw. durch die Auswahl von Changing in der Spalte Art auf der ParameterRegisterkarte des Class Builder deklariert. Einem Ein-/Ausgabeparameter wird bei Aufruf der Methode der Wert des zugeordneten Aktualparameters zugewiesen, und er wird beim fehlerfreien Verlassen der Methode über ENDMETHOD oder RETURN an den Aktualparameter übergeben. Ein-/Ausgabeparameter dürfen in der Methode überschrieben werden.
왘
Rückgabewert Eine Methode kann genau einen hinter dem Zusatz RETURNING der Anweisungen METHODS oder CLASS-METHODS bzw. durch die Auswahl von Returning in der Spalte Art auf der Parameter-Registerkarte des Class Builder deklarierten Rückgabewert haben, für den die Wertübergabe deklariert sein muss. In der Methode wird ein Rückgabewert wie ein Ausgabeparameter behandelt. Eine Methode mit einem Rückgabewert ist aber eine funktionale Methode, die außer dem Rückgabewert nur Eingabeparameter haben kann. Eine funktionale Methode kann an Operandenpositionen eingesetzt werden, an denen dann der Rückgabewert verwendet wird.3
3
Funktionale Methoden – nicht Funktionsbausteine – sind die natürliche Erweiterung der eingebauten Funktionen (siehe Abschnitt 5.2.4) um selbst definierte Funktionen, so wie selbst definierte Datentypen die eingebauten ABAP-Typen erweitern.
375
Funktionale Methode
6.1
358.book Page 376 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Wählen Sie beim Deklarieren von Parametern immer die Art, die genau zum Verhalten des Parameters passt. Ein Parameter, der von der Methode nur entgegengenommen, aber nicht geändert wird, ist ein Eingabeparameter. Ein Parameter, der nur ausgegeben, aber nicht entgegengenommen wird, ist ein Ausgabeparameter oder ein Rückgabewert. Ein Parameter, der entgegengenommen, geändert und ausgegeben wird, ist ein Ein-/Ausgabeparameter. Das klingt zwar selbstverständlich, Sie werden aber gleich sehen, dass sich Parameter technisch gesehen nicht unbedingt so verhalten müssen, wie es ihrer Art entspräche.
Übergabeart Bis auf den Rückgabewert, für den die Wertübergabe fest vorgeschrieben ist, können Sie für jeden einzelnen Parameter die Übergabeart entweder als Referenzübergabe oder als Wertübergabe definieren. Die Syntax für die Referenzübergabe am Beispiel eines Eingabeparameters ipara ist: REFERENCE
METHODS meth IMPORTING ipara ...
oder gleichbedeutend auch METHODS meth IMPORTING REFERENCE(ipara) ...
Die Syntax für die Wertübergabe am Beispiel des Rückgabewerts return ist: VALUE
METHODS meth RETURNING VALUE(return) ...
Im Class Builder legen Sie die Übergabeart dadurch fest, dass Sie das Ankreuzfeld Wertübergabe auf der Parameter-Registerkarte des Class Builder ankreuzen oder nicht. Sowohl in der Syntax als auch im Class Builder ist die Referenzübergabe also der Standard, der verwendet wird, wenn nichts angegeben ist. Was ist nun der Unterschied zwischen den Übergabearten? 왘
Referenzübergabe Bei der Referenzübergabe bekommt die Methode bei ihrem Aufruf unabhängig von der Parameterart für jeden Formalparameter, für den ein Aktualparameter angegeben ist, eine Referenz auf den
376
358.book Page 377 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
6.1
Aktualparameter übergeben und arbeitet dadurch mit dem Aktualparameter selbst. Änderungen am Formalparameter wirken unmittelbar auf den Aktualparameter. 왘
Wertübergabe Bei der Wertübergabe wird beim Aufruf der Methode für jeden Formalparameter ein lokales Datenobjekt als Kopie des Aktualparameters angelegt, das bei Eingabeparametern und Ein-/Ausgabeparametern dessen Wert zugewiesen bekommt. Nur bei fehlerfreier Beendigung der Methode über ENDMETHOD oder RETURN bekommen Ausgabeparameter, Ein-/Ausgabeparameter und Rückgabewerte den Wert des Formalparameters zugewiesen.
Die Übergabeart ist eine technische Eigenschaft, die das Verhalten eines Formalparameters festlegt. Nur bei der Wertübergabe entspricht das tatsächliche Verhalten immer dem durch die Parameterart definierten Verhalten. Bei der Referenzübergabe 왘
sind Ausgabeparameter zu Beginn der Methode also nicht unbedingt initial (Ausgabeparameter verhalten sich wie Ein-/Ausgabeparameter)
왘
sind Änderungen an Ausgabeparametern und Ein-/Ausgabeparametern auch beim Abbruch der Methode durch eine Ausnahme wirksam
왘
dürfen per Referenz übergebene Eingabeparameter zwar nicht explizit in der Methode verändert werden, können aber durch Anbindung an globale Aktualparameter ihren Wert ändern, wenn diese während der Ausführung der Methode geändert werden
Aus diesem Grund sollte eine Methode immer so programmiert werden, dass das Verhalten ihrer Parameter der durch die Parameterart festgelegten Semantik entspricht: 왘
Führen Sie keinen Lesezugriff auf einen per Referenz übergebenen Ausgabeparameter aus, da sein Startwert nicht festgelegt ist.
왘
Wenn Sie Zeilen an eine interne Tabelle anhängen oder einen String verlängern, der als per Referenz übergebener Ausgabeparameter definiert ist, initialisieren Sie den Parameter vor dem ersten Zugriff.
왘
Überlegen Sie, auf welchen Wert Sie per Referenz übergebene Ausgabeparameter oder Ein-/Ausgabeparameter vor dem Auslö-
377
Parameterart vs. Übergabeart
358.book Page 378 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
sen einer Ausnahme setzen, damit ein Aufrufer eine adäquate Ausnahmebehandlung durchführen kann. Referenzübergabe vs. Wertübergabe
Bei der Referenzübergabe sind also ein paar Vorsichtsmaßnahmen zu treffen, die es bei der Wertübergabe nicht gibt. Warum gibt es die Referenzübergabe dann überhaupt? Die Antwort liegt in der Performance.
Performance vs. Robustheit
Eine Referenzübergabe ist in ABAP immer performanter als die Wertübergabe, da beim Prozeduraufruf kein lokales Datenobjekt angelegt werden muss und kein Datentransport stattfindet. Aus Performancegründen ist die Referenzübergabe der Wertübergabe in der Regel meistens vorzuziehen, es sei denn, in der Prozedur muss ein expliziter oder impliziter Schreibzugriff auf einen Eingabeparameter stattfinden, oder man will sicherstellen, dass ein Ausgabeparameter bzw. ein Ein-/Ausgabeparameter nur bei fehlerfreier Beendigung der Prozedur zurückgegeben wird. Solche Fälle sollten, wenn möglich, auf die Übergabe von Parametern mit einer Größe von kleiner etwa 100 Byte beschränkt werden.4 Das Beispiel in Listing 6.1 zeigt eine kleine und wahrscheinlich unerwartete Falle, in die man bei der unüberlegten Verwendung der Referenzübergabe tappen kann. Listing 6.1 Übergabeart von Formalparametern REPORT z_parameter_passing. CLASS demo DEFINITION CREATE PRIVATE. PUBLIC SECTION. CLASS-METHODS main. PRIVATE SECTION. METHODS: meth1 IMPORTING value(idx) TYPE i, meth2 IMPORTING reference(idx) TYPE i. DATA msg TYPE string. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main.
4
Bei Strings und internen Tabellen kann der Performance-Nachteil der Wertgegenüber der Referenzübergabe sogar durch deren eingebaute Copy-on-WriteSemantik (Sharing, siehe Abschnitt 5.1.7) aufgehoben werden. Dies gilt insbesondere für Eingabeparameter, solange sie nicht geändert werden.
378
358.book Page 379 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
DATA oref TYPE REF TO demo. CREATE OBJECT oref. DO 2 TIMES. oref->meth1( sy-index ). oref->meth2( sy-index ). ENDDO. ENDMETHOD. METHOD meth1. DO 3 TIMES. msg = idx. CONCATENATE `meth1: ` msg INTO msg. MESSAGE msg TYPE 'I'. ENDDO. ENDMETHOD. METHOD meth2. DO 3 TIMES. msg = idx. CONCATENATE `meth2: ` msg INTO msg. MESSAGE msg TYPE 'I'. ENDDO. ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
In der Methode main werden zwei Methoden mit identischer Implementierung in einer DO-Schleife aufgerufen. Die erste Methode meth1 gibt wie erwartet dreimal den per Wert übergebenen Inhalt von syindex aus, also »1«, »1«, »1« während des ersten und »2«, »2«, »2« während des zweiten Aufrufs. Die zweite Methode meth2 gibt bei beiden Aufrufen »1«, »2«, »3« aus. Die DO-Schleife in meth1 und meth2 setzt das globale Systemfeld sy-index und damit in meth2 den per Referenz übergebenen Formalparameter idx! Die Methode mit der Wertübergabe ist also robuster. Das Beispiel zeigt aber auch, dass globale Parameter wie Systemfelder, deren Änderung nicht der direkten Kontrolle einer Methode unterliegen, auch von Aufruferseite nicht einfach so an Methoden übergeben werden sollten. Durch Einführung einer lokalen Hilfsvariablen in main, der sy-index zugewiesen und die dann an meth2 übergeben wird, würde auch meth2 das erwartete Ergebnis liefern.
379
6.1
358.book Page 380 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Typisierung Sie müssen jeden Formalparameter einer Methode typisieren. Mit Typisierung ist gemeint, dass Sie einem Formalparameter einen Typ zuordnen. Die Syntax hierfür ist ähnlich wie bei der Datendeklaration ein TYPE- oder LIKE-Zusatz, den Sie hinter jedem Formalparameter angeben müssen, also z.B.: METHODS meth EXPORTING opara TYPE dtype ...
Bei lokalen Klassen kann jeder an dieser Stelle sichtbare Typ angegeben werden. Im Class Builder geben Sie den Typ durch Eingabe in die Spalten Typisierung (Type, Type Ref To oder Like) und Bezugstyp auf der Parameter-Registerkarte an. Da der angegebene Typ auch für jeden Verwender der Methode zugänglich sein muss, können für öffentliche Methoden nur eingebaute ABAP-Typen, globale Typen aus dem ABAP Dictionary oder Typen aus dem öffentlichen Sichtbarkeitsbereich einer globalen Klasse angegeben werden. Bei geschützten Methoden sind zusätzlich Typen aus dem geschützten Sichtbarkeitsbereich der Klasse und bei privaten Methoden Typen aus dem privaten Sichtbarkeitsbereich sowie lokale Typen des Class-Pools möglich. Das Besondere an der Typisierung im Vergleich zu einer Datendeklaration ist, dass ein Formalparameter seinen tatsächlichen Datentyp erst in dem Moment erhält, in dem er bei einem Methodenaufruf an einen Aktualparameter gebunden wird. Der Formalparameter übernimmt dann sämtliche technischen Eigenschaften des Aktualparameters. Überprüfung der Typisierung
Damit ein Aktualparameter übergeben werden kann, muss sein Datentyp zur Typisierung des Formalparameters passen. Genauer gesagt, müssen seine technischen Typeigenschaften kompatibel zum Datentyp sein, der für die Typisierung verwendet wurde. Die technischen Eigenschaften eines Elementartyps sind der eingebaute ABAPTyp (c, d, f, i, n, p, t, string, x, xstring), die Länge (bei c, n, p, x) und die Anzahl der Nachkommastellen (für p). Die technische Eigenschaft eines strukturierten Typs ist sein Aufbau aus Unterstrukturen und elementaren Komponenten, wobei die Komponentennamen aber irrelevant sind. Die technischen Eigenschaften einer internen Tabelle sind die Tabellenart (STANDARD, HASHED, SORTED), der Zeilentyp und der Tabellenschlüssel.
380
358.book Page 381 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
Die Typisierung eines Formalparameters kann vollständig oder generisch sein. Für die vollständige Typisierung beziehen Sie sich mit TYPE auf einen vollständigen Datentyp oder mit LIKE auf ein Datenobjekt. Für die generische Typisierung können Sie die eingebauten generischen Typen (any, any table, c, clike, csequence, data, hashed table, index table, n, numeric, object, simple, sorted table, standard table, table, x, xsequence) verwenden (siehe Abschnitt 5.1.9). Weiterhin sind auch interne Tabellentypen generisch, wenn der Tabellenschlüssel nicht komplett definiert ist.
Generische Typisierung
Während vollständig typisierte Formalparameter in der Methode immer wie lokale Datenobjekte dieses Typs betrachtet werden können, bei denen alle Typeigenschaften bekannt sind, unterscheiden sich generische Typen hinsichtlich des statischen und des dynamischen Zugriffs. Nur bei statischem Zugriff werden die zur Typisierung verwendeten Typeigenschaften verwendet. Beim dynamischen Zugriff5 werden die Typeigenschaften des angebundenen Aktualparameters verwendet. Diese können sich in den nicht-technischen Eigenschaften, wie z.B. Komponentennamen, von der Typisierung unterscheiden. Neben ihrer Rolle zur Überprüfung des Datentyps eines angebundenen Aktualparameters definiert die Typisierung, wie der Formalparameter als Operand von Anweisungen in der Methode verwendet werden kann. Mit einer Ausnahme können Formalparameter in allen Operandenpositionen eingesetzt werden, die nicht durch die Typisierung ausgeschlossen werden. Beispielsweise kann ein generisch mit any typisierter Formalparameter beliebig einem ebensolchen Formalparameter zugewiesen werden. Wenn dann zur Laufzeit Typen aufeinander treffen, für die es keine Konvertierungsregel gibt (siehe Abschnitt 5.2.2), kommt es zu einer Ausnahme. Die Ausnahme von dieser Regel sind interne Tabellen: Tabellenzugriffe sind nur auf Formalparameter erlaubt, die entsprechend typisiert sind. Das Beispiel in Listing 6.2 zeigt verschiedene Typisierungen und ihre Auswirkungen auf die Verwendung der Formalparameter in den Methoden.
5
Wie z.B. der dynamische Zugriff auf eine Komponente bei einer Operation auf einer internen Tabelle.
381
Operandenposition
6.1
358.book Page 382 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Listing 6.2 Typisierung von Formalparametern REPORT z_parameter_typing. CLASS demo DEFINITION. PUBLIC SECTION. METHODS: meth1 IMPORTING ipar TYPE any, meth2 IMPORTING ipar TYPE any table, meth3 IMPORTING ipar TYPE index table. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD meth1. DATA num TYPE string. num = ipar. "READ TABLE ipar INDEX 1 " TRANSPORTING NO FIELDS. "READ TABLE ipar WITH KEY table_line = '...' " TRANSPORTING NO FIELDS. ENDMETHOD. METHOD meth2. DATA num TYPE string. "num = ipar. "READ TABLE ipar INDEX 1 " TRANSPORTING NO FIELDS. READ TABLE ipar WITH KEY table_line = '...' TRANSPORTING NO FIELDS. ENDMETHOD. METHOD meth3. DATA num TYPE string. "num = ipar. READ TABLE ipar WITH KEY table_line = '...' TRANSPORTING NO FIELDS. READ TABLE ipar INDEX 1 TRANSPORTING NO FIELDS. ENDMETHOD. ENDCLASS.
In den Methoden sind drei denkbare Verwendungen des Eingabeparameters aufgeführt, wobei Anweisungen, die für die jeweilige Typisierung zu Syntaxfehlern führen, auskommentiert sind: 왘
Der Eingabeparameter ipar von Methode meth1 ist vollständig generisch typisiert. Er kann der lokalen Variablen num zugewiesen werden. Es können aber keine Leseoperationen für interne Tabellen ausgeführt werden. Beim Methodenaufruf können beliebige
382
358.book Page 383 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
6.1
Datenobjekte an den Formalparameter übergeben werden. Würde aber eine interne Tabelle übergeben, käme es bei der Zuweisung an num zu einer Ausnahme. 왘
Der Eingabeparameter ipar von Methode meth2 ist mit einer bezüglich Tabellenart, Zeilentyp und Tabellenschlüssel generischen internen Tabelle typisiert. Er kann nicht der lokalen Variablen num zugewiesen werden. Es können nur Schlüsselzugriffe für interne Tabellen ausgeführt werden, da nur diese bei allen Tabellenarten möglich sind. Beim Methodenaufruf können beliebige interne Tabellen an den Formalparameter übergeben werden.
왘
Der Eingabeparameter ipar von Methode meth3 ist mit einer bezüglich Zeilentyp und Tabellenschlüssel generischen Indextabelle typisiert. Er kann nicht der lokalen Variablen num zugewiesen werden. Es können aber alle Zugriffe für interne Tabellen ausgeführt werden, da bei Indextabellen Schlüssel- und Indexzugriffe möglich sind. Beim Methodenaufruf können nur Indextabellen, aber keine Hash-Tabellen an den Formalparameter übergeben werden.
Formalparameter sollten möglichst passend typisiert werden. Die Typisierung muss sowohl den Anforderungen der Implementierung als auch den Erwartungen der Aufrufer gerecht werden. Wenn Sie generisch typisieren wollen oder müssen, bleiben Sie immer so spezifisch wie möglich. Verwenden Sie generische Typen wie csequence, numeric, simple und xsequence statt any. Beispielsweise ist in der Regel csequence angemessen, wenn Sie eine Textverarbeitung anbieten. Genauso sind standard table, sorted table, index table oder hashed table gegenüber any table empfohlen. Je generischer Sie typisieren, desto umsichtiger müssen Sie bei der Verwendung des Formalparameters in der Implementierung sein, um Ausnahmen zu vermeiden. Dementsprechend müssten Zuweisungen völlig generisch typisierter Formalparameter vermieden werden, wenn Sie nicht vorher eine Überprüfung des Typs zur Laufzeit vornehmen (siehe Abschnitt 11.2) oder mögliche Ausnahmen behandeln (siehe Abschnitt 8.2) wollen. Falls generische Typisierung nicht notwendig ist, typisieren Sie immer vollständig. Nur vollständig typisierte Formalparameter verhalten sich immer gleich und können lokal getestet werden. Achten Sie insbesondere darauf, nicht aus Versehen generisch zu typisieren,
383
Generisch vs. vollständig
358.book Page 384 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
wenn eigentlich vollständige Typisierung gewünscht ist. Eine gängige Falle sind dabei interne Tabellentypen mit generischem Schlüssel.
Versorgungsart Für jeden Formalparameter, der einen Wert erwartet, d.h. Eingabeparameter und Ein-/Ausgabeparameter, muss standardmäßig beim Methodenaufruf ein Aktualparameter angegeben werden. Die Zuordnung von Aktualparametern an Ausgabeparameter und Rückgabewerte ist immer optional. Für Eingabeparameter und Ein-/Ausgabeparameter kann diese Regel dadurch aufgehoben werden, dass ein solcher Parameter als optional deklariert wird. Die Syntax am Beispiel eines Ein-/Ausgabeparameters ist: OPTIONAL
METHODS meth CHANGING cpara TYPE dtype OPTIONAL ...
oder DEFAULT
METHODS meth CHANGING cpara TYPE dtype DEFAULT dobj ...
Für einen so deklarierten Formalparameter muss beim Methodenaufruf kein Aktualparameter angegeben werden. Ein Formalparameter mit dem Zusatz OPTIONAL wird typgerecht initialisiert. Beim Zusatz DEFAULT werden Wert und Typ eines passend angegebenen Ersatzparameters dobj übernommen. Im Class Builder machen Sie einen Formalparameter durch Markierung der Spalte Optional bzw. durch Eingabe eines Werts in die Spalte Defaultwert optional. Wir empfehlen, alle Formalparameter optional zu machen, bis auf solche, bei denen tatsächlich bei jedem Aufruf der Methode eine andere Eingabe notwendig ist. Anderenfalls zwingen Sie Ihre Aufrufer dazu, unnötige Aktualparameter anzugeben, für die häufig sogar typgerechte Hilfsvariablen angelegt werden müssen. Sorgen Sie dafür, dass optionale Parameter immer passend initialisiert werden. Mit dem speziellen Prädikat ... IS SUPPLIED ...
384
358.book Page 385 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
6.1
können Sie in der Methode sogar über einen logischen Ausdruck darauf reagieren, ob einem optionalen Parameter ein Aktualparameter zugeordnet ist oder nicht.
6.1.2
Methodenaufrufe
Dieser Abschnitt fasst die Möglichkeiten zusammen, wie Methoden statisch aufgerufen werden können. Daneben gibt es auch die Möglichkeit des dynamischen Methodenaufrufs (siehe Abschnitt 11.4). Beim Aufruf einer Methode müssen an alle nicht-optionalen Formalparameter, d.h. alle Eingabe- und Ein-/Ausgabeparameter, die nicht als optional gekennzeichnet sind, Aktualparameter übergeben werden. An optionale Formalparameter können Aktualparameter angebunden werden. Die Aktualparameter müssen zur Typisierung der Formalparameter passen. Wir stellen die statischen Methodenaufrufe in Abhängigkeit von der Komplexität der Methodenschnittstelle dar.
Statische Methodenaufrufe Die einfachste Methode hat keine Schnittstellenparameter. Dementsprechend einfach ist der Methodenaufruf. Die Anweisung ist: Kein Parameter
meth( ).
Mit meth geben Sie die Methode so an, wie Sie sie als Komponente einer Klasse bzw. eines Objekts an der aktuellen Stelle adressieren können, d.h. direkt mit ihrem Namen meth in einer Methode der gleichen Klasse, oder mit oref->meth bzw. class=>meth überall dort, wo die Methode sichtbar ist. Wenn die Methode einen nicht-optionalen Eingabeparameter hat, ist die Anweisung: Ein Eingabeparameter
meth( dobj ).
Dabei wird das Datenobjekt dobj als Aktualparameter an den Eingabeparameter übergeben. Wenn die Methode mehrere Eingabeparameter hat, ist die Anweisung: Mehrere Eingabeparameter
meth( i1 = dobj1 i2 = dobj2 ... ).
385
358.book Page 386 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Jedem Eingabeparameter wird explizit ein Datenobjekt zugeordnet. Wenn beliebigen Formalparametern Aktualparameter zugeordnet werden sollen, ist die Syntax wie folgt: Beliebige Parameter
meth( EXPORTING i1 = dobj1 i2 = dobj2 ... IMPORTING o1 = dobj1 o2 = dobj2 ... CHANGING c1 = dobj1 c2 = dobj2 ... ).
Mit EXPORTING versorgen Sie die mit IMPORTING definierten Eingabeparameter. Mit IMPORTING nehmen Sie Werte von mit EXPORTING definierten Ausgabeparametern entgegen. Mit CHANGING ordnen Sie die Aktualparameter den mit CHANGING definierten Ein-/Ausgabeparametern zu. Das Gleichheitszeichen ist hier kein Zuweisungsoperator, sondern dient der Anbindung von Aktual- an Formalparameter. Diese Syntax umfasst die vorhergehenden Kurzformen und kann natürlich auch statt diesen verwendet werden. Schließlich und endlich können auch noch alle der vorhergehenden Syntaxformen mit einem CALL METHOD ver(un)ziert werden, also z.B.: CALL METHOD
CALL METHOD meth( i1 = dobj1 i2 = dobj2 ... ).
Diese Angabe ist aber nichts als unnötiges syntaktisches Rauschen und kann (ab Release 6.10) ruhig weggelassen werden.6
Funktionaler Methodenaufruf Ihnen wird aufgefallen sein, dass wir bei den genannten Methodenaufrufen nichts zum RETURNING-Parameter einer funktionalen Methode gesagt haben.7 Dies liegt daran, dass funktionale Methoden zum Einsatz an Operandenpositionen vorgesehen sind. Es gibt zwar auch eine eigene Anweisung zum Aufruf einer funktionalen Methode: RETURNINGParameter
meth( EXPORTING i1 = dobj1 i2 = dobj2 ... RECEIVING r = dobj ).
6 7
Das Sprachelement CALL METHOD wird nur noch beim dynamischen Methodenaufruf benötigt. Zur Erinnerung: Eine funktionale Methode hat beliebig viele Eingabeparameter und genau einen per Wert übergebenen Rückgabewert.
386
358.book Page 387 Monday, September 4, 2006 8:51 AM
Methodenschnittstellen und Methodenaufrufe
Dabei nimmt RECEIVING den Rückgabewert in dobj entgegen. Diese Anweisung wird in der Praxis aber selten bis gar nicht verwendet. Das funktionale Pendant zu obigem Aufruf ist: dobj = meth( i1 = dobj1 i2 = dobj2 ... ).
Der Aufruf der funktionalen Methode kann ohne Angabe von RECEIVING an einer Operandenposition, hier das Quellfeld einer Zuweisung, aufgeführt werden. Bei Ausführung der Anweisung wird die Methode aufgerufen und der Rückgabewert als Operand verwendet. Im gezeigten Fall wird er also dobj zugewiesen. Die Zuordnung von Aktualparametern an die Eingabeparameter erfolgt mit den drei bereits erklärten Syntaxformen für keinen, einen oder mehrere Eingabeparameter: ... meth( ) ... ... meth( dobj ) ... ... meth( i1 = dobj1 i2 = dobj2 ... ) ...
Funktionale Methoden sind an den gleichen Stellen wie eingebaute Funktionen (siehe Abschnitt 5.2.4) verwendbar, wobei eine funktionale Methode, die mit meth( a ) aufgerufen wird, eine gleichnamige eingebaute Funktion verdeckt: 왘
als Quellfeld einer Zuweisung
왘
als Operand in einem arithmetischen Ausdruck
왘
als Operand in einem logischen Ausdruck
왘
als Operand in der Anweisung CASE
왘
als Operand in der Anweisung WHEN
왘
als Operand in der WHERE-Bedingung für interne Tabellen
Wenn eine funktionale Methode, die an einer Operandenposition aufgerufen wurde, eine klassenbasierte Ausnahme nach außen reicht, kann diese innerhalb einer TRY-Kontrollstruktur behandelt werden.8 Ab SAP NetWeaver 2007 werden funktionale Methoden wie eingebaute Funktionen und ganze arithmetische Ausdrücke an fast allen Operandenpositionen einsetzbar sein, wo dies sinnvoll ist. Insbesondere werden sie als Aktualparameter für Eingabeparameter von Methoden möglich sein, was Verkettungen von Methodenaufrufen erlauben wird. 8
Klassische Ausnahmen sind in diesem Fall nicht behandelbar.
387
6.1
358.book Page 388 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
In Listing 6.3 haben wir zwei funktionale Methoden get_area und get_volume zur Berechnung der Kreisfläche und des Volumens eines Zylinders in einer Klasse cylinder implementiert. Listing 6.3 Funktionale Methoden REPORT z_functional_method. SELECTION-SCREEN BEGIN OF SCREEN 100. PARAMETERS: p_radius TYPE i, p_height TYPE i. SELECTION-SCREEN END OF SCREEN 100. CLASS demo DEFINITION. PUBLIC SECTION. CLASS-METHODS main. ENDCLASS. CLASS cylinder DEFINITION. PUBLIC SECTION. METHODS: constructor IMPORTING i_radius TYPE numeric i_height TYPE numeric, get_area RETURNING value(r_area) TYPE f, get_volume RETURNING value(r_volume) TYPE f. PRIVATE SECTION. CONSTANTS pi TYPE f VALUE '3.14159265'. DATA: radius TYPE f, height TYPE f. ENDCLASS. CLASS cylinder IMPLEMENTATION. METHOD constructor. me->radius = i_radius. me->height = i_height. ENDMETHOD. METHOD get_area. r_area = pi * me->radius ** 2. ENDMETHOD. METHOD get_volume. r_volume = me->get_area( ) * me->height. ENDMETHOD. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: oref TYPE REF TO cylinder,
388
358.book Page 389 Monday, September 4, 2006 8:51 AM
Vererbung
6.2
volume TYPE string. CALL SELECTION-SCREEN 100 STARTING AT 10 10. IF sy-subrc = 0. CREATE OBJECT oref EXPORTING i_radius = p_radius i_height = p_height. volume = oref->get_volume( ). CONCATENATE `Volume: ` volume INTO volume. MESSAGE volume TYPE 'I'. ENDIF. ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Die Methode main der Klasse demo ruft get_volume auf der rechten Seite einer Zuweisung funktional auf und weist das Ergebnis dem String volume zu. Die Methode get_volume ruft get_area in einem arithmetischen Ausdruck auf. Der Rechentyp dieses Ausdrucks ist f.
6.2
Vererbung
Vererbung bedeutet in der Objektorientierung Spezialisierung von Klassen durch die Ableitung von Unterklassen aus Oberklassen.
6.2.1
Grundlagen
Klassen sind die Baupläne oder Konstruktionsvorschriften für Objekte. Stellen Sie sich jetzt vor, Sie schreiben die Klassen »PKW« und »LKW«. Sie wollen für beide Klassen Methoden implementieren, die die Objekte steuern oder Informationen über ihre Position und Geschwindigkeit zurückgeben. Bereits zu diesem Zeitpunkt lässt sich absehen, dass Sie einige Teile der Klassen doppelt schreiben müssen. Mit dem Vererbungsmechanismus einer objektorientierten Programmiersprache stehen Ihnen hier Möglichkeiten zur Verfügung, die Ihnen helfen, die gleichen oder ähnliche Teile einer Klasse wieder zu verwenden und eine Hierarchie von Klassen aufzubauen. Wenn wir unsere beiden Klassen »PKW« und »LKW« genauer betrachten, können wir feststellen, dass es sich in beiden Fällen um Spezialfälle eines Fahrzeugs handelt. Wollen wir eine dritte Klasse »Kipper« abbilden, handelt es sich dabei wiederum um den Spezial-
389
Oberklassen und Unterklassen
358.book Page 390 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
fall eines LKW. Um eine Hierarchiebeziehung zwischen solchen Klassen zu erzeugen, lassen sich in der Vererbung Klassen voneinander ableiten. In unserem Beispiel werden »PKW« und »LKW« von der Klasse »Fahrzeug« und »Kipper« von »LKW« abgeleitet. Abgeleitete oder speziellere Klassen werden als Unterklassen bezeichnet, generellere Klassen als Oberklassen. Einfachvererbung
In ABAP Objects ist das Konzept der Einfachvererbung verwirklicht, das heißt, jede Klasse kann nur eine Oberklasse, aber mehrere Unterklassen besitzen.9 In der Einfachvererbung lassen sich Vererbungsbeziehungen in einem Vererbungsbaum darstellen. Jede Klasse einer objektorientierten Programmiersprache, in der die Einfachvererbung verwirklicht ist, hat eine eindeutige Position als Knoten in einem solchen Vererbungsbaum. Das gilt übrigens auch für unsere bisherigen Klassen, bei denen wir überhaupt noch nicht von Vererbung gesprochen haben. Für jede Klasse lassen sich ihre Oberklassen entlang eines eindeutigen Pfads des Vererbungsbaums zu genau einem Wurzelknoten des Baums zurückverfolgen. Der Wurzelknoten ist die Oberklasse sämtlicher Klassen des Vererbungsbaums.
Wurzelklasse
Abbildung 6.1 stellt diesen Zusammenhang grafisch dar. Der Wurzelknoten des Vererbungsbaums in ABAP Objects ist die vordefinierte leere und abstrakte Klasse object. object
CLASS c1 DEFINITION [INHERITING FROM object].
CLASS c11 DEFINITION INHERITING FROM c1.
CLASS c2 DEFINITION [INHERITING FROM object].
CLASS c12 DEFINITION INHERITING FROM c1.
Abbildung 6.1 Vererbungsbaum in ABAP Objects
9
Andere Programmiersprachen, wie z.B. C++, lassen durchaus zu, dass eine Klasse von mehreren Klassen erben kann. Dieser Mechanismus wird Mehrfachvererbung genannt und ist in ABAP Objects nicht realisiert.
390
358.book Page 391 Monday, September 4, 2006 8:51 AM
Vererbung
6.2
Vererbung bedeutet nichts anderes, als dass eine Unterklasse sämtliche Komponenten, also Attribute, Methoden, Ereignisse etc., ihrer Oberklasse übernimmt und genau wie eigene Komponenten verwenden kann. In jeder Unterklasse lassen sich unter dem Aspekt der Spezialisierung neue Elemente hinzufügen oder Methoden redefinieren, wovon die Oberklasse keine Kenntnis hat. In Unterklassen können immer nur Elemente hinzugefügt werden. Es widerspräche dem Vererbungsgedanken, etwas wegzunehmen.
Ableitung
Die direkten Unterklassen der Wurzelklasse object können demnach keine Komponenten aus ihrer leeren Oberklasse übernehmen, sondern nur neue Komponenten hinzufügen. Genau diese Situation besteht für unsere bisherigen Klassen: Alle Klassen in ABAP Objects, die nicht explizit von einer anderen Klasse erben, sind implizit direkte Unterklassen von object.
Implizite Unterklassen
Wenn wir jetzt Unterklassen von explizit definierten Klassen bilden, erben diese deren Komponenten und können neue Komponenten hinzufügen. Die Spezialisierung nimmt entlang eines Pfads des Vererbungsbaums also umso mehr zu, je weiter Sie sich von der Wurzel entfernen. Bewegen Sie sich dagegen in Richtung der Wurzel, nimmt umgekehrt die Generalisierung der Klassen zu.
Spezialisierung/ Generalisierung
Wenn Sie sich eine Klasse anschauen, die weiter unten im Vererbungsbaum sitzt, dann sehen Sie, dass die geerbten Komponenten der Klasse aus allen Klassen stammen, die auf dem Pfad von der Klasse bis zur Oberklasse liegen. Mit anderen Worten: Die Definition einer Unterklasse setzt sich aus den Definitionen aller ihrer Oberklassen bis hinauf zu object zusammen. Die Beziehung einer Unterklasse zu ihrer Oberklasse sollte sich immer durch »ist ein« ausdrücken lassen, wie z.B. »ein Frachtflugzeug ist ein Flugzeug ist ein Verkehrsmittel ist ein Objekt«. Dadurch sind Unterklassen immer wie Oberklassen behandelbar (siehe Polymorphie in Abschnitt 6.4).
Zusammensetzung
6.2.2
Unterklassen anlegen
Eine Oberklasse hat keine Kenntnis von eventuell vorhandenen Unterklassen. Nur die Unterklasse weiß, dass sie von einer anderen Klasse erbt. Deshalb kann eine Vererbungsbeziehung nur bei der Deklaration einer Unterklasse definiert werden. Die Syntax, um eine Unterklasse subclass aus einer Oberklasse superclass abzuleiten, ist:
391
358.book Page 392 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
INHERITING FROM
CLASS subclass DEFINITION INHERITING FROM superclass. ... ENDCLASS.
Es handelt sich also um einen simplen Zusatz zur Anweisung CLASS DEFINITION. Für superclass kann jede an dieser Stelle sichtbare nicht-finale Klasse angegeben werden. Im Class Builder legen Sie eine Unterklasse durch Auswahl von Oberklasse auf der Registerkarte Eigenschaften an. Danach kann im Feld Erbt von eine beliebige nicht-finale globale Klasse als Oberklasse eingetragen werden. Die Funktionen Vererbung aufheben und Vererbung ändern ermöglichen das Ändern der Vererbungsbeziehung (siehe Abbildung 6.2).
Abbildung 6.2 Vererbung im Class Builder
Um im Class Builder in einer Unterklasse die von der Oberklasse geerbten Komponenten anzuzeigen, markieren Sie unter Hilfsmittel • Einstellungen den Eintrag auch geerbte Komponenten anzeigen. Für jede Klasse, die keinen expliziten Zusatz INHERITING FROM hat, ergänzt das System implizit den Zusatz INHERITING FROM object, so dass jede Klasse ohne INHERITING-Zusatz automatisch eine direkte Unterklasse der Wurzelklasse object ist. In Listing 6.4 implementieren wir ansatzweise unser Spezialisierungsbeispiel mit Fahrzeugen. Wir leiten also zwei Klassen, car und truck, von der Klasse vehicle ab. Listing 6.4 Einfaches Beispiel zur Vererbung REPORT z_inheritance. CLASS demo DEFINITION. PUBLIC SECTION. CLASS-METHODS main. ENDCLASS. CLASS vehicle DEFINITION. PUBLIC SECTION. METHODS: accelerate IMPORTING delta TYPE i,
392
358.book Page 393 Monday, September 4, 2006 8:51 AM
Vererbung
show_speed. PROTECTED SECTION. DATA speed TYPE i. ENDCLASS. CLASS car DEFINITION INHERITING FROM vehicle. ENDCLASS. CLASS truck DEFINITION INHERITING FROM vehicle. PUBLIC SECTION. METHODS: load IMPORTING freight TYPE string, unload. PROTECTED SECTION. DATA freight TYPE string. ENDCLASS. CLASS vehicle IMPLEMENTATION. METHOD accelerate. me->speed = me->speed + delta. ENDMETHOD. METHOD show_speed. DATA output TYPE string. output = me->speed. MESSAGE output TYPE 'I'. ENDMETHOD. ENDCLASS. CLASS truck IMPLEMENTATION. METHOD load. me->freight = freight. ENDMETHOD. METHOD unload. CLEAR me->freight. ENDMETHOD. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: car_ref TYPE REF TO car, truck_ref TYPE REF TO truck. CREATE OBJECT: car_ref, truck_ref. car_ref->accelerate( 130 ). car_ref->show_speed( ). truck_ref->load( `Beer` ). truck_ref->accelerate( 110 ). truck_ref->show_speed( ).
393
6.2
358.book Page 394 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
truck_ref->unload( ). ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Die Klasse vehicle enthält ein geschütztes Attribut speed und zwei öffentliche Methoden accelerate und show_speed. Beachten Sie, dass wir hier explizit angeben, dass vehicle von object erbt. Normalerweise lassen wir den INHERITING-Zusatz bei solchen Klassen weg. Die Klassen car und truck leiten wir beide von vehicle ab. Dadurch erben diese das Attribut und die Methoden. Da speed in der PROTECTED SECTION deklariert ist, ist es auch in den Unterklassen sichtbar. Die Klasse truck spezialisieren wir mit einem zusätzlichen Attribut für die Fracht und zusätzlichen Methoden load und unload zum Beladen bzw. Entladen. Die Klasse car erhält in diesem Beispiel noch keine zusätzlichen Komponenten. Das bedeutet, dass sich ihre Objekte nicht von denen der Klasse vehicle unterscheiden. Da keine Methoden hinzugekommen sind, benötigt car keinen Implementierungsteil. In der Methode main der Klasse demo erzeugen wir mit den Referenzvariablen car_ref und truck_ref jeweils ein Objekt der beiden Unterklassen und rufen deren Methoden auf. Die Methoden accelerate und show_speed können in beiden Unterklassen verwendet werden. Die Methoden load und unload gibt es aber nur in truck.
6.2.3
Sichtbarkeitsbereiche und Namensräume in der Vererbung
In einer Klasse gibt es drei unterschiedliche Sichtbarkeitsbereiche, in denen die Komponenten der Klasse deklariert werden (siehe Abschnitt 4.3.2). Eine Unterklasse übernimmt sämtliche Komponenten ihrer Oberklassen, wobei sich deren Sichtbarkeit nicht ändert. Das bedeutet, in einer Unterklasse sind nur die öffentlichen und geschützten Komponenten ihrer Oberklassen sichtbar. Die privaten Komponenten der Oberklassen sind zwar vorhanden, aber unsichtbar.10 10 Beachten Sie aber, dass die von der Oberklasse geerbten Methoden sehr wohl mit den privaten Attributen der Oberklasse arbeiten, solange sie nicht in einer Unterklasse redefiniert werden.
394
358.book Page 395 Monday, September 4, 2006 8:51 AM
Vererbung
In den Sichtbarkeitsbereichen einer Unterklasse sind also folgende Komponenten enthalten: 왘
PUBLIC Der öffentliche Sichtbarkeitsbereich einer Unterklasse enthält sämtliche öffentlichen Komponenten aller Oberklassen zuzüglich der hinzugekommenen eigenen öffentlichen Komponenten. Diese Komponenten sind von außen über Komponentenselektoren ansprechbar.
왘
PROTECTED Der geschützte Sichtbarkeitsbereich einer Unterklasse enthält sämtliche geschützten Komponenten aller Oberklassen zuzüglich der hinzugekommenen eigenen geschützten Komponenten. Diese Komponenten sind nicht von außen über Komponentenselektoren ansprechbar. Von außen gesehen hat »geschützt« die gleiche Bedeutung wie »privat«.
왘
PRIVATE Der private Sichtbarkeitsbereich einer Unterklasse enthält nur die eigenen privaten Komponenten. Diese Komponenten sind nur in den Methodenimplementierungen der Unterklasse ansprechbar.
Da alle in einer Klasse sichtbaren Komponenten eindeutige Namen haben müssen, liegen sämtliche öffentlichen und geschützten Komponenten aller Klassen auf einem Pfad des Vererbungsbaums in einem Namensraum und müssen eindeutige Namen haben. Private Komponenten, die nur innerhalb einer Klasse sichtbar und in Unterklassen nicht verwendbar sind, müssen nur innerhalb ihrer Klasse eindeutige Namen haben. Das hat folgende Konsequenzen: Eine Oberklasse hat keine Kenntnis von ihren Unterklassen. Wenn Sie eine nicht-finale Klasse in der Klassenbibliothek anlegen und zur Verwendung freigeben, können Sie als Entwickler nie wissen, welche Unterklassen Ihre Klasse außer den von Ihnen definierten nach einiger Zeit haben wird. Wenn Sie dann nachträglich neue Komponenten im öffentlichen oder geschützten Bereich Ihrer Klasse einbauen und irgendeine Unterklasse zufällig eine namensgleiche eigene Komponente enthält, machen Sie diese syntaktisch inkorrekt. Richtig sicher ist also nur das Hinzufügen von privaten Komponenten. In globalen Klassen ist also
395
Namensraum
6.2
358.book Page 396 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
nicht nur die Schnittstelle nach außen, sondern auch die Schnittstelle zu eventuellen Unterklassen stabil zu halten. Um die Unterklassen einer Klasse zumindest auf das gleiche Paket einzuschränken, sollten nicht-finale Klassen deshalb bevorzugterweise in Paketen organisiert sein, bei denen die Eigenschaft Paketprüfung als Server eingeschaltet ist (siehe Abschnitt 2.3.3).
6.2.4
Methodenredefinition
Eine Unterklasse übernimmt bei der Vererbung alle öffentlichen und geschützten Methoden sämtlicher Oberklassen zu ihren eigenen Komponenten.11 Beim Aufruf einer Methode in der Unterklasse läuft diese so ab, wie sie in der Oberklasse implementiert wurde, und arbeitet sogar mit den privaten Komponenten der Oberklasse. Da der Sinn von Vererbung im Wesentlichen eine Spezialisierung ist, kann es aber sein, dass das Verhalten der Methode einer Oberklasse zu allgemein für den speziellen Zweck einer Unterklasse ist. In einigen Fällen muss zur Implementierung der Oberklasse etwas hinzugefügt werden, in anderen Fällen muss die Implementierung vollständig geändert werden. Die Semantik der Methode für den äußeren Verwender muss aber immer stabil bleiben, da dieser nur die konstante Schnittstelle (inklusive Dokumentation), aber nicht die Implementierung sieht. Neuimplementierung
Um das Verhalten von Unterklassen-Objekten zu spezialisieren, können Instanzmethoden in Unterklassen redefiniert werden. Statische Methoden können nicht redefiniert werden. Die Redefinition einer Methode bedeutet eine neue Implementierung der Methode in einer Unterklasse bei unveränderter Schnittstelle.12 Die Deklaration der Methode erfolgt weiterhin in ihrer Oberklasse. Frühere Implementierungen der Methode in vorangehenden Oberklassen bleiben ebenfalls dort erhalten. Bei der Redefinition einer Methode in einer Unterklasse wird eine zusätzliche Implementierung erzeugt, die bei
11 Die privaten Methoden werden prinzipiell zwar auch geerbt, sind in der Unterklasse aber nicht sichtbar. 12 Einige andere objektorientierte Programmiersprachen erlauben das Überladen von Funktionen bzw. Methoden. In diesem Fall kann für eine überschriebene bzw. redefinierte Methode eine eigene veränderte Parameterschnittstelle festgelegt werden. ABAP Objects unterstützt diesen Mechanismus zurzeit nicht.
396
358.book Page 397 Monday, September 4, 2006 8:51 AM
Vererbung
6.2
Verwendung der Unterklasse und weiterer Unterklassen die früheren Implementierungen verschattet. Jede Referenz, die auf ein Objekt der Unterklasse zeigt, verwendet die redefinierte Methode. Das ist unabhängig vom Typ der Referenzvariablen (mehr dazu in Abschnitt 6.4). Dies gilt insbesondere auch für die Selbstreferenz me. Wenn also eine Oberklassenmethode meth1 einen Aufruf einer Methode meth2 der eigenen Klasse enthält, die in einer Unterklasse redefiniert wird, führt der Aufruf der Methode meth1 in einer Instanz der Oberklasse zur Ausführung der ursprünglichen Methode meth2 und der Aufruf von meth1 in einer Instanz der Unterklasse zur Ausführung der redefinierten Methode meth2. Eine redefinierte Methode greift wie die eigenen Methoden der Unterklasse auf die privaten Attribute der Unterklasse zu.
Zugriff
Die Syntax zur Redefinition einer Instanzmethode in einer Unterklasse ist:
REDEFINITION
METHODS meth REDEFINITION.
Diese Anweisung muss im Deklarationsteil der Unterklasse im gleichen Sichtbarkeitsbereich wie die eigentliche Deklaration der Methode in der Oberklasse aufgeführt werden. Die Definition der Schnittstelle wird nicht wiederholt. Im Class Builder redefinieren Sie eine geerbte Methode dadurch, dass Sie sie auf der Registerkarte Methoden anzeigen (hierfür mit der Funktion Einstellungen des Class Builders den Eintrag auch geerbte Komponenten anzeigen wählen), markieren und die Funktion Redefinieren wählen (siehe Abbildung 6.3).
Abbildung 6.3 Redefinition einer geerbten Methode
Für jede redefinierte Methode muss in der redefinierenden Unterklasse eine neue Implementierung angelegt werden. Bei globalen Klassen übernimmt dies der Class Builder beim Redefinieren, und Sie können wie bei normalen Methoden zur Implementierung navigie-
397
Implementierung
358.book Page 398 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
ren. Bei lokalen Klassen müssen Sie die Implementierung wie gehabt selbst im Implementierungsteil eintragen. Pseudoreferenz
In der Implementierung einer redefinierten Methode kann mittels der Pseudoreferenz super-> auf die ursprüngliche Methode der direkten Oberklasse zugegriffen werden. Damit wird die Verschattung der redefinierten Methode umgangen. Diese Pseudoreferenz verwenden Sie immer dann, wenn Sie die Funktionalität der Oberklasse zunächst übernehmen und dann ergänzen wollen. Wir wenden nun die Methodenredefinition auf unser Beispiel aus Listing 6.4 an. In Listing 6.5 zeigen wir nur die Unterschiede zu Listing 6.4. Listing 6.5 Methodenredefinition REPORT z_method_redefinition. ... CLASS car DEFINITION INHERITING FROM vehicle. PUBLIC SECTION. METHODS show_speed REDEFINITION. ENDCLASS. CLASS truck DEFINITION INHERITING FROM vehicle. PUBLIC SECTION. METHODS: accelerate REDEFINITION, show_speed REDEFINITION, load IMPORTING freight TYPE string, unload. PROTECTED SECTION. DATA freight TYPE string. PRIVATE SECTION. CONSTANTS max_speed TYPE i VALUE '80'. ENDCLASS. ... CLASS car IMPLEMENTATION. METHOD show_speed. DATA output TYPE string. output = me->speed. CONCATENATE `Car, speed: ` output INTO output. MESSAGE output TYPE 'I'.
398
358.book Page 399 Monday, September 4, 2006 8:51 AM
Vererbung
ENDMETHOD. ENDCLASS. CLASS truck IMPLEMENTATION. METHOD accelerate. super->accelerate( delta ). IF me->speed > truck=>max_speed. me->speed = truck=>max_speed. ENDIF. ENDMETHOD. METHOD show_speed. DATA output TYPE string. output = me->speed. CONCATENATE `Truck with ` me->freight `, speed: ` output INTO output. MESSAGE output TYPE 'I'. ENDMETHOD. ... ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: car_ref TYPE REF TO car, truck_ref TYPE REF TO truck. CREATE OBJECT: car_ref, truck_ref. car_ref->accelerate( 130 ). car_ref->show_speed( ). truck_ref->load( `Beer` ). truck_ref->accelerate( 110 ). truck_ref->show_speed( ). truck_ref->unload( ). ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Wir spezialisieren die Methode accelerate in der Klasse truck und die Methode show_speed in beiden Unterklassen: 왘
In der Klasse truck haben wir eine Maximalgeschwindigkeit max_ speed eingeführt, die in accelerate nicht überschritten werden darf. Deshalb wird in der Neuimplementierung die Geschwindig-
399
6.2
358.book Page 400 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
keit erst durch Aufruf von super->accelerate durch die vorherige Implementierung gesetzt, dann aber überprüft und gegebenenfalls angepasst. 왘
Die Methode show_speed wird in beiden Unterklassen um spezifische Ausgaben erweitert. Dabei wird kein Gebrauch von der vorherigen Implementierung gemacht.
Alle redefinierten Methoden behalten trotz neuer Implementierung ihre ursprüngliche Semantik. Sie sehen, dass hier Programmierdisziplin gefordert ist, da wir die Methoden auch völlig anders implementieren könnten (mehr dazu in Abschnitt 6.4.3). Ein Testwerkzeug, das helfen kann, die Stabilität von Anwendungen zu überprüfen, ist ABAP Unit (siehe Abschnitt 13.3).
6.2.5
Abstrakte Klassen und Methoden
Wenn Sie eine Klasse nur als Vorlage für Unterklassen verwenden wollen und keine Objekte dieser Klasse selbst benötigen, können Sie sie als abstrakte Klasse definieren. Die Syntax für die Definition einer abstrakten Klasse ist: ABSTRACT
CLASS class DEFINITION ABSTRACT. ... ENDCLASS.
Im Class Builder legen Sie eine abstrakte Klasse durch Auswahl von Abstrakt im Eingabefeld Inst.-Erzeugung auf der Registerkarte Eigenschaften an (siehe Abbildung 6.4).
Abbildung 6.4 Abstrakte globale Klasse
Von einer abstrakten Klasse können keine Objekte mit CREATE OBJECT erzeugt werden. Abstrakte Klassen dienen stattdessen als Vorlage für Unterklassen. Von abstrakten Klassen können konkrete
400
358.book Page 401 Monday, September 4, 2006 8:51 AM
Vererbung
6.2
Unterklassen abgeleitet werden, von denen dann Objekte erzeugt werden können. Auch einzelne Instanzmethoden können als abstrakt gekennzeichnet werden. Die Syntax ist: METHODS meth ABSTRACT.
Im Class Builder können Sie eine Methode in deren Detailsicht als Abstrakt kennzeichnen (siehe Abbildung 6.5).
Abbildung 6.5 Abstrakte Methode
Eine abstrakte Methode kann nicht in ihrer eigenen Klasse, sondern erst in einer konkreten Unterklasse implementiert werden. Aus diesem Grund können abstrakte Methoden nur in abstrakten Klassen angelegt werden. Ansonsten könnte ein Objekt mit ansprechbarer Methode, aber fehlender Implementierung erzeugt werden. Um eine abstrakte Methode in einer Unterklasse zu implementieren, verwenden Sie den Mechanismus der Methodenredefinition aus Abschnitt 6.2.4. Der einzige Unterschied zu einer echten Redefinition ist der, dass in der Methode nicht die Pseudoreferenz super-> verwendet werden kann. In einer abstrakten Klasse können sowohl konkrete als auch abstrakte Methoden deklariert werden. Konkrete Methoden werden wie gewohnt deklariert und implementiert. Die konkreten Methoden können sogar die abstrakten Methoden aufrufen, da ja Namen
401
Implementierung
358.book Page 402 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
und Schnittstellen vollständig bekannt sind. Das Verhalten der abstrakten Methode wird aber erst bei der Implementierung in einer Unterklasse festgelegt und kann deshalb in verschiedenen Unterklassen unterschiedlich sein. In unserem Beispiel in Listing 6.5 ist die Oberklasse vehicle recht rudimentär, und es werden keine Objekte von ihr erzeugt. Um dies grundsätzlich zu verbieten, kann die Klasse, wie in Listing 6.6 gezeigt, abstrakt definiert werden. Listing 6.6 zeigt nur die Unterschiede gegenüber Listing 6.5. Listing 6.6 Abstrakte Klasse und Methode REPORT z_abstract_class. ... CLASS vehicle DEFINITION ABSTRACT. PUBLIC SECTION. METHODS: accelerate IMPORTING delta TYPE i, show_speed ABSTRACT. PROTECTED SECTION. DATA speed TYPE i. ENDCLASS. ... CLASS vehicle IMPLEMENTATION. METHOD accelerate. me->speed = me->speed + delta. ENDMETHOD. ENDCLASS. ...
Die Klasse vehicle legt nur noch die die gemeinsamen Elemente der Unterklassen fest. Da die beiden Unterklassen aus Listing 6.5 die Methode show_speed ohnehin redefinieren, haben wir sie in Listing 6.6 ebenfalls als abstrakt deklariert. Damit fällt ihre Implementierung in der Klasse vehicle weg. Design
Die Verwendung abstrakter Klassen und Methoden kann ein wichtiges Mittel des objektorientierten Designs sein. Abstrakte Klassen stellen ihren Unterklassen eine gemeinsame Schnittstelle und eine
402
358.book Page 403 Monday, September 4, 2006 8:51 AM
Vererbung
bereits teilweise implementierte Funktionalität zur Verfügung, können jedoch selbst noch keine sinnvollen Operationen auf ihren Attributen ausführen. In einem Gehaltsabrechnungssystem können Sie sich beispielsweise eine Klasse vorstellen, die schon viele Aufgaben wie Überweisungstätigkeiten etc. implementiert, die eigentliche Gehaltsabrechnung aber nur abstrakt enthält. Es ist dann die Aufgabe verschiedener Unterklassen, für verschiedene Anstellungsverhältnisse die richtige Abrechnung durchzuführen. Da ABAP Objects keine Mehrfachvererbung unterstützt, ist die Verwendung der Abstraktion durch abstrakte Klassen immer nur auf die Unterklassen eines bestimmten Knotens des Vererbungsbaums begrenzt. Mit Interfaces lernen Sie in Abschnitt 6.3 ein weiteres Mittel kennen, mit dem Sie ähnliche Aufgaben unabhängig von der Position in der Vererbungshierarchie lösen können.
6.2.6
Interfaces
Finale Klassen und Methoden
Wie abstrakte Klassen und Methoden die Definition von Unterklassen erfordern, um überhaupt mit den Klassen arbeiten zu können, kann es umgekehrt Situationen geben, in der Sie eine ganze Klasse oder eine einzelne Methode vor unkontrollierter Spezialisierung schützen wollen. Um dies zu erreichen, deklarieren Sie eine Klasse oder Instanzmethode als final. Das kann speziell dann sinnvoll sein, wenn Sie an einer Klasse noch spätere Änderungen durchführen wollen, ohne dass eventuelle Unterklassen syntaktisch oder semantisch inkorrekt werden (siehe Namensraum von Komponenten in der Vererbung in Abschnitt 6.2.3). Wenn Sie der in Abschnitt 4.9 vorgestellten defensiven Vorgehensweise bei der Programmierung des AS ABAP mit ABAP Objects folgen, ist die Deklaration finaler Klassen sogar immer empfohlen. Die Syntax für die Definition einer finalen Klasse ist: FINAL
CLASS class DEFINITION FINAL. ... ENDCLASS.
Im Class Builder legen Sie eine abstrakte Klasse durch Auswahl des Ankreuzfeldes Final auf der Registerkarte Eigenschaften an (siehe Abbildung 6.4). Von einer finalen Klasse können keine Unterklassen mehr abgeleitet werden. Eine finale Klasse schließt demnach einen
403
6.2
358.book Page 404 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Pfad der Vererbungshierarchie vollständig ab. Alle Instanzmethoden einer finalen Klasse sind automatisch final. In einer nicht-finalen Klasse können einzelne Instanzmethoden als final deklariert werden. Die Syntax ist: METHODS meth FINAL.
Im Class Builder können Sie eine Instanzmethode in deren Detailsicht als Final kennzeichnen (siehe Abbildung 6.5). Eine finale Methode kann in Unterklassen nicht redefiniert werden. Eine finale Methode kann nicht gleichzeitig abstrakt sein. Eine Klasse kann zwar gleichzeitig final und abstrakt sein, dann können aber nur ihre statischen Komponenten verwendet werden. Die Deklaration von Instanzkomponenten in einer solchen Klasse ist zwar möglich, aber nicht sinnvoll.
6.2.7
Statische Attribute in der Vererbung
Zur Verwendung einer statischen Komponente einer Klasse sind keine Instanzen der Klasse nötig. Sind Instanzen vorhanden, teilen sie sich die statischen Komponenten. Wie wirkt sich nun die Vererbung auf statische Komponenten und hier insbesondere auf statische Attribute aus? Vererbungsbaum
Ein statisches Attribut ist wie alle Komponenten genau einmal innerhalb eines Pfads des Vererbungsbaums vorhanden. Eine Unterklasse hat Zugriff auf den Inhalt der öffentlichen und geschützten statischen Attribute aller Oberklassen. Umgekehrt teilt sich eine Oberklasse ihre öffentlichen und geschützten statischen Attribute mit allen Unterklassen. Ein statisches Attribut ist in der Vererbung also nicht einer einzigen Klasse, sondern einem Pfad des Vererbungsbaums zugeordnet. Zugriffe von außen sind über den Klassenkomponentenselektor (=>) mit allen beteiligten Klassennamen oder von innen in allen beteiligten Klassen, in denen ein statisches Attribut sichtbar ist, möglich. Änderungen des Wertes sind in allen beteiligten Klassen sichtbar. Listing 6.7 zeigt ein einfaches Beispiel. Listing 6.7 Statische Attribute in der Vererbung REPORT z_static_attributes.
404
358.book Page 405 Monday, September 4, 2006 8:51 AM
Vererbung
CLASS demo DEFINITION. PUBLIC SECTION. CLASS-METHODS main. ENDCLASS. CLASS c1 DEFINITION. PUBLIC SECTION. CLASS-DATA a1 TYPE string. ENDCLASS. CLASS c2 DEFINITION INHERITING FROM c1. ... ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. c2=>a1 = 'ABAP Objects'. MESSAGE c1=>a1 TYPE 'I'. ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Beim Ansprechen eines statischen Attributs, das zu einem Pfad eines Vererbungsbaums gehört, wird unabhängig vom im Klassenkomponentenselektor verwendeten Klassennamen immer die Klasse angesprochen, in der das Attribut deklariert ist. Dies ist wichtig für den Aufruf des statischen Konstruktors (siehe Abschnitt 6.2.8). Ein statischer Konstruktor wird bei der ersten Ansprache einer Klasse ausgeführt. Wenn ein statisches Attribut über den Klassennamen einer Unterklasse adressiert wird, aber in einer Oberklasse deklariert ist, wird nur der statische Konstruktor der Oberklasse ausgeführt.
Statischer Konstruktor
Da statische Komponenten genau einmal in einem Pfad vorkommen sollen, um von allen Unterklassen gemeinsam genutzt zu werden, dürfen statische Methoden in ABAP Objects nicht redefiniert werden.
Statische Methoden
6.2.8
Konstruktoren in der Vererbung
Konstruktoren dienen der Initialisierung der Attribute einer Klasse (siehe Abschnitt 4.7). Während Instanzkonstruktoren die Instanz-
405
6.2
358.book Page 406 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
attribute jedes einzelnen Objekts bei der Instanzierung setzen können, sind die statischen Konstruktoren für die statischen Attribute der Klasse vor dem ersten Zugriff auf die Klasse zuständig. Da in der Vererbung eine Unterklasse sämtliche Attribute ihrer Oberklassen erbt, stellt sich automatisch die Frage, wie die Konstruktoren dafür sorgen, dass bei Verwendung der Unterklasse auch die geerbten Attribute initialisiert werden.
Instanzkonstruktoren Jede Klasse hat einen vordefinierten Instanzkonstruktor namens constructor. Instanzkonstruktoren weichen damit von der Regel ab, dass es entlang eines Pfads des Vererbungsbaums nur eindeutige Komponentennamen gibt. Die Konsequenz daraus ist, dass die Instanzkonstruktoren der einzelnen Klassen eines Vererbungsbaums völlig unabhängig voneinander sein müssen. Um Namenskonflikte zu verhindern,
super->constructor
왘
können Instanzkonstruktoren von Oberklassen in Unterklassen nicht redefiniert werden
왘
können Instanzkonstruktoren nicht explizit mit constructor( ) aufgerufen werden
Der Instanzkonstruktor wird automatisch nach dem Anlegen eines Objekts mit dem Befehl CREATE OBJECT ausgeführt. Da eine Unterklasse alle für sie sichtbaren Attribute ihrer Oberklassen enthält, deren Inhalt wiederum von Instanzkonstruktoren dieser Klassen gesetzt werden kann, muss der Instanzkonstruktor einer Unterklasse dafür sorgen, dass auch die Instanzkonstruktoren sämtlicher Oberklassen ausgeführt werden.13 Hierfür muss der Instanzkonstruktor jeder Unterklasse einen Aufruf super->constructor( ... ).
des Instanzkonstruktors der direkten Oberklasse enthalten, selbst wenn dieser nicht explizit deklariert ist. Ausnahmen hiervon sind nur die direkten Unterklassen des Wurzelknotens object. Die Anweisung super->constructor( ... ) ist die einzige Ausnahme von
13 Insbesondere können die privaten Attribute von Oberklassen nur in deren Konstruktoren initialisiert werden.
406
358.book Page 407 Monday, September 4, 2006 8:51 AM
Vererbung
6.2
der Regel, dass Konstruktoren nicht explizit aufgerufen werden können. In Oberklassen, in denen der Instanzkonstruktor nicht explizit deklariert und implementiert ist, wird die implizit immer vorhandene Implementierung des Instanzkonstruktors ausgeführt. Diese sorgt automatisch für den Aufruf des Instanzkonstruktors der nächsthöheren Oberklasse. Vor der Ausführung eines Instanzkonstruktors müssen dessen nichtoptionale Eingabeparameter versorgt werden. Diese werden wie folgt gesucht: 왘
Versorgung bei CREATE OBJECT Ausgehend von der Klasse des erzeugten Objekts, wird der erste explizit definierte Instanzkonstruktor im zugehörigen Pfad des Vererbungsbaums gesucht. Dies ist der Instanzkonstruktor der Klasse selbst oder der erste explizit definierte Instanzkonstruktor einer Oberklasse.
왘
Versorgung bei super->constructor( ... ) Ausgehend von der direkten Oberklasse, wird der erste explizit definierte Instanzkonstruktor im zugehörigen Pfad des Vererbungsbaums gesucht.
Eingabeparameter
Die Schnittstelle des ersten explizit definierten Instanzkonstruktors wird bei CREATE OBJECT bzw. in super->constructor( ... ) wie bei einer normalen Methode versorgt, d.h.: 왘
Falls es keine Eingabeparameter gibt, werden keine Parameter übergeben.
왘
Optionale Eingabeparameter können versorgt werden.
왘
Nicht-optionale Eingabeparameter müssen versorgt werden.
Falls es im Pfad des Vererbungsbaums bis zur Wurzelklasse object keinen explizit definierten Instanzkonstruktor gibt, werden keine Parameter übergeben. Sowohl bei CREATE OBJECT als auch bei super->constructor( ... ) muss also der nächstmögliche explizite Instanzkonstruktor betrachtet und, falls vorhanden, dessen Schnittstelle versorgt werden. Beim Arbeiten mit Unterklassen müssen Sie also den gesamten Pfad des Vererbungsbaums gut kennen, da es durchaus passieren kann, dass
407
Vererbungsbaum
358.book Page 408 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
beim Erzeugen eines Objekts einer Unterklasse, die im Vererbungsbaum weit unten liegt, Parameter an den Konstruktor einer viel näher zum Wurzelknoten hin liegenden Oberklasse übergeben werden müssen. Der Instanzkonstruktor einer Unterklasse wird durch den von der Syntax geforderten Aufruf super->constructor( ... ) in zwei Teile zerlegt. In den Anweisungen vor dem Aufruf verhält sich der Konstruktor wie eine statische Methode. Dort hat er keinen Zugriff auf die Instanzattribute seiner Klasse. Erst nach dem Aufruf können auch Instanzattribute adressiert werden. 3-Phasen-Modell
Die Ausführung eines Instanzkonstruktors einer Unterklasse lässt sich somit in drei Phasen zerlegen, die wir in Listing 6.8 durch Kommentarzeilen verdeutlicht haben. Listing 6.8 3-Phasen-Modell eines Instanzkonstruktors METHOD constructor. " Phase 1: Access to static attributes only ... " Phase 2: Execution of super class constructor(s) CALL METHOD super->constructor EXPORTING ... " Phase 3: Access to instance attributes only ... ENDMETHOD.
In den einzelnen Phasen kann der Instanzkonstruktor folgende Arbeiten ausführen: 왘
Phase 1 Hier können Vorbereitungen für den Aufruf des Instanzkonstruktors der Oberklasse getroffen werden – wie die Bestimmung von Aktualparametern für dessen Schnittstelle.
왘
Phase 2 In dieser Phase wird der Instanzkonstruktor der Oberklasse ausgeführt, der – falls implementiert – wieder in drei Phasen abläuft.
왘
Phase 3 Die Attribute der Oberklassen sind jetzt richtig initialisiert. Mit diesen Werten können die nötigen Initialisierungen für die eigenen Instanzattribute vorgenommen werden.
408
358.book Page 409 Monday, September 4, 2006 8:51 AM
Vererbung
Bei der Instanzierung einer Unterklasse findet also ein geschachtelter Aufruf der Instanzkonstruktoren von der Unterklasse zu den Oberklassen hin statt, wobei aber erst in der tiefsten Schachtelungsebene, d.h. in der höchsten Oberklasse, deren Instanzattribute adressiert werden können. Bei der Rückkehr in die Konstruktoren der darunter liegenden Unterklassen können dort auch deren Instanzattribute sukzessive adressiert werden. In Konstruktoren sind die Methoden von Unterklassen nicht sichtbar. Falls ein Instanzkonstruktor eine Instanzmethode der gleichen Klasse über die implizite Selbstreferenz me aufruft, wird die Methode so aufgerufen, wie sie in der Klasse des Instanzkonstruktors implementiert ist, und nicht die eventuell redefinierte Methode der zu instanzierenden Unterklasse. Dies ist eine Ausnahme von der Regel, dass beim Aufruf von Instanzmethoden immer die Implementierung in der Klasse aufgerufen wird, auf deren Instanz die Referenz gerade zeigt. In Listing 6.9 wird das Verhalten von Instanzkonstruktoren in der Vererbung in einem einfachen Beispiel dargestellt. Listing 6.9 Instanzkonstruktoren in der Vererbung REPORT z_constructor_inheritance. CLASS demo DEFINITION. PUBLIC SECTION. CLASS-METHODS main. ENDCLASS. CLASS vessel DEFINITION. PUBLIC SECTION. METHODS constructor IMPORTING i_name TYPE string. PROTECTED SECTION. DATA name TYPE string. ENDCLASS. CLASS ship DEFINITION INHERITING FROM vessel. ... ENDCLASS. CLASS motorship DEFINITION INHERITING FROM ship. PUBLIC SECTION. METHODS constructor IMPORTING i_name TYPE string
409
Selbstreferenz
6.2
358.book Page 410 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
i_fuelamount TYPE i. PRIVATE SECTION. DATA fuelamount TYPE i. ENDCLASS. CLASS vessel IMPLEMENTATION. METHOD constructor. name = i_name. ENDMETHOD. ENDCLASS. CLASS motorship IMPLEMENTATION. METHOD constructor. super->constructor( i_name ). fuelamount = i_fuelamount. ENDMETHOD. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: o_vessel TYPE REF TO vessel, o_ship TYPE REF TO ship, o_motorship TYPE REF TO motorship. CREATE OBJECT: o_vessel EXPORTING i_name = 'Vincent', o_ship EXPORTING i_name = 'Mia', o_motorship EXPORTING i_name = 'Jules' i_fuelamount = 12000. ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Dieses Beispiel zeigt drei aufeinander folgende Klassen der Vererbungshierarchie. Die Klasse vessel hat einen Instanzkonstruktor mit einem Eingabeparameter. Von vessel leiten wir die Klasse ship ab, die den Instanzkonstruktor nicht explizit deklariert und implementiert. Von ship leiten wir motorship ab. Diese Klasse hat wieder einen expliziten Instanzkonstruktor mit zwei Eingabeparametern. Wir erzeugen von jeder der Klassen ein Objekt und versorgen dabei die Parameterschnittstelle der Konstruktoren mit Aktualparametern. Der Aufruf der Konstruktoren spielt sich dabei wie folgt ab:
410
358.book Page 411 Monday, September 4, 2006 8:51 AM
Vererbung
왘
Das mit o_vessel erzeugte Objekt wird bei CREATE OBJECT im expliziten Instanzkonstruktor von vessel initialisiert, wobei ein Attribut mit Hilfe des übergebenen Aktualparameters gesetzt wird.
왘
Das mit o_ship erzeugte Objekt wird bei CREATE OBJECT ebenfalls über den Instanzkonstruktor von vessel initialisiert, da der implizite Instanzkonstruktor von ship diesen aufruft. Es muss dessen Parameterschnittstelle versorgt werden.
왘
Das mit o_motorship erzeugte Objekt wird im expliziten Instanzkonstruktor von motorship initialisiert. In diesem muss über super->constructor der Instanzkonstruktor der direkten Oberklasse aufgerufen werden. Der implizite Instanzkonstruktor von ship ruft den expliziten Instanzkonstruktor von vessel auf. Es muss dessen Parameterschnittstelle versorgt werden.
Sie können das Verhalten des Programms am besten nachvollziehen, wenn Sie es zeilenweise im ABAP Debugger ausführen.
Statische Konstruktoren Jede Klasse hat einen statischen Konstruktor namens class_ constructor. Bezüglich des Namensraums entlang eines Vererbungs-
baums gilt für den statischen Konstruktor das Gleiche wie für den Instanzkonstruktor. Bei der ersten Ansprache einer Unterklasse in einem Programm wird ihr statischer Konstruktor ausgeführt. Zuvor müssen aber die vorhergehenden statischen Konstruktoren des gesamten Vererbungsbaums ausgeführt worden sein. Da ein statischer Konstruktor nur ein einziges Mal während der Ausführung eines Programms aufgerufen werden soll, wird bei erster Ansprache einer Unterklasse nach der nächsthöheren Oberklasse gesucht, deren statischer Konstruktor noch nicht ausgeführt wurde. Dann wird erst deren statischer Konstruktor ausgeführt und danach sukzessive der aller folgenden Unterklassen bis zur angesprochenen Unterklasse. Im Unterschied zu Instanzkonstruktoren muss ein statischer Konstruktor hierfür nicht explizit den statischen Konstruktor seiner Oberklasse aufrufen. Stattdessen sorgt die Laufzeitumgebung automatisch dafür, dass die statischen Konstruktoren in der richtigen Reihenfolge aufgerufen
411
Aufruf
6.2
358.book Page 412 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
werden. Sie können in einer Unterklasse immer von richtig initialisierten statischen Attributen der Oberklassen ausgehen.
6.2.9
Instanzierbarkeit in der Vererbung
Eine Unterklasse umfasst die Objektbeschreibungen aller Oberklassen. Die Instanzierung einer Unterklasse bedeutet damit gleichzeitig die Instanzierung sämtlicher Oberklassen in einem einzigen Objekt, wobei die Initialisierung der Oberklassenattribute durch den Aufruf der Oberklassenkonstruktoren, wie in Abschnitt 6.2.8 beschrieben, sichergestellt wird. Die Zusätze CREATE PUBLIC|PROTECTED|PRIVATE der Anweisung CLASS bzw. die entsprechenden Einstellungen des Class Builder steuern für jede einzelne Klasse, wer eine Instanz der Klasse erzeugen oder ihren Instanzkonstruktor aufrufen darf (siehe Abschnitt 4.3.2). In der Vererbung ergeben sich daraus drei Situationen, deren Verhalten in ABAP Objects wie folgt definiert ist: 왘
Öffentlich instanzierbare Oberklasse Der Instanzkonstruktor der Oberklasse ist öffentlich sichtbar. Wenn bei einer Unterklasse die Instanzierbarkeit nicht explizit festgelegt ist, erbt sie die öffentliche Instanzierbarkeit der Oberklasse. Die Instanzierbarkeit einer Unterklasse kann explizit auf eine der drei Arten festgelegt werden. Eine Unterklasse kann die Sichtbarkeit ihres eigenen Instanzkonstruktors unabhängig von der Oberklasse steuern.
왘
Geschützt instanzierbare Oberklasse Der Instanzkonstruktor der Oberklasse ist in Unterklassen sichtbar. Wenn bei einer Unterklasse die Instanzierbarkeit nicht explizit festgelegt ist, erbt sie die geschützte Instanzierbarkeit der Oberklasse. Die Instanzierbarkeit einer Unterklasse kann explizit auf eine der drei Arten festgelegt werden. Eine Unterklasse kann die Sichtbarkeit ihres eigenen Instanzkonstruktors unabhängig von der Oberklasse steuern und damit auch den geschützten Instanzkonstruktor der Oberklasse im angegebenen Bereich veröffentlichen.
왘
Privat instanzierbare Oberklasse Der Instanzkonstruktor der Oberklasse ist nur in der Oberklasse sichtbar. Dabei sind zwei Fälle zu unterscheiden:
412
358.book Page 413 Monday, September 4, 2006 8:51 AM
Interfaces
왘
Unterklasse ist kein Freund der Oberklasse Da niemand außer der Oberklasse selbst ihren Instanzkonstruktor aufrufen darf, ist die Unterklasse nicht instanzierbar. Die Unterklasse hat sozusagen einen impliziten Zusatz CREATE NONE. Die Instanzierbarkeit der Unterklasse kann nicht explizit angegeben werden, da dies eine Veröffentlichung des Oberklassenkonstruktors im angegebenen Bereich bedeuten würde.
왘
Unterklasse ist Freund der Oberklasse Wenn bei der Unterklasse die Instanzierbarkeit nicht explizit festgelegt ist, erbt sie die private Instanzierbarkeit der Oberklasse. Die Instanzierbarkeit einer Unterklasse kann explizit auf eine der drei Arten festgelegt werden. Als Freund darf eine Unterklasse damit den privaten Konstruktor der Oberklasse im angegebenen Bereich veröffentlichen.
Wenn in einem Pfad des Vererbungsbaums eine Oberklasse für die private Instanzierbarkeit definiert wurde, kann also keine Unterklasse von äußeren Verwendern instanziert werden, und eine Unterklasse kann sich nicht einmal selbst instanzieren, da sie keinen Zugriff auf den Instanzkonstruktor der Oberklasse hat! Es bietet sich also an, eine Klasse, die für die private Instanzierbarkeit definiert wird, gleichzeitig final zu machen, um eine Ableitung von Unterklassen zu verhindern. Ausnahmen von dieser Regel gibt es nur, wenn eine privat instanzierbare Oberklasse ihren Unterklassen die Freundschaft anbietet. Da eine Oberklasse ihre Unterklassen in der Regel nicht kennt, ist dies aber eher ein seltener Fall. Eine Oberklasse kann aber auch einem Interface die Freundschaft anbieten, das dann wiederum von ihren Unterklassen implementiert werden kann (siehe Abschnitt 6.3.3). Wie immer beim Anbieten von Freundschaft sollte auch hier sehr vorsichtig vorgegangen werden, beispielsweise indem die Verwendung des befreundeten Interface auf das aktuelle Paket beschränkt wird.
6.3
Interfaces
Interfaces in ABAP Objects sind eigenständige Schnittstellen von Klassen.
413
6.3
Private Oberklasse
358.book Page 414 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
6.3.1
Grundlagen
Schnittstelle
Der einzige für einen Verwender relevante Teil einer Klasse ist ihre öffentliche Schnittstelle, die durch die Komponenten ihres öffentlichen Sichtbarkeitsbereichs aufgebaut ist. Alle anderen Komponenten sind für den Benutzer irrelevant. Dieser Aspekt wird besonders beim Einsatz abstrakter Methoden in abstrakten Klassen deutlich (siehe Abschnitt 6.2.5). Solche Klassen dienen im Wesentlichen der Definition von Schnittstellen, die erst mit Objekten von Unterklassen verwendet werden können.
Keine Mehrfachvererbung
Da ABAP Objects keine Mehrfachvererbung unterstützt, beschränkt sich die Verwendung von abstrakten Klassen zur Definition von Schnittstellen aber ausschließlich auf ihre Unterklassen. Es ist aber durchaus wünschenswert, auch allgemein gültige Schnittstellen definieren zu können, die gleichberechtigt in mehreren Klassen verwendbar sind.
Entkopplung
Solche Schnittstellen werden durch Interfaces verwirklicht. Interfaces sind eigenständig definierbare Schnittstellen ohne Implementierung, die in Klassen eingebunden und dort implementiert werden können. Interfaces dienen einer loseren Kopplung zwischen einer Klasse und einem Verwender, da sie eine zusätzliche Zugriffsschicht (Protokoll) zur Verfügung stellen. Dabei sind zwei Szenarien möglich:
BAdI
왘
Eine Klasse stellt ihre öffentliche Schnittstelle dem Verwender ganz oder teilweise in einem oder mehreren Interfaces zur Verfügung und entkoppelt ihn damit von der eigentlichen Klassendefinition. Jedes Interface beschreibt einen eigenständigen Aspekt der Klasse und bietet genau diesen und nichts als diesen einem Verwender an. Dies kann sich positiv auf die Wartbarkeit einer Klasse auswirken.
왘
Ein Verwender hat eine genaue Vorstellungen davon, wie er ein Objekt verwenden möchte, und definiert ein Interface mit sämtlichen von ihm gewünschten Komponenten. Jede Klasse, die diese Aufgabe erfüllen will, verwendet das Interface und stellt die Funktionalität zur Verfügung.
Ein sehr schönes Anwendungsbeispiel für diese Entkopplung bietet die Erweiterbarkeit von ausgelieferten ABAP-Anwendungsprogrammen in Kundensystemen durch BAdIs (Business Add- Ins). BAdIs basieren auf Interfaces, die im Originalsystem deklariert werden. Die
414
358.book Page 415 Monday, September 4, 2006 8:51 AM
Interfaces
6.3
eigentliche Funktionalität eines BAdI wird aber erst in Folgesystemen durch die Verwendung des Interface in Klassen und deren Implementierung zur Verfügung gestellt.14 Da Interfaces nur Schnittstellen ohne Implementierung sind, können wie bei abstrakten Klassen keine Objekte von ihnen erzeugt werden. Interfaces werden stattdessen in Klassen eingebunden bzw. implementiert. Wenn eine Klasse ein Interface implementiert, ist sie über diese Schnittstelle ansprechbar. Hierfür dienen spezielle Interfacereferenzvariablen. Diese können auf Objekte aller Klassen zeigen, die ihr Interface enthalten. Da beliebige Klassen das gleiche Interface einbinden können, sind ihre Objekte über ein und dieselbe Interfacereferenzvariable ansprechbar. Abbildung 6.6 stellt die Rolle von Interfaces nochmals grafisch dar. In unserer Darstellung von Objekten mit einem durch eine Schale von den äußeren Verwendern abgetrennten Inneren sind Interfaces sozusagen leere Schalen, die von Klassen statt ihrer eigenen Schalen oder als Teile ihrer eigenen Schalen verwendet werden können.15 INTERFACE if_serializable. METHODS serialize ... ... ENDINTERFACE.
INTERFACE if_writeable. METHODS write_list ... ... ENDINTERFACE.
CLASS cl_.... INTERFACES: if_serializable, if_writeable ... ... ENDINTERFACE.
iref1 iref2 DATA: iref1 TYPE REF TO if_serializable, iref2 TYPE REF TO if_writeable.
METHOD if_serializable~serialize. ... METHOD if_writeable~write_list. ...
Abbildung 6.6 Interfaces
14 Auf das große Themengebiet »Erweiterungen und Modifikationen« von ABAPAnwendungen des AS ABAP gehen wir in dieser Auflage noch nicht ein. 15 Im Vergleich zu Abbildung 6.1 ist deutlich zu sehen, dass das Einbinden von Interfaces in Klassen auch als eine Mehrfachvererbung von Interfaces an Klassen angesehen werden kann. Da Interfaces keine eigenen Methodenimplementierungen haben, treten keine konzeptionellen Probleme wie bei der Mehrfachvererbung von Klassen auf.
415
Interfacereferenzvariablen
358.book Page 416 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Wenn eine Klasse beispielsweise Services anbieten will, wie Ausgabe ihrer Attribute in eine Liste oder Serialisierbarkeit, kann sie entsprechende Interfaces implementieren. Verwender, die nur an diesen Aspekten von Objekten interessiert sind, greifen über Interfacereferenzvariablen auf diese zu. Wir gehen in den folgenden Abschnitten detailliert auf die in Abbildung 6.6 gezeigten Sprachelemente ein.
6.3.2
Interfaces anlegen
Hinsichtlich ihrer Deklaration spielen Interfaces in ABAP Objects die gleiche Rolle wie Klassen. Genau wie Klassen sind Interfaces Objekttypen, die im Namensraum aller Typen liegen. Während eine Klasse alle Aspekte einer Klasse beschreibt, beschreibt ein Interface nur einen Teilaspekt. Wie schon gesagt, können Interfaces als spezielle abstrakte Klassen ohne Implementierung angesehen werden, für die eine Mehrfachverwendung möglich ist. Dementsprechend unterscheidet sich die Deklaration eines Interface kaum von der einer Klasse. Wie bei Klassen unterscheiden wir auch globale und lokale Interfaces, für deren Verwendbarkeit das Gleiche wie für globale und lokale Klassen gilt: Globale Interfaces können in jedem Programm verwendet werden, dessen Paketzuordnung dies erlaubt. Lokale Interfaces können nur im gleichen Programm verwendet werden. INTERFACE – ENDINTERFACE
Die Syntax zur Deklaration eines lokalen Interface ist: INTERFACE intf. DATA ... CLASS-DATA ... METHODS ... CLASS-METHODS ... ... ENDINTERFACE.
Die Deklaration eines Interface entspricht im Prinzip dem Deklarationsteil einer Klasse, wobei statt CLASS – ENDCLASS einfach INTERFACE – ENDINTERFACE verwendet wird. Interfaces können exakt die gleichen Komponenten wie Klassen enthalten. Im Unterschied zu Klassen müssen Interfaces aber nicht in verschiedene Sichtbarkeitsberei-
416
358.book Page 417 Monday, September 4, 2006 8:51 AM
Interfaces
che unterteilt werden, da Interfacekomponenten immer nur in den öffentlichen Sichtbarkeitsbereich von Klassen eingebunden werden. Um ein globales Interface anzulegen, verwenden Sie wie für globale Klassen den Class Builder. Im Object Navigator wählen Sie Anlegen • Klassenbibliothek • Interface. In der Transaktion SE24 wählen Sie nach der Auswahl von Anlegen den Objekttyp Interface statt Klasse aus.16 Abbildung 6.7 zeigt den Class Builder für ein globales Interface ZIF_ DRIVE_OBJECT. Sie sehen die von Klassen gewohnte Oberfläche. Beim Anlegen von Komponenten sind die gleichen Angaben wie bei Klassen zu machen, bis auf die Einteilung in einen Sichtbarkeitsbereich. Im gezeigten Fall haben wir die gleichen Methoden ACCELERATE und SHOW_SPEED angelegt wie in ZCL_VEHICLE aus Abbildung 4.7 in Kapitel 4. Das gezeigte Interface kann somit als Schnittstelle zu Objekten dienen, die gefahren werden können.
Abbildung 6.7 Globales Interface
Der Class Builder generiert die zugehörigen ABAP-Anweisungen in einem Programm vom Typ Interface-Pool, dessen Quelltext über Springen • Interface Section auch direkt bearbeitet werden kann (siehe Abbildung 6.8). Wie in Class-Pools zeichnet der Zusatz PUBLIC das Interface als globales Interface aus, das in allen Programmen verwendet werden kann. Neben der Deklaration des globalen Interface
16 Bei Einhaltung der Namenskonvention IF_... bzw. ZIF_... wird automatisch ein Interface angelegt.
417
Class Builder
6.3
358.book Page 418 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
kann ein Interface-Pool außer der Bekanntmachung von Typgruppen keine lokalen Typdeklarationen enthalten.17
Abbildung 6.8 Quelltext eines Interface-Pools Abstraktion
Der wesentliche Unterschied zwischen Interfaces und Klassen ist der, dass es für ein Interface keinen Implementierungsteil gibt. Deshalb ist auch der Zusatz DEFINITION zu INTERFACE nicht notwendig. Die Methoden eines Interface sind alle abstrakt. Sie sind im Interface inklusive ihrer Parameterschnittstelle vollständig deklariert, jedoch nicht implementiert. Ähnlich wie die Unterklassen abstrakter Klassen deren abstrakte Methoden implementieren, müssen alle Klassen, die ein Interface verwenden wollen, dessen Methoden implementieren.18
6.3.3
Implementieren von Interfaces in Klassen
Jede Klasse kann eines oder mehrere Interfaces implementieren. Die wesentliche Voraussetzung für die Implementierung eines Interface ist die, dass das Interface der implementierenden Klasse bekannt ist. Es muss also global in der Klassenbibliothek oder lokal im gleichen Programm deklariert sein. Weiterhin muss die Verwendung des Interface durch die Paketzuordnung erlaubt sein.
17 In Interface-Pools würden solche Deklarationen nichts nutzen. In Class-Pools sind sie möglich, aber nur im privaten Bereich der globalen Klasse verwendbar. Diesen Bereich gibt es bei Interfaces nicht. 18 Genau genommen, bezieht sich die Ähnlichkeit aber nur auf Instanzmethoden. In Interfaces können auch statische Methoden ohne Implementierung definiert werden. Dies ist in abstrakten Klassen nicht möglich, da statische Methoden nicht redefinierbar sind.
418
358.book Page 419 Monday, September 4, 2006 8:51 AM
Interfaces
Die Syntax zur Implementierung von Interfaces ist:
INTERFACES
CLASS class DEFINITION. PUBLIC SECTION. INTERFACES: intf1, intf2 ... ... ... ENDCLASS.
Interfaces werden also mit der Anweisung INTERFACES im öffentlichen Sichtbarkeitsbereich einer Klasse eingebunden. In den öffentlichen Sichtbarkeitsbereich einer globalen Klasse können nur globale Interfaces eingebunden werden. Dies geschieht auf der Registerkarte Interfaces des Class Builder.
Abbildung 6.9 Interface einbinden
In Abbildung 6.9 haben wir die Klasse ZCL_VEHICLE aus Abbildung 4.7 in eine neue Klasse ZCL_VEHICLE_WITH_INTF kopiert, ihre Methoden gelöscht und das Interface ZIF_DRIVE_OBJECT aus Abbildung 6.7 angegeben. In den Spalten Abstrakt und Final können Sie festlegen, dass alle Methoden des Interface in der Klasse entweder abstrakt oder final sein sollen. In der Anweisung INTERFACES wird dies durch den optionalen Zusatz ALL METHODS ABSTRACT|FINAL ausgedrückt. Durch das Implementieren eines Interface wird die öffentliche Schnittstelle der Klasse um die Interfacekomponenten erweitert. Jede Komponente comp eines implementierten Interface intf wird zu einer vollwertigen Komponente der Klasse und innerhalb der Klasse mit dem Namen ... intf~comp ...
419
intf~comp
6.3
358.book Page 420 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
identifiziert. Interfacekomponenten werden wie klasseneigene öffentliche Komponenten an Unterklassen vererbt. Eine Klasse kann durchaus eine eigene Komponente des gleichen Namens wie eine Interfacekomponente haben, oder verschiedene implementierte Interfaces können ebenfalls gleichnamige Komponenten enthalten. Alle liegen in einem Namensraum und werden in der Klasse durch unterschiedliche Präfixe intf~ unterschieden. Das Zeichen »~« ist der Interfacekomponentenselektor.
Abbildung 6.10 Interfacemethoden
Abbildung 6.10 zeigt, wie die Methoden des Interface ZIF_DRIVE_ OBJECT in ZCL_VEHICLE_WITH_INTF angezeigt werden. Für jede einzelne Methode kann in der Detailsicht (siehe Abbildung 6.5) eingestellt werden, ob sie abstrakt oder final sein soll. Die INTERFACESAnweisung hat dafür die optionalen Zusätze ABSTRACT METHODS und FINAL METHODS. Ansonsten kann eine Interfacemethode in einer Klasse aber nicht mehr geändert werden. Bei Interfaceattributen ist es ähnlich. Die einzige Eigenschaft, die beim Einbinden in eine Klasse geändert werden kann, ist der Startwert (Zusatz DATA VALUES zu INTERFACES). Eine Klasse muss sämtliche konkreten (nicht-abstrakten) Methoden aller eingebundenen Interfaces in ihrem Implementierungsteil implementieren. Im Class Builder geschieht dies wie üblich durch Auswahl von Quelltext für jede Interfacemethode. In der Klasse ZCL_ VEHICLE_WITH_INTF haben wir im Wesentlichen die Methodenimplementierungen von ZCL_VEHICLE übernommen (siehe Listing 6.10).
420
358.book Page 421 Monday, September 4, 2006 8:51 AM
Interfaces
Listing 6.10 Implementierung von Interfacemethoden CLASS zcl_vehicle_with_intf IMPLEMENTATION. METHOD zif_drive_object~accelerate. speed = speed + delta. ENDMETHOD. METHOD zif_drive_object~show_speed. DATA output TYPE string. output = speed. CONCATENATE `Vehicle speed: ` output INTO output. MESSAGE output TYPE 'I'. ENDMETHOD. ENDCLASS.
Wenn eine Klasse in ihrem öffentlichen Sichtbarkeitsbereich keine eigenen Komponenten deklariert, sondern ausschließlich Interfaces einbindet, wird die gesamte öffentliche Schnittstelle der Klasse durch Interfaces definiert, und die Begriffe »Interface« und »äußere Schnittstelle« sind für die Klasse tatsächlich gleichbedeutend. Dies ist in unserer Beispielklasse ZCL_VEHICLE_WITH_INTF der Fall. Die bisher durch eigene Komponenten der Klasse aufgebaute Schnittstelle nach außen wurde vollständig in das Interface ZIF_DRIVE_ OBJECT ausgelagert. Listing 6.11 fasst das bisher Gesagte nochmals am Beispiel eines lokalen Interface zusammen. Hier wird die öffentliche Schnittstelle der Klasse vehicle aus Listing 4.5 in ein lokales Interface ausgelagert. Die lokale Klasse vehicle könnte statt eines lokalen Interface drive_ object aber genauso gut das globale Interface ZIF_DRIVE_OBJECT implementieren. Listing 6.11 Deklaration und Implementierung eines lokalen Interface REPORT z_vehicle_with_intf. INTERFACE drive_object. METHODS: accelerate IMPORTING delta TYPE i, show_speed. ENDINTERFACE. CLASS vehicle DEFINITION. PUBLIC SECTION. INTERFACES drive_object. PRIVATE SECTION.
421
6.3
358.book Page 422 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
DATA speed TYPE i. ENDCLASS. CLASS vehicle IMPLEMENTATION. METHOD drive_object~accelerate. speed = speed + delta. ENDMETHOD. METHOD drive_object~show_speed. DATA output TYPE string. CONCATENATE `Vehicle speed: ` output INTO output. output = speed. MESSAGE output TYPE 'I'. ENDMETHOD. ENDCLASS.
6.3.4
Zugriff auf Interfaces in Objekten
Jeder Zugriff auf Objekte erfolgt über Objektreferenzvariablen. Bisher haben wir mit Objektreferenzvariablen gearbeitet, die mit Bezug auf eine Klasse deklariert wurden: Klassenreferenzvariable
DATA cref TYPE REF TO class.
Mit solchen Referenzvariablen können alle Komponenten der Klasse class eines Objekts angesprochen werden, die an der aktuellen Stelle sichtbar sind. Wir nennen diese Art von Objektreferenzvariablen deshalb Klassenreferenzvariablen. Wie wir im letzten Abschnitt gesehen haben, werden die Interfacekomponenten eines in einer Klasse implementierten Interface in der Klasse als vollwertige Komponenten behandelt. Also könnte man versucht sein, die Interfacekomponenten eines Objekts wie folgt anzusprechen: ... cref->intf~comp ...
Das funktioniert tatsächlich. Sie können es mit unserer Klasse ZCL_ VEHICLE_WITH_INTF ausprobieren. Diese Art des Zugriffs ist aber nicht besonders schön. Der äußere Verwender einer Klasse soll auf eine Schnittstelle mit einfachen Komponenten zugreifen können, ohne sich um die technische Zusammensetzung der Schnittstelle kümmern zu müssen. Sowohl Interfaces als auch die eigenen Komponenten der Klasse selbst definieren solche Schnittstellen. Diese sollten direkt verwendet werden, aber nicht in Mischformen wie in
422
358.book Page 423 Monday, September 4, 2006 8:51 AM
Interfaces
6.3
obigem Zugriff. Kurz gesagt, der Interfacekomponentenselektor sollte nur innerhalb von Klassen (und Interfaces, siehe Abschnitt 6.3.6) verwendet werden. Für den Zugriff auf Interfacekomponenten in Objekten enthält ABAP Objects Interfacereferenzvariablen. Dabei handelt es sich um Objektreferenzvariablen, die mit Bezug auf ein Interface deklariert werden: Interfacereferenzvariable
DATA ref TYPE REF TO intf.
Eine Interfacereferenzvariable kann auf die Objekte sämtlicher Klassen zeigen, die das Interface intf implementieren. Mit einer solchen Referenzvariablen können alle Komponenten des Interface eines Objekts direkt über ... iref->comp ...
angesprochen werden. Im Gegensatz zu cref->intf~comp drückt iref->comp aus, dass auf Komponenten einer Klasse zugegriffen wird, die hierarchisch auf der gleichen Ebene, aber in einem anderen Teil der Schnittstelle liegen. Über eine Interfacereferenzvariable lassen sich genau die Komponenten eines Objekts ansprechen, die seiner Klasse durch die Implementierung des Interface intf, mit dem sie deklariert wurde, hinzugefügt wurden. Andere Komponenten, d.h. eigene Komponenten der Klasse oder Komponenten anderer Interfaces, sind über eine Interfacereferenzvariable nicht ansprechbar (nicht einmal dynamisch, siehe Abschnitte 11.1.1 und 11.4.1).
comp intf~comp
cref iref DATA: cref TYPE REF TO class, iref TYPE REF TO intf. CREATE OBJECT cref. iref = cref.
Abbildung 6.11 Interfacereferenzvariable
Abbildung 6.11 zeigt, wie Klassen- und Interfacereferenzvariablen auf das gleiche Objekt zeigen, wobei die Interfacereferenzvariable
423
358.book Page 424 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
nur die eigenen Interfacekomponenten kennt und über die Klassenreferenzvariable nur die Nicht-Interfacekomponenten der Klasse angesprochen werden sollten. Up Cast
Das Coding in Abbildung 6.11 zeigt auch schon einen Weg, wie es dazu kommt, dass Interfacereferenzvariablen auf Objekte zeigen. Sie können einfach eine Klassenreferenzvariable, die auf ein Objekt zeigt, einer Interfacereferenzvariablen zuweisen. Hierbei handelt es sich in der Regel um einen Up Cast. Mehr dazu in Abschnitt 6.4.2. Noch bequemer geht es, wenn Sie ohnehin nur an den Interfacekomponenten einer Klasse interessiert sind. Dies ist beispielsweise automatisch der Fall, wenn die gesamte öffentliche Schnittstelle einer Klasse durch ein Interface definiert ist. In solchen Fällen genügt es, die Objekte der Klasse über eine Interfacereferenzvariable zu erzeugen:
CREATE OBJECT
CREATE OBJECT iref TYPE class EXPORTING ...
Mit dem Zusatz TYPE geben Sie die Klasse des zu erzeugenden Objekts an und versorgen deren Instanzkonstruktor, falls notwendig, mit EXPORTING. Sie benötigen aber nicht unbedingt eine Klassenreferenzvariable für die Objekterzeugung. Voraussetzung ist nur, dass die Klasse class (oder eine ihrer Oberklassen) das Interface intf enthält. Verwendersicht
Ein Verwender von Objektreferenzvariablen arbeitet in der Regel mit Objekten, ohne sich um die Details ihrer Implementierung kümmern zu müssen. Anders als beim Arbeiten mit Klassenreferenzvariablen muss ein Verwender einer Interfacereferenzvariablen in der Regel nicht einmal wissen, von welcher Klasse das Objekt ist, mit dem er gerade arbeitet. Das Beispiel in Listing 6.12 demonstriert die Verwendung von Interfacereferenzvariablen. Die Methoden main und output der Klasse demo arbeiten ausschließlich mit solchen Objektreferenzvariablen, die alle mit Bezug auf unser Beispielinterface ZIF_DRIVE_OBJECT angelegt werden. Hierfür ist in demo ein interner Tabellentyp deklariert, dessen Zeilentyp ein solcher Referenztyp ist. Neben unserer globalen Beispielklasse CL_VEHICLE_WITH_INTF haben wir auch noch eine lokale Klasse electron angelegt, die ebenfalls das Interface enthält, die Methoden aber spezifisch implementiert, indem die
424
358.book Page 425 Monday, September 4, 2006 8:51 AM
Interfaces
Geschwindigkeit in Einheiten der Lichtgeschwindigkeit (c=300.000) gespeichert wird. Von jeder der beiden Klassen wird je ein Objekt erzeugt, beschleunigt und die Objektreferenz an eine interne Tabelle angehängt. Dann wird diese Tabelle an die Methode output übergeben, wo Zeile für Zeile die Interfacemethode show_speed ausgeführt wird. Listing 6.12 Interfacereferenzvariablen REPORT z_drive_many_objects. CLASS demo DEFINITION. PUBLIC SECTION. CLASS-METHODS main. PRIVATE SECTION. TYPES iref_tab_type TYPE TABLE OF REF TO zif_drive_object. CLASS-METHODS output IMPORTING iref_tab TYPE iref_tab_type. ENDCLASS. CLASS electron DEFINITION. PUBLIC SECTION. INTERFACES zif_drive_object. PRIVATE SECTION. CONSTANTS c TYPE i VALUE 300000. DATA speed_over_c TYPE p DECIMALS 3. ENDCLASS. CLASS electron IMPLEMENTATION. METHOD zif_drive_object~accelerate. me->speed_over_c = me->speed_over_c + delta / c. ENDMETHOD. METHOD zif_drive_object~show_speed. DATA output TYPE string. output = me->speed_over_c. CONCATENATE `Electron speed/c: ` output INTO output. MESSAGE output TYPE 'I'. ENDMETHOD. ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: iref_tab TYPE iref_tab_type,
425
6.3
358.book Page 426 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
iref LIKE LINE OF iref_tab. CREATE OBJECT iref TYPE zcl_vehicle_with_intf. iref->accelerate( 100 ). APPEND iref TO iref_tab. CREATE OBJECT iref TYPE electron. iref->accelerate( 250000 ). APPEND iref TO iref_tab. demo=>output( iref_tab ). ENDMETHOD. METHOD output. DATA iref LIKE LINE OF iref_tab. LOOP AT iref_tab INTO iref. iref->show_speed( ). ENDLOOP. ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Obwohl das Beispiel eng an das von Listing 4.8 angelehnt ist, zeigt es eine völlig neue Qualität. Die interne Tabelle ist wie dort eine Sammlung von Zeigern auf Objekten. Da es sich aber um Interfacereferenzvariablen handelt, können die Klassen und damit das Verhalten der Objekte, die in einer internen Tabelle gehalten werden, verschieden sein. Besonderes Augenmerk verdient hier die Methode output. Diese Methode ist ein Beispiel für den oben erwähnten Verwender, der mit Objekten arbeitet, ohne deren Klasse zu kennen. Die Methode output bekommt eine Tabelle mit Referenzvariablen übergeben und weiß, dass sie dort eine Methode show_speed aufrufen kann. Die tatsächliche Implementierung spielt für sie keine Rolle. Dies entspricht genau dem Konzept der Polymorphie, das in Abbildung 6.14 dargestellt ist und das wir im zugehörigen Abschnitt noch genauer unter die Lupe nehmen werden. Im Moment genügt es, zu sehen, dass syntaktisch absolut identische Methodenaufrufe in einer Schleife zu unterschiedlichen Ausgaben führen.
426
358.book Page 427 Monday, September 4, 2006 8:51 AM
Interfaces
6.3.5
Zugriff auf statische Interfacekomponenten
Da Interfaces die gleichen Komponenten wie Klassen enthalten können, sind auch statische Komponenten möglich. Auf die statischen Komponenten eines Interface können Sie nicht mit dem Namen des Interface und dem Klassenkomponentenselektor zugreifen. Die einzige Ausnahme sind mit CONSTANTS deklarierte Konstanten: ... intf=>const ...
Die statischen Komponenten gehören nämlich zu den statischen Komponenten jeder implementierenden Klasse. Das bedeutet, dass statische Attribute je nach Klasse unterschiedliche Werte haben und statische Methoden in jeder Klasse unterschiedlich implementiert sein können. Um instanzunabhängig auf die statischen Komponenten von Interfaces zuzugreifen, müssten Sie den Namen einer implementierenden Klasse und den Interfacekomponentenselektor verwenden: ... class=>intf~comp ...
Dies sollte aus den in Abschnitt 6.3.4 erwähnten Gründen aber die Ausnahme bleiben. Stattdessen sollten implementierende Klassen Aliasnamen (siehe Abschnitt 6.3.7) für die statischen Komponenten von Interfaces deklarieren und diese damit wie die eigenen statischen Komponenten über den Klassennamen ansprechbar machen. Natürlich können Sie auch immer mit Interfacereferenzvariablen auf statische Komponenten zugreifen, nachdem Sie Objekte von den implementierenden Klassen erzeugt haben.
6.3.6
Interfaces zusammensetzen
In Abbildung 6.9 fällt auf, dass der Class Builder für ein Interface genau wie für eine Klasse die Registerkarte Interfaces anbietet. Dementsprechend kann auch die Anweisung INTERFACES nicht nur in Klassen, sondern auch in der Deklaration eines Interface verwendet werden: INTERFACE intf1. INTERFACES: intf2, intf3, ... ... ENDINTERFACE.
427
Aliasnamen
6.3
358.book Page 428 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
Komponenteninterface
Dieser Mechanismus erlaubt es, mehrere Interfaces zu einem Interface zusammenzusetzen. Das Zusammensetzen von Interfaces kann bei der Modellierung komplexer Anwendungen hilfreich sein. Die Komponenten eines Interface intf1, das weitere Interfaces intf2, intf3, ... einbindet, setzen sich aus seinen eigenen Komponenten und den Komponenten der eingebundenen Interfaces zusammen. Die Komponenten liegen dabei alle auf der gleichen Ebene. Ein Interface, das mindestens ein anderes Interface enthält, heißt zusammengesetztes oder auch geschachteltes Interface. Ein Interface, das in einem anderen Interface eingebunden ist, heißt Komponenteninterface. Ein Komponenteninterface kann selbst zusammengesetzt sein. Betrachten wir die Mehrfachschachtelung von Interfaces in Listing 6.13. Listing 6.13 Zusammengesetzte Interfaces INTERFACE intf1. ... ENDINTERFACE. INTERFACE intf2. INTERFACES: intf1 ... ... ENDINTERFACE. INTERFACE intf3. INTERFACES: intf1, intf2 ... ... ENDINTERFACE.
Das zusammengesetzte Interface intf3 hat eine Komponente intf2, die selbst zusammengesetzt ist. Obwohl es hier danach aussieht, dass durch die Schachtelung mehrerer Interfaces eine Komponentenhierarchie entsteht, ist dem nicht so. Alle Komponenteninterfaces eines zusammengesetzten Interfaces liegen auf der gleichen Ebene. Eine Schachtelung von Namen wie intf3~intf2~intf1 ist nicht möglich. Im obigen Beispiel wird das Komponenteninterface intf1 des zusammengesetzten Interface intf2 zu einem Komponenteninterface von intf3. Ein zusammengesetztes Interface enthält jedes Komponenteninterface genau ein einziges Mal. Obwohl intf1 sowohl direkt als Komponenteninterface von intf3 als auch indirekt über
428
358.book Page 429 Monday, September 4, 2006 8:51 AM
Interfaces
6.3
intf2 in intf3 eingebunden wird, kommt es nur einmal vor. Es kann
in intf3 nur unter dem Namen intf1 adressiert werden – auch dann, wenn es nicht direkt eingebunden würde. Wenn ein zusammengesetztes Interface in einer Klasse implementiert wird, verhalten sich alle Interfacekomponenten des Interface so, als sei ihr Interface genau einmal und einzeln in der Klasse implementiert worden. Die Interfacekomponenten der einzelnen Komponenteninterfaces erweitern die öffentliche Schnittstelle der Klasse mit ihren ursprünglichen Namen. Da jedes Interface in einem zusammengesetzten Interface genau einmal vorkommt, kann es dabei zu keinen Namenskonflikten kommen. Die Art und Weise, wie ein implementiertes Interface zusammengesetzt wird, ist bei der Implementierung in eine Klasse egal. Betrachten wir das Beispiel in Listing 6.14: Listing 6.14 Implementierung zusammengesetzter Interfaces INTERFACE intf1. METHODS meth. ENDINTERFACE. INTERFACE intf2. INTERFACES intf1. METHODS meth. ENDINTERFACE. INTERFACE intf3. INTERFACES intf1. METHODS meth. ENDINTERFACE. INTERFACE intf4. INTERFACES: intf2, intf3. ENDINTERFACE. CLASS class DEFINITION. PUBLIC SECTION. INTERFACES intf4. ENDCLASS. CLASS class IMPLEMENTATION. METHOD intf1~meth. ... ENDMETHOD. METHOD intf2~meth. ... ENDMETHOD.
429
Implementierung
358.book Page 430 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
METHOD intf3~meth. ... ENDMETHOD. ENDCLASS.
Hier wird eine gleichnamige Methode meth in drei individuellen Interfaces deklariert und mit Hilfe des Interfacekomponentenselektors deshalb auch dreimal unterschiedlich implementiert. Die Zusammensetzung der Interfaces spielt dabei keine Rolle: Die Methode intf1~meth wird nur einmal implementiert, obwohl sie in zwei Interfaces intf2 und intf3 vorhanden ist. Der Name intf4 taucht im Implementierungsteil der Klasse überhaupt nicht auf. Wenn Sie im Deklarationsteil obiger Klasse class zusätzlich zu intf4 eines oder mehrere der übrigen Interfaces intf1, intf2 oder intf3 aufführen, ändert sich an den Komponenten und dem Implementierungsteil der Klasse gar nichts, da der Compiler bei einer Klasse wie in zusammengesetzten Interfaces immer dafür sorgt, dass jede Komponente nur einmal vorhanden ist. Zugriff
Für den Zugriff auf Objekte, deren Klasse ein zusammengesetztes Interface implementiert, gilt das Gleiche, als würde die Klasse jedes Interface einzeln implementieren. D.h., der Zugriff auf Interfacekomponenten sollte mit Interfacereferenzvariablen vom Typ des jeweiligen Komponenteninterface erfolgen. Mit entsprechenden Zuweisungen an Interfacereferenzvariablen (Up Casts, siehe Abschnitt 6.4.2) kann das immer bewerkstelligt werden. Der Interfacekomponentenselektor sollte hierfür nicht verwendet werden. Er kann aber in einem zusammengesetzten Interface verwendet werden, um die Komponenten von Komponenteninterfaces wie eigene Komponenten zugänglich zu machen.
6.3.7
Aliasnamen für Interfacekomponenten
Der vollständige Name einer Komponente, die durch ein Interface zu einer Klasse oder einem anderen Interface hinzugefügt wird, lautet intf~comp. Für diesen Namen kann auf der Ebene, auf der das Interface mit der Anweisung INTERFACES eingebunden wird, wie folgt ein Aliasname definiert werden: ALIASES
ALIASES name FOR intf~comp.
Aliasnamen können also beim Implementieren von Interfaces im Deklarationsteil einer Klasse oder beim Zusammensetzen von Inter-
430
358.book Page 431 Monday, September 4, 2006 8:51 AM
Interfaces
faces in der Deklaration eines Interface vergeben werden. Im Class Builder können Sie Aliasnamen für Klassen wie für Interfaces auf der Registerkarte Aliases eintragen (siehe Abbildung 6.12).
Abbildung 6.12 Aliasnamen
Aliasnamen in Klassen In Klassen gehören Aliasnamen zum Namensraum der Komponenten einer Klasse und müssen dort, wie die anderen Komponenten auch, einem Sichtbarkeitsbereich zugeordnet werden. Die Sichtbarkeit eines Aliasnamens von außerhalb der Klasse richtet sich nach seinem Sichtbarkeitsbereich und nicht nach dem Sichtbarkeitsbereich der zugeordneten Interfacekomponente. In Listing 6.15 modifizieren wir das Beispiel aus Listing 6.12, indem wir Aliasnamen verwenden. In der lokalen Klasse electron deklarieren wir hierfür wie für ZCL_VEHICLE_WITH_INTF (siehe Abbildung 6.12) einen Aliasnamen accelerate für die Interfacemethode zif_ drive_object~accelerate. Listing 6.15 zeigt nur die Unterschiede zu Listing 6.12. Listing 6.15 Aliasnamen in Klassen REPORT z_drive_via_aliases. ... CLASS electron DEFINITION. PUBLIC SECTION. INTERFACES zif_drive_object.
431
6.3
358.book Page 432 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
ALIASES accelerate FOR zif_drive_object~accelerate. PRIVATE SECTION. ... ENDCLASS. CLASS electron IMPLEMENTATION. METHOD accelerate. me->speed_over_c = me->speed_over_c + delta / c. ENDMETHOD. ... ENDCLASS. CLASS demo IMPLEMENTATION. METHOD main. DATA: vehicle TYPE REF TO zcl_vehicle_with_intf, electron TYPE REF TO electron, iref_tab TYPE iref_tab_type. CREATE OBJECT vehicle. vehicle->accelerate( 100 ). APPEND vehicle TO iref_tab. CREATE OBJECT electron. electron->accelerate( 250000 ). APPEND electron TO iref_tab. demo=>output( iref_tab ). ENDMETHOD. ... ENDCLASS. START-OF-SELECTION. demo=>main( ).
Die Interfacemethode kann in der Klasse jetzt unter ihrem Aliasnamen implementiert und von einem Verwender wie eine direkte Methode der Klasse aufgerufen werden. Wir ändern die Methode main, in der die Klassen für die Objekterzeugung ohnehin bekannt sein müssen, so ab, dass die Objekte über Klassenreferenzvariablen erzeugt werden. Wegen des Aliasnamens kann mit diesen die Interfacemethode accelerate aufgerufen werden, ohne dass der Interfacekomponentenselektor notwendig ist. In der Methode output, die nichts von den Klassen wissen muss, wird nichts geändert.
432
358.book Page 433 Monday, September 4, 2006 8:51 AM
Interfaces
Eine Klasse kann mit Aliasnamen ihre Interfacekomponenten sozusagen als klassenspezifische Komponenten veröffentlichen. Insbesondere können Aliasnamen in Klassen auch dazu verwendet werden, klassenspezifische Komponenten, die im Lauf eines Entwicklungszyklus in Interfaces ausgelagert werden, weiterhin unter ihrem alten Namen anzusprechen. Dadurch müssen die Verwender der Klasse nicht an die neuen Namen angepasst werden. In unserer Beispielklasse ZCL_VEHICLE_WITH_INTF haben wir die Methoden aus ZCL_VEHICLE in Interfacemethoden verwandelt. Stellen Sie sich vor, wir hätten diese Änderung direkt in ZCL_ VEHICLE vorgenommen. Sämtliche Verwender wären syntaktisch inkorrekt geworden. Durch die gleichzeitige Einführung von Aliasnamen wäre die Klasse aber unverändert ansprechbar geblieben.
Aliasnamen in zusammengesetzten Interfaces Da in zusammengesetzten Interfaces keine Verkettungen von Namen möglich sind, stellen Aliasnamen in Komponenteninterfaces die einzige Möglichkeit dar, solche Komponenten zu adressieren, die im zusammengesetzten Interface sonst nicht zur Verfügung stünden. Betrachten wir das Beispiel in Listing 6.16. Listing 6.16 Aliasnamen in Interfaces INTERFACE intf1. METHODS meth1. ENDINTERFACE. INTERFACE intf2. INTERFACES intf1. ALIASES meth1 FOR intf1~meth1. ENDINTERFACE. INTERFACE intf3. INTERFACES intf2. ALIASES meth1 FOR intf2~meth1. ENDINTERFACE.
Das Interface intf3 kann über den Aliasnamen meth1 in intf2 die Komponente meth1 des Interface intf1 in seiner eigenen Anweisung ALIASES ansprechen. Ohne Aliasnamen in intf2 wäre das nicht möglich, da die Bezeichnung intf2~intf1~m1 nicht erlaubt ist. Jetzt kann
433
6.3
358.book Page 434 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
ein Verwender von intf3 auf die Komponente meth1 in intf1 zugreifen, ohne etwas über die Zusammensetzung des Interface wissen zu müssen: DATA i_ref TYPE REF TO intf3. ... i_ref->meth1( ... ).
Ohne Aliasnamen in intf3 müsste der Zugriff wie folgt aussehen: i_ref->intf1~meth1( ... ).
Der Verwender müsste also wissen, dass intf3 aus intf2 und dieses wiederum aus intf1 zusammengesetzt ist. Insbesondere bei globalen Interfaces sollte man nicht verlangen, dass sich der Verwender die Zusammensetzung eines Interface im Class Builder anschaut, bevor er eine Methode des Interface verwenden kann. Es ist aber nicht notwendig, dass die Aliasnamen immer genauso heißen wie die Originalnamen.
6.3.8
Interfaces und Vererbung
Zum Abschluss unserer Beschreibung von Interfaces wollen wir noch kurz auf das Verhältnis von Interfaces zur Vererbung eingehen und beide Konzepte nochmals zusammenfassend gegenüberstellen. Die Konzepte von Interfaces und Vererbung sind unabhängig voneinander und vollständig miteinander verträglich. In den Klassen eines Vererbungsbaums können beliebig viele Interfaces implementiert werden, wobei jedes Interface aber nur einmal pro Pfad des Vererbungsbaums implementiert werden kann. Dadurch hat jede Interfacekomponente über den gesamten Vererbungsbaum einen eindeutigen Namen intf~comp und ist ab der Klasse, die das Interface implementiert, in allen Unterklassen enthalten. Interfacemethoden sind nach ihrer Implementierung vollwertige Komponenten einer Klasse und können in Unterklassen redefiniert werden. Interfacemethoden können zwar in der Deklaration des Interface nicht als abstrakt oder final gekennzeichnet werden, jede Klasse kann dies aber bei der Implementierung des Interface für sich festlegen. Kopplung
Der Einsatz von Vererbung ist immer sinnvoll, wenn unterschiedliche Klassen in einer Generalisierungs-/Spezialisierungsbeziehung
434
358.book Page 435 Monday, September 4, 2006 8:51 AM
Interfaces
zueinander stehen. Wenn wir beispielsweise zwei Klassen »Frachtflugzeug« und »Passagierflugzeug« betrachten, finden sich in beiden Klassen Komponenten, die in einer gemeinsamen Oberklasse »Flugzeug« deklariert werden können. Der große Nutzen der Vererbung ist, dass die Unterklassen alle bereits in der Oberklasse programmierten Eigenschaften übernehmen und damit wieder verwenden. Gleichzeitig besteht dadurch eine äußerst enge Kopplung zwischen Ober- und Unterklassen. Eine Unterklasse hängt stark von ihren Oberklassen ab, da sie in der Regel zum Großteil aus den Komponenten der Oberklassen besteht. Eine Unterklasse muss über ihre Oberklasse genau Bescheid wissen. Deutlich wurde dies z.B. bei der Diskussion von Instanzkonstruktoren in der Vererbung in Abschnitt 6.2.8. Jede Änderung von nicht-privaten Komponenten einer Oberklasse ändert sämtliche Unterklassen. Umgekehrt können auch Unterklassen durch bestimmte Anforderungen das Design von Oberklassen beeinflussen. Wenn Sie Vererbung zur Definition von Klassen verwenden, sollten Sie im Idealfall Zugriff auf alle beteiligten Klassen haben, da nur sämtliche Klassen eines Pfads des Vererbungsbaums ein sinnvolles Ganzes ergeben. Eher gefährlich ist es dagegen, sich einfach durch Definition einer Unterklasse an irgendeine Oberklasse anzuhängen, wenn sie nicht zum gleichen Paket gehört oder explizit in der Paketschnittstelle als Oberklasse freigegeben wurde.19 Der Einsatz von Interfaces bietet sich immer an, wenn Schnittstellen oder Protokolle beschrieben werden sollen, ohne dass damit gleich eine bestimmte Art der Implementierung verbunden ist. Zwischen Verwender und Klasse wird eine zusätzliche Schicht eingeführt, die den Verwender von einer expliziten Klasse entkoppelt und dadurch viel unabhängiger macht. Interfaces erlauben es dem Verwender, mit verschiedensten Klassen uniform umzugehen, ohne dass die Klassen gleichzeitig miteinander gekoppelt sein müssen. In der objektorientierten Modellierung bieten Interfaces eine von Klassen unabhängige Abstraktion an: Unabhängig von der tatsächlichen Implementierung können die Dienstleistungen beschrieben werden, die ein Verwender braucht. Zudem realisieren Interfaces gewissermaßen auch einen Aspekt der Mehrfachvererbung, da mehrere Interfaces in einer Klasse implementiert werden können. Wenn eine Programmierspra19 Ein vollständiges Paketkonzept, das es erlaubt, solche Angaben in der Paketschnittstelle vorzugeben und zu überprüfen, wird aber erst im kommenden Release verwirklicht.
435
Entkopplung
6.3
358.book Page 436 Monday, September 4, 2006 8:51 AM
6
Weiterführende Konzepte von ABAP Objects
che eine echte Mehrfachvererbung zulässt, wird Mehrfachvererbung in der Regel auch nur im Sinn von Interfaces verwendet. Das heißt, nur abstrakte Klassen mit ausschließlich abstrakten Methoden kommen als verschiedene Oberklassen einer einzigen Unterklasse in Frage. Ansonsten würde sich sofort die Frage stellen, welche Methodenimplementierung in einer Unterklasse eigentlich verwendet wird, wenn diese schon in mehreren Oberklassen implementiert sein sollte.20 Ähnlich wie bei Oberklassen in der Vererbung ist aber auch bei Interfaces zu beachten, dass nachträgliche Änderungen an Interfaces sämtliche Klassen, die das Interface implementieren, syntaktisch inkorrekt machen können.
6.4
Objektreferenzen und Polymorphie
Objektreferenzen sind der Dreh- und Angelpunkt beim Umgang mit Objekten. Sie werden zur Objekterzeugung verwendet und dienen der Adressierung von Objekten. Als Inhalt von Objektreferenzvariablen können sie anderen Variablen zugewiesen oder an Prozeduren übergeben werden. Objektreferenzvariablen unterteilen sich in Klassenreferenzvariablen und in Interfacereferenzvariablen. Bei der Verwendung von Interfacereferenzvariablen haben wir bereits gesehen, dass der Typ einer Referenzvariablen nicht dem Typ des referenzierten Objekts entsprechen muss. In diesem Abschnitt gehen wir näher auf diese Tatsache und das daraus folgende polymorphe Verhalten von Methodenaufrufen ein.
6.4.1
Statischer und dynamischer Typ
In diesem Abschnitt definieren wir zwei wichtige Begriffe für Referenzvariablen, nämlich deren statischen und dynamischen Typ. Statischer Typ
Der statische Typ einer Referenzvariablen oref ist der Typ, der bei der Deklaration hinter 20 Dies ist das »Diamantproblem« der Mehrfachvererbung. Eine Methode, die in einer Oberklasse deklariert ist, wird in zwei Unterklassen redefiniert, die Oberklasse von einer weiteren Unterklasse ist. Welche Implementierung wird in dieser Unterklasse verwendet? Bei Interfaces tritt das Problem nicht auf, da bei der Implementierung von zusammengesetzten Interfaces jede Interfacemethode nur einmal vorhanden ist.
436
358.book Page 1107 Monday, September 4, 2006 8:51 AM
Index #EC erweiterte Programmprüfung 1030 $TMP Paket 64 & Literaloperator 293 * arithmetischer Operator 311 Kommentar 90 + arithmetischer Operator 311 / arithmetischer Operator 311 = Vergleichsoperator 319 Zuweisungsoperator 297 arithmetischer Operator 311 Strukturkomponentenselektor 267 => Klassenkomponentenselektor 138, 214 -> Objektkomponentenselektor 138, 220, 272 > Vergleichsoperator 319 ->* Dereferenzierungsoperator 273, 884 >= Vergleichsoperator 319 ?= Casting-Operator 444, 891 ~ Interfacekomponentenselektor 419 Spaltenselektor 787, 794 4GL Fourth Generation Language 24, 25
A A Nachrichtentyp 732 ABAP Advanced Business Application Programming 23
Allgemeiner Berichts Aufbereitungs Prozessor 23 Anforderungen 30 klassisch 489 Programmiermodelle 490 ABAP Debugger klassisch 1036 konfigurieren 1039 neu 1036 Oberfläche 1037 Verwendung 103, 1045 Werkzeug 1036 ABAP Dictionary Ablage 72 Dynpro-Feld 580 Werkzeug 72, 277 ABAP Editor Direkteinstieg 60 einstellen 88 ABAP Memory Daten-Cluster 855 Hauptmodus 188 ABAP Objects ABAP 24 Objektorientierung 195 Verwendung 27, 118, 240 ABAP Unit Code Inspector 1058 Organisation 1049 Verwendung 1051 Werkzeug 1048 ABAP Workbench AS ABAP 153 Entwicklungsumgebung 57 Programmierwerkzeuge 59 ABAP/4 R/3 24 ABAP-Glossar ABAP-Schlüsselwortdokumentation 148 ABAP-Laufzeitanalyse Werkzeug 1068 ABAP-Laufzeitumgebung AS ABAP 153, 161 Virtual Machine 94
1107
358.book Page 1108 Monday, September 4, 2006 8:51 AM
Index
ABAP-Programm aktivieren 94 anlegen 87 Aufbau 163 aufrufen 167 ausführen 94, 166 kopieren 97 laden 167, 189 Modularisierung 198 testen 1023 Typ 170 ABAP-Prozessor AS ABAP 158 ABAP-Schlüsselwortdokumentation öffnen 100 verwenden 146 ABAP-Scripting BSP 733 ABAP-Syntax Kettensatz 100 Kommentare und Anweisungen 89 ABAP-Typ eingebaut 257 generisch 287 ABAP-Wort ABAP-Anweisung 90 Abbruchmeldung Nachrichtentyp 732 abfangbarer Laufzeitfehler Verwendung 547 Ablauflogik Dynpro 563 abs numerische Funktion 313 ABSTRACT CLASS 400 METHODS 401 abstrakt Interface 418 Abstraktion Objektorientierung 193 Abwärtskompatibilität ABAP 38, 489 ABAP Objects 195 acos Gleitpunktfunktion 313 ADD ABAP-Anweisung 311
1108
Agent Klasse 206, 227 Aggregatfunktion SELECT-Klausel 780, 799 Aktion Web Dynpro ABAP 756 Aktivierung Repository Objekt 78 Aktualisierungsperre Shared Objects 478 Aktualparameter Ereignis 463 Funktionsbaustein 514 übergeben 385 ALIASES ABAP-Anweisung 430 Aliasname Interface 433 Interfacekomponente 430 Klasse 431 ALL WHERE-Klausel 798 ALL INSTANCES SET HANDLER 468 alternativer Spaltenname SELECT-Klausel 780 alternativer Tabellenname SELECT 794 ALV Beispiel 665 Druckliste 725 SAP List Viewer 144, 647 ALV Grid Control CFW 647 ALV-Liste Reporting 721 AND boolescher Operator 323 WHERE-Klausel 786 AND RETURN SUBMIT 168 Ankreuzfeld Bildschirmelement 575 Selektionsbild 676 anonymes Datenobjekt Datentyp 886 dynamisches Speicherobjekt 1060 erzeugen 886 Verwendung 887
358.book Page 1109 Monday, September 4, 2006 8:51 AM
Index
Anweisung ABAP-Programm 90 obsolet 489 Anweisungsblock Kontrollstruktur 324 Anwendungs-Control CFW 645 Anwendungsereignis GUI Control 652 Anwendungsfunktionsleiste Funktion 585 SAP GUI 562, 583 Selektionsbild 694 Anwendungskomponente Paket 67 ANY WHERE-Klausel 798 any generischer Typ 288 ANY TABLE generische Tabellenart 352 any table generischer Typ 288 APPEND ABAP-Anweisung 357 APPENDING TABLE INTO-Klausel 781 Application Server Verwendungsart 152 Application Server ABAP SAP NetWeaver 153 Application Server Java SAP NetWeaver 153 Applikationsschicht AS ABAP 157 Applikationsserver AS ABAP 185 Architektur serviceorientiert 972 ArchiveLink Druckliste 715 Archivierungsparameter Spoolauftrag 716 AREA HANDLE CREATE OBJECT 481 aRFC asynchroner RFC 922 ausführen 932 Verwendung 923
arithmetischer Ausdruck Rechenausdruck 311 AS Application Server 152 AS ABAP Application Server ABAP 24, 153 System 184 Trial Version 38, 51 Verfügbarkeit 38 AS Java Application Server Java 153 AS WINDOW SELECTION-SCREEN 688 ASAP ABAP Objects 373 ASCENDING SORT 363 asin Gleitpunktfunktion 313 ASSERT ABAP-Anweisung 557 Assertion verwenden 557 Vorteile 556 Zusicherung 556 ASSIGN ABAP-Anweisung 872 dynamisch 904 ASSIGN COMPONENT ABAP-Anweisung 875 ASSIGN INCREMENT ABAP-Anweisung 877 ASSIGNING LOOP 360 READ TABLE 358 asXML ABAP Serialization XML 1003, 1004 asynchrone Kommunikation tRFC 938 AT END OF ABAP-Anweisung 361 AT EXIT COMMAND MODULE 597 AT NEW ABAP-Anweisung 361 AT SELECTION-SCREEN Ereignis 493 Selektionsbildereignis 689, 690
1109
358.book Page 1110 Monday, September 4, 2006 8:51 AM
Index
atan Gleitpunktfunktion 313 ATRA Transaktion 1069 Attribut anlegen 208 deklarieren 124 Objektorientierung 192, 370 XML 993 Aufgabe Transportauftrag 70 Aufrufhierarchie Ausnahmebehandlung 533 Aufrufkette Hauptmodus 188 ausführbares Programm ABAP-Laufzeitumgebung 492 aufrufen 168 ausführen 491 Programmtyp 172 Verwendung 501 Ausgabefeld Selektionsbild 685 Ausgabeparameter Ereignis 461 Formalparameter 375 Funktionsbaustein 510 Auslieferungsklasse Datenbanktabelle 73 Ausnahme abfangen 529 auslösen 527 behandelbar 525 behandeln 529 Behandler 529 deklarieren 123, 536 Funktionsbaustein 511 Kategorie 538 nicht-klassenbasiert 546 Parameterschnittstelle 374 propagieren 532 RFC API 946 unbehandelbar 525 Ausnahmebehandler klassenbasierte Ausnahme 529 Ausnahmebehandlung ABAP 525 Aufräumarbeiten 534 durchführen 102
1110
Funktionsbaustein 515 klassenbasiert 526 klassenbasiert/klassisch 552 klassisch 546 Nachrichten 550 Ausnahmegruppe abfangbarer Laufzeitfehler 547 Ausnahmeklasse 554 Ausnahmekategorie Verwendung 539 Ausnahmeklasse anlegen 119, 539 Attribute 540 Ausnahmetext 541 klassenbasierte Ausnahme 526 lokal 541 Methoden 540 Vorteile 527 Ausnahmeobjekt erzeugen 528 klassenbasierte Ausnahme 526 Ausnahmetext anlegen 542 Nachricht 542, 552, 732 OTR 542 Verwendung 543 Auswahlknopf Bildschirmelement 575 Selektionsbild 676 Auszeichnungselement XML 991 AUTHORITY_CHECK_TCODE Berechtigungsprüfung 862 AUTHORITY-CHECK ABAP-Anweisung 863 Automation Queue CFW 649 AVG Aggregatfunktion 780
B BACK ABAP-Anweisung 705 BACKGROUND TASK CALL FUNCTION 937 BAdI Interface 415
358.book Page 1111 Monday, September 4, 2006 8:51 AM
Index
Barrierefreiheit Produktstandard 719 BEGIN OF TYPES/DATA 266 Beispielbibliothek ABAP-Schlüsselwortdokumentation 150 Benutzerdialog anlegen 106 entkoppeln 106 Benutzermenü SAP Easy Access 57 Benutzerschnittstelle AS ABAP 155 Benutzersitzung Applikationsserver 187 Benutzungsoberfläche ABAP 559 Berechtigung Berechtigungsprüfung 861 prüfen 861 Berechtigungsgruppe Berechtigungsprüfung 863 Berechtigungsobjekt Berechtigungsprüfung 860 Berechtigungsprofil Berechtigungsprüfung 861 Berechtigungsprüfung AS ABAP 860 Beschreibungsfunktion Funktion 313 BETWEEN Prädikat 322 WHERE-Klausel 787 bgRFC Background RFC 940 Bibliothek Java 36 Bildschirmbild Dynpro 562 SAP GUI 562 Bildschirmelement Dynpro-Feld 578 Eigenschaften 576 Funktionscode 583 Layout Editor 574 modifzieren 576 SAP GUI 562 Selektionsbild 673
Bildschirmliste klassische Liste 706 Bitausdruck Rechenausdruck 311 Blätterleiste SAP GUI 562 Block Selektionsbild 686 boolescher Operator logischer Ausdruck 323 BREAK-POINT ABAP-Anweisung 1043 Breakpoint ABAP Debugger 1042 setzen 103 Browser Control Beispiel 664 CFW 646 BSP Business Server Pages 156, 561, 562, 733 Bündelung SAP LUW 812 Business Key Objektidentität 828 Business Server Page AS ABAP 156, 561, 733 BY SORT 364 BYPASSING BUFFER Open SQL 822 byteartig Datentyp 259 BYTE-CA Vergleichsoperator 322 BYTE-CN Vergleichsoperator 322 BYTE-CO Vergleichsoperator 322 Bytecode ABAP-Programm 94 BYTE-CS Vergleichsoperator 322 Bytefeld Datenobjekt 258, 262 Bytekette verarbeiten 330 BYTE-NA Vergleichsoperator 322
1111
358.book Page 1112 Monday, September 4, 2006 8:51 AM
Index
BYTE-NS Vergleichsoperator 322 Bytestring Datenobjekt 263
C c ABAP-Typ 258, 261 CA Vergleichsoperator 322, 343 CALL FUNCTION ABAP-Anweisung 514 dynamisch 910 CALL METHOD ABAP-Anweisung 386 dynamisch 907 CALL SCREEN ABAP-Anweisung 567, 569 CALL SELECTION-SCREEN ABAP-Anweisung 688 CALL SUBSCREEN Dynpro-Anweisung 635 CALL TRANSACTION ABAP-Anweisung 568 CALL TRANSFORMATION ABAP-Anweisung 1002 ABAP-Programm 1012 iXML Library 995 CALL TRANSACTION ABAP-Anweisung 170 Callback-Routine aRFC 933 Kontextmenü 589 CASE ABAP-Anweisung 326 Kontrollstruktur 326 CASTING ASSIGN 880 Casting Feldsymbol 879 Casting-Operator Down Cast 444 CATCH ABAP-Anweisung 529 CATCH-Block TRY-Kontrollstruktur 529 CATT Werkzeug 1075
1112
ceil numerische Funktion 313 CFW Control Framework 642 CHAIN Dynpro-Anweisung 594, 598 CHANGING Aktualparameter 386 FORM 516 METHOD 210 METHODS 375 PERFORM 518 charlen Beschreibungsfunktion 313, 342 CHECK ABAP-Anweisung 329 CHECKBOX PARAMETERS 676 Checkpoint ABAP-Programm 1043 Checkpoint-Gruppe Assertion 557 Breakpoint 1043 CL_ABAP_CLASSDESCR RTTI 897 CL_ABAP_MATCHER regulärer Ausdruck 339 CL_ABAP_MEMORY_AREA Shared Objects 479 CL_ABAP_REGEX regulärer Ausdruck 339 CL_ABAP_STRUCTDESCR RTTI 897 CL_ABAP_TYPEDESCR RTTI 894 CL_AUNIT_ASSERT ABAP Unit 1056 CL_CTMENU Konextmenü 589 CL_GUI_ALV_GRID CFW 647 CL_GUI_CFW CFW 643 CL_GUI_CONTROL CFW 643 CL_GUI_CUSTOM_CONTAINER CFW 644 CL_GUI_DIALOGBOX_CONTAINER CFW 644
358.book Page 1113 Monday, September 4, 2006 8:51 AM
Index
CL_GUI_DOCKING_CONTAINER CFW 644 CL_GUI_FRONTEND_SERVICES Systemklasse 851 CL_GUI_HTML_VIEWER CFW 646 CL_GUI_OBJECT CFW 643 CL_GUI_PICTURE CFW 646 CL_GUI_SIMPLE_TREE CFW 647 CL_GUI_SPLITTER_CONTAINER CFW 644 CL_GUI_TEXTEDIT CFW 646 CL_GUI_TOOLBAR CFW 645 CL_HTTP_UTILITY ICF 970 CL_SALV_EVENTS_TABLE ALV 721 CL_SALV_FUNCTIONS ALV 722 CL_SALV_HIERSEQ_TABLE ALV 654 CL_SALV_PRINT ALV 725 CL_SALV_TABLE ALV 654 CL_SALV_TREE ALV 654 CL_SHM_AREA Shared Objects 479 CLASS ABAP-Anweisung 199 Class Builder verwenden 121 Werkzeug 198 class_constructor statischer Konstruktor 235 CLASS-DATA ABAP-Anweisung 208 CLASS-EVENTS ABAP-Anweisung 461 CLASS-METHODS ABAP-Anweisung 210 CLASS-POOL ABAP-Anweisung 171
Class-Pool ABAP-Programm 238 Programmtyp 171 CLEANUP ABAP-Anweisung 529 CLEANUP-Block TRY-Kontrollstruktur 530 verlassen 535 Verwendung 534 CLEAR ABAP-Anweisung 311 CLIENT SPECIFIED Open SQL 820 Client-Programm Webservice 987 Client-Proxy Webservice 986 Client-Server-Architektur AS ABAP 155 clike generischer Typ 288 CLOSE CURSOR ABAP-Anweisung 802 CLOSE DATASET ABAP-Anweisung 848 CN Vergleichsoperator 322, 343 CO Vergleichsoperator 322, 343 Code Inspector Framework 1035 Werkzeug 1030 COLLECT ABAP-Anweisung 356 Commit Datenbank 810 COMMIT WORK ABAP-Anweisung 813, 938 Persistenzdienst 839 COMMUNICATION_FAILURE RFC 932 Component-Controller Web-Dynpro-Component 745 COMPUTE ABAP-Anweisung 313 CONCATENATE ABAP-Anweisung 332 CONDENSE ABAP-Anweisung 332
1113
358.book Page 1114 Monday, September 4, 2006 8:51 AM
Index
CONSTANTS ABAP-Anweisung 209, 290 constructor Instanzkonstruktor 232 Container Klasse 206 Container-Control CFW 644 Context-Binding Web Dynpro ABAP 752 Context-Mapping Web Dynpro ABAP 749 CONTINUE ABAP-Anweisung 329 Control Framework CFW 642 Control-Ereignis Beispiel 667 Controller MVC 734, 745 CONTROLS ABAP-Anweisung 632, 636 CONVERT DATE ABAP-Anweisung 318 CONVERT TEXT ABAP-Anweisung 332 CONVERT TIME STAMP ABAP-Anweisung 318 Cookie Zugriff 966 Copy-on-Write dynamisches Datenobjekt 1061 interne Tabelle 307 CORRESPONDING FIELDS OF INTO-Klausel 784 cos Gleitpunktfunktion 313 cosh Gleitpunktfunktion 313 COUNT Aggregatfunktion 780 Coverage Analyzer aufrufen 1074 Werkzeug 1073 CP Vergleichsoperator 322, 343 CREATE DATA ABAP-Anweisung 295, 886
1114
CREATE OBJECT ABAP-Anweisung 219, 424 CREATE PRIVATE CLASS 204 CREATE PROTECTED CLASS 204 CREATE PUBLIC CLASS 204 CREATE_PERSISTENT Persistenzdienst 835 CS Vergleichsoperator 322, 343 csequence generischer Typ 288 CTS SAP Change and Transport System 65 cursor Datentyp 802 Cursor-Variable Datenbank-Cursor 801 Custom-Container CFW 644 Custom-Control Bildschirmelement 575 CX_DYNAMIC_CHECK Ausnahmekategorie 538 Ausnahmeklasse 527 CX_NO_CHECK Ausnahmekategorie 539 Ausnahmeklasse 527 CX_ROOT Ausnahmeklasse 526 CX_STATIC_CHECK Ausnahmekategorie 538 Ausnahmeklasse 526 CX_SY_NO_HANDLER Ausnahmeklasse 536
D d ABAP-Typ 258, 261 DATA ABAP-Anweisung 208, 246 data generischer Typ 288 Data Browser Werkzeug 104
358.book Page 1115 Monday, September 4, 2006 8:51 AM
Index
DATA BUFFER Daten-Cluster 855 Datei Applikationsserver 846 lesen 847 löschen 848 öffnen 846 Präsentationsserver 851 schließen 848 schreiben 847 Dateiname logisch 845 Dateischnittstelle AS ABAP 845 Daten ABAP-Programm 245 Attribut 247 Kapselung 248 lokal 247 numerisch 249 programmglobal 247 zeichenartig 249 Datenablage persistent 769 Datenbank AS ABAP 159 Commit 810 LUW 809 Rollback 811 Sperre 815 Datenbankanmeldung AS ABAP 186 Datenbank-Cursor öffnen 801 Datenbankschnittstelle AS ABAP 159, 771 Datenbanktabelle 788 ABAP Dictionary 772 aktivieren 81 anlegen 72 auslesen 776 Daten-Cluster 856 Datentyp 275 Inhalt ändern 805 relational 770 Repository-Objekt 71 Struktur 772 technische Einstellungen 80 Zeile ändern 806
Zeile einfügen oder ändern 807 Zeile löschen 808 Zeilen einfügen 805 Datenbank-View ABAP Dictionary 773 auslesen 792 Daten-Cluster ablegen 855 AS ABAP 855 einlesen 857 löschen 857 Datendeklaration durchführen 100 Datenelement ABAP Dictionary 278 aktivieren 78 anlegen 76, 278 Datenbanktabelle 75 Datenelement-Dokumentation Feldhilfe 599 Datenelementpflege ABAP Dictionary 76 Datenelement-Zusatzdokumentation Feldhilfe 599 Datenhaltung Konsistenz 808 Datenkapselung ABAP Objects 27 Datenobjekt ABAP-Programm 246 anonym 295, 885 benannt 289 deklarieren 246 dynamisch 263 elementar 257 Kontext 247 konvertieren 298 Namen 246 numerisch 312 Operationen 297 statisch 259 vordefiniert 295 zuweisen 297 Datenreferenz dynamische Programmierung 868 zuweisen 890 Datenreferenzvariable deklarieren 272, 882
1115
358.book Page 1116 Monday, September 4, 2006 8:51 AM
Index
Datentyp ABAP Dictionary 254, 273 ABAP-Typenhierarchie 250 Datenobjekt 249 definieren 253 Domäne 79 eigenständig 253 elementar 257 gebunden 253 generisch 258 global 254, 273 Klasse 216 Klasse/Interface 254 lokal 124 programmlokal 255 Typgruppe 255 Verwendung 256 Datenübertragung AS ABAP 918 Datenverarbeitung betriebswirtschaftlich 30 Datenwurzel Simple Transformation 1013 Datumsfeld berechnen 315 Datenobjekt 258, 261 Gültigkeit 316 vergleichen 320 DCL Data Control Language 771 DDL Data Definition Language 771 Debuggee ABAP Debugger 1036 Debugger ABAP Debugger 1036 Debugger Breakpoint ABAP Debugger 1042 Debugger-Werkzeuge ABAP Debugger 1041 Debugging-Sitzung ABAP Debugger 1041 beenden 1042 starten 1041 DECIMALS TYPES/DATA 265 DEFAULT METHODS 384 PARAMETERS 676
1116
DEFERRED CLASS DEFINITION 229 DEFINE ABAP-Anweisung 184 DEFINITION CLASS 199 Deklarationsteil ABAP-Programm 92, 163 Klasse 199 Top-Include 180 DELETE DATASET ABAP-Anweisung 848 DELETE dbtab ABAP-Anweisung 808 DELETE FROM Daten-Cluster 857 DELETE itab ABAP-Anweisung 362 DELETE_PERSISTENT Persistenzdienst 839 DEQUEUE Sperrfunktionsbaustein 819 Dereferenzierung Datenreferenzvariable 884 Dereferenzierungsoperator verwenden 273 DESCENDING SORT 363 DESCRIBE FIELD ABAP-Anweisung 894 DESCRIBE_BY_DATA RTTI 896 DESCRIBE_BY_DATA_REF RTTI 897 DESCRIBE_BY_NAME RTTI 897 Deserialisierung ST 1009 XML-ABAP 989 XSLT 1004 Design by Contract Assertion 558 DESTINATION CALL FUNCTION 926, 931 DESTINATION IN GROUP CALL FUNCTION 933 Destruktor ABAP Objects 237
358.book Page 1117 Monday, September 4, 2006 8:51 AM
Index
Dialogbox-Container CFW 644 Dialogfenster modal 570 Dialogmodul anlegen 591 Daten 248 Verarbeitungsblock 165, 177 Verwendung 592 Dialogprogrammierung klassiches ABAP 498 Dialogschnittstelle AS ABAP 156 Dialogschritt PAI/PBO 593 Dialogstatus GUI-Status 584 Dialogtransaktion anlegen 567 ausführen 498 Einstiegs-Dynpro 568 Selektionsbild 689 Transaktionscode 169 Verwendung 501 Dictionary-Typ anlegen 275 div arithmetischer Operator 311 DIVIDE ABAP-Anweisung 311 DML Data Manipulation Language 771 DO ABAP-Anweisung 327 Docking-Container Beispiel 659 CFW 644 Dokumentation Datenelement 279 DOM Document Object Model 995, 996 Domäne ABAP Dictionary 279 anlegen 79, 279 Datenelement 78 Domänenpflege ABAP Dictionary 80 DOM-Objekt iXML Library 1000
Doppelklick klassische Liste 711 Down Cast Datenreferenzvariable 891 Interface 446 Objektreferenzvariable 444 Vererbung 445 Dropdown Listbox 604 Druckliste ALV 725 klassische Liste 715 Drucklistenstufe Druckliste 716 Druckparameter Hintergrundverarbeitung 700 Spool-Auftrag 716 Drucktaste Bildschirmelement 575 Selektionsbild 686 Drucktastenleiste SAP GUI 562, 583 DTD Dokumenttypdefinitionen 995, 996 Dynamic Access Klassenkomponenten 874 Dynamische Dokumente CFW 654 dynamischer Typ Datenreferenzvariable 882 Objektreferenzvariable 437 Polymorphie 449 Referenzvariable 307 dynamisches Datenobjekt dynamisches Speicherobjekt 1060 Dynpro ABAP Objects 607 ABAP-Programm 565 anlegen 572 AS ABAP 156 Beispiel 609 Control 626 Dialogtransaktion 498 Dynamisches Programm 561 Dynpro-Folge 566 Eigenschaften 572 Eingabeüberprüfung 595 Feld 578 Funktionsgruppe 607
1117
358.book Page 1118 Monday, September 4, 2006 8:51 AM
Index
Nummer 572 Prozess 499 prüfen 578 testen 578 Typ 573 verlassen 571 Verwendung 157 Dynpro-Ablauflogik Anweisungen 577 implementieren 577 Table Control 630 Dynpro-Datentransport automatisch 593 steuern 593 Dynpro-Feld Datentransport 579 Datentyp 274, 580 Dynpro-Folge beenden 569 Dialogtransaktion 571 Dynpro-Prozess 499 schachteln 570 Dynpro-Nummer Selektionsbild 675 Dynpros Datenübergabe 566 Layout 574 Dynpro-Verarbeitung Nachricht 730
E E Nachrichtentyp 731 eCATT extended Computer Aided Test Tool 1075 Editor-Modus Class Builder 215 Ein-/Ausgabefeld Bildschirmelement 574 Ein-/Ausgabeparameter Formalparameter 375 Funktionsbaustein 510 Einfachvererbung Objektorientierung 371 Vererbung 390 Eingabedialog Web Dynpro ABAP 753
1118
Eingabeformat Dynpro 595 Eingabehilfe automatisch 600 definieren 603 Dynpro 600 Hierarchie 602 Selektionsbild 691 Web Dynpro ABAP 754 Eingabeparameter Formalparameter 374 Funktionsbaustein 510 Instanzkonstruktor 232, 407 Eingabeüberprüfung automatisch 595 definieren 597, 598 Nachricht 731 Selektionsbild 691 Eingebauter Typ Datenelement 78 eingebauter Typ ABAP Dictionary 276 ABAP-Programm 257 Einrückung Pretty Printer 91 Einstiegs-Dynpro Dynpro-Folge 567 Einzelschritt ABAP-Debugger 104 Element XML 991 elementar Datentyp 252 elementarer ABAP-Typ asXML 1004 JCo 954 RFC API 945 elementares Datenobjekt Initialwert 311 vergleichen 320 zuweisen 300 Elementartyp deklarieren 264 ELSE ABAP-Anweisung 325 ELSEIF ABAP-Anweisung 325 END OF TYPES/DATA 266
358.book Page 1119 Monday, September 4, 2006 8:51 AM
Index
ENDING AT CALL SCREEN 570 CALL SELECTION-SCREEN 688 END-OF-PAGE Listenereignis 706 END-OF-SELECTION Ereignis 494 ENQUEUE Sperrfunktionsbaustein 817 Enterprise Service Client-Proxy 986 Enterprise Services Repository Exchange Infrastructure 973 Enterprise SOA XML 989 Entkopplung Interface 435 Objektorientierung 414 Entwickler Berechtigung 57 Entwicklerschlüssel SAPNet 57 Entwicklungsklasse Paket 65 Entwicklungsobjekt ABAP Workbench 62 Entwicklungssystem CTS 65 Entwicklungsumgebung ABAP 26 EQ Vergleichsoperator 319 Ereignis ABAP Objects 28, 458 ABAP-Laufzeitumgebung 492 auslösen 463 deklarieren 461 Klasse 460 Objektorientierung 372 Vererbung 465 Verwaltung 468 Web Dynpro ABAP 756 Ereignisbehandler deklarieren 464 Methode 460 registrieren 468 Ereignisblock Daten 248 Funktionsgruppe 507
Verarbeitungsblock 165, 178 error_message klassische Ausnahme 732 Erweiterungsinfosystem Object Navigator 62 Erweiterungskategorie Datenbanktabelle 81 EVA Prinzip 494 EVENTS ABAP-Anweisung 461 EXCEPTIONS CALL FUNCTION 549 CALL METHOD 549 METHODS 548 EXCEPTION-TABLE CALL FUNCTION 910 CALL METHOD 907 EXCLUDING SET PF-STATUS 587 EXEC SQL ABAP-Anweisung 822 EXISTS WHERE-Klausel 797 EXIT ABAP-Anweisung 329 Exit-Meldung Nachrichtentyp 732 exp Gleitpunktfunktion 313 EXPORT ABAP-Anweisung 855 EXPORTING Aktualparameter 386 EVENTS 461 METHOD 210 METHODS 375 RAISE EVENT 463
F f ABAP-Typ 258, 260 Rechentyp 314 F1-Hilfe Dynpro 599 F4-Hilfe Dynpro 600
1119
358.book Page 1120 Monday, September 4, 2006 8:51 AM
Index
Factory-Methode Klasse 204, 226 Fallunterscheidung Kontrollstruktur 326 falsch logischer Ausdruck 318 Favoriten SAP Easy Access 61 Favoriten-Menü SAP Easy Access 58 Fehler Ausnahmesituation 524 vermeiden 523 Fehlermeldung Dynpro 611 Nachrichtentyp 731 Feld Datenbanktabelle 75 Feldbezeichner Datenelement 78, 279 Feldhilfe definieren 600 Dynpro 598, 599 Selektionsbild 691 Web Dynpro ABAP 754 Feldsymbol dynamische Programmierung 868 typisieren 871 Verwendung 869 Fenster SAP GUI 562 Festpunktarithmetik Programmeigenschaft 175 Festwert Eingabehilfe 601 Festwerte Domäne 85 FETCH NEXT CURSOR ABAP-Anweisung 802 FIELD Dynpro-Anweisung 593, 598 FIELD-SYMBOLS ABAP-Anweisung 871 Filterbedingung Query-Dienst 830 FINAL CLASS 403 METHODS 404
1120
FIND ABAP-Anweisung 333 Fixture ABAP Unit 1055 flach Datentyp 284 Struktur 285 flache Struktur zuweisen 304 floor numerische Funktion 313 Flugdatenmodell Dynpro 613 SAP 54 Folge-Dynpro aufrufen 568 Dynpro-Eigenschaft 573 Dynpro-Folge 566 FOR ALL ENTRIES SELECT 795 FOR EVENT METHODS 464 FORM ABAP-Anweisung 516 Formalparameter Operandenposition 381 optional 384 Parameterschnittstelle 374 typisieren 380 Verwendung 377 FORMAT ABAP-Anweisung 705 Formularfeld URL 965 frac numerische Funktion 313 Framework ABAP Objects 240 Fremdschlüssel Datenbanktabelle 86 Fremdschlüsselbeziehung Datenbanktabelle 770 Freund Klasse 205 Freundschaft Klasse 205 FRIENDS CLASS 205
358.book Page 1121 Monday, September 4, 2006 8:51 AM
Index
FROM-Klausel SELECT 778 FUNCTION ABAP-Anweisung 512 Function Builder Werkzeug 112, 503, 509 FUNCTION KEY SELECTION-SCREEN 694 FUNCTION-POOL ABAP-Anweisung 172, 508 Function-Pool Programmtyp 171 Funktion eingebaut 312 funktionale Methode aufrufen 386 definieren 375 Operandenposition 387 Funktionsbaustein anlegen 112, 508 freigeben 514 implementieren 113 Prozedur 177, 503 Quelltext 511 testen 115, 513 Funktionsbausteinaufruf dynamisch 910 Funktionscode auswerten 588 Exit-Kommando 596, 597 klassische Liste 712 Menu Painter 584 SAP GUI 582 Selektionsbild 693 Verwendung 584 Funktionsgruppe ABAP-Programm 503 anlegen 108, 505 einleiten 108 globale Daten 504 Include-Programme 506 Namenskonvention 506 Programmtyp 171 Verwendung 504 Funktionstastenbelegung GUI-Status 566 Menu Painter 584
G ganze Zahl Datenobjekt 258, 259 Garbage Collector ABAP-Laufzeitumgebung 229 GE Vergleichsoperator 319 Gebiet anlegen 475 Eigenschaften 475 Gebietshandle anbinden 479 Shared Objects 473 Gebietsinstanzen Shared Objects 472 Gebietsinstanzversion Shared Objects 472 Gebietsklasse Shared Objects 473 Gebietswurzelklasse Shared Objects 473 Generalisierung Vererbung 391 GENERATE SUBROUTINE POOL ABAP-Anweisung 912 generisch Datentyp 286 generische Typisierung Verwendung 383 generischer Datentyp ABAP-Typenhierarchie 250 gepackte Zahl Datenobjekt 258, 259 geschützt Sichtbarkeitsbereich 201 Vererbung 395 geschützt instanzierbar Oberklasse 412 geschützter Bereich TRY-Block 529 GET Ereignis 493 GET DATASET ABAP-Anweisung 848 GET REFERENCE ABAP-Anweisung 883
1121
358.book Page 1122 Monday, September 4, 2006 8:51 AM
Index
GET RUN TIME ABAP-Anweisung 792 GET TIME STAMP ABAP-Anweisung 318 GET/SET-Methoden persistente Klasse 828 GET_PERSISTENT Persistenzdienst 834 GET_PERSISTENT_BY_QUERY Query-Dienst 829 GET_PRINT_PARAMETERS Druckparameter 716 Gleitpunktfunktion Funktion 313 Gleitpunktzahl Datenobjekt 258, 260 goldene Regel Datenreferenzvariable 882 Objektreferenzvariable 438 Überprüfung 440 GROUP BY-Klausel SELECT 798 Grundliste anzeigen 708 klassische Liste 706 Gruppenstufenverarbeitung interne Tabelle 361 Gruppenstufenwechsel Kontrollstruktur 361 GT Vergleichsoperator 319 GUI Graphical User Interface 559 GUI Control Beispiel 656 Dynpro 641 Ereignis 650 Lebensdauer 652 Methode 649 SAP GUI 640 Verarbeitung 649 Verschalung 654 GUI_DOWNLOAD Datei schreiben 851 GUI_UPLOAD Datei lesen 851 GUID Objektidentität 840
1122
GUI-Status ABAP-Programm 566 Beispiel 615 Funktionen 584 klassische Liste 712 prüfen 586 Selektionsbild 693 setzen 587 Vorlage abgleichen 586 GUI-Titel anlegen 587
H HANDLE ASSIGN 881 CREATE DATA 887 HASHED TABLE TYPES/DATA 270, 348 hashed table generischer Typ 288 Hash-Tabelle Tabellenart 348 Verwendung 349 Hauptmodus Benutzersitzung 188 HAVING-Klausel SELECT 799 Header tiefes Datenobjekt 1061 Hello World ABAP-Programm 93 Hintergrundaufgabe Hintergrundauftrag 701 Hintergrundauftrag einplanen 492 Hintergrundverarbeitung ausführbares Programm 491, 700 einplanen 704 tRFC 938 Hostvariable Native SQL 823 HTML Oberfläche 733 HTML GUI SAP GUI 562 HTTP(S) Protokoll 957
358.book Page 1123 Monday, September 4, 2006 8:51 AM
Index
HTTP-Body Zugriff 962 HTTP-Client ICF 968 HTTP-Header Zugriff 961 HTTP-Kommunikation AS ABAP 956 HTTP-Request senden 970 HTTP-Request-Handler anlegen 959 ICF 959 implementieren 961 registrieren 960 HTTP-Server ICF 959 HTTP-Service anlegen 960 testen 961
I I Nachrichtentyp 730 i ABAP-Typ 258, 259 Rechentyp 314 ICF AS ABAP 957 Internet Communication Framework 957 Methoden 964 Webservice 978 ICF-Client Programmierung 966 ICF-Server Programmierung 958 ICM AS ABAP 957 Internet Communication Manager 160, 957 ID XSLT-Programm 1004 IF ABAP-Anweisung 325 Kontrollstruktur 325 IF_HTTP_CLIENT ICF 966
IF_HTTP_ENTITY ICF 961 IF_HTTP_EXTENSION ICF 959 IF_HTTP_HEADER_FIELDS ICF 962 IF_HTTP_HEADER_FIELDS_SAP ICF 962 IF_HTTP_RESPONSE ICF 962, 970 IF_OS_TRANSACTION Transaktionsdienst 841 IF_SERIALIZABLE_OBJECT Interface 447 Tag-Interface 1008 IF_T100_MESSAGE Nachrichten-Interface 542, 544, 729 IMPLEMENTATION CLASS 199 Implementierung Methode 211 Implementierungsteil ABAP-Programm 92, 164 Klasse 199 IMPORT ABAP-Anweisung 857 IMPORTING Aktualparameter 386 METHOD 210 METHODS 374 IN BYTE MODE Bytekettenverarbeitung 331 IN CHARACTER MODE Zeichenkettenverarbeitung 331 IN PROGRAM PERFORM 518 IN seltab Logischer Ausdruck 684 Prädikat 323 WHERE-Klausel 787 Inbound-Plug Web Dynpro ABAP 761 INCLUDE ABAP-Anweisung 180 INCLUDE STRUCTURE ABAP-Anweisung 268 INCLUDE TYPE ABAP-Anweisung 268
1123
358.book Page 1124 Monday, September 4, 2006 8:51 AM
Index
Include-Programm ABAP-Programm 180 Verwendung 181 INDEX INSERT 355 READ TABLE 357 INDEX TABLE generische Tabellenart 352 index table generischer Typ 288 Indexsuche ABAP-Schlüsselwortdokumentation 148 Indexzugriff interne Tabelle 348 INDX-artig Datenbanktabelle 856 Informationsnachricht Nachrichtentyp 730 INHERITING FROM CLASS 391 INITIAL SIZE TYPES/DATA 353 Initialisierung Objekt 231 INITIALIZATION Ereignis 493 Initialwert Datenobjekt 311 INNER JOIN SELECT 795 INPUT MODULE 591 Input-Stream-Objekt iXML Library 1000 INSERT dbtab ABAP-Anweisung 805 INSERT itab ABAP-Anweisung 355 INSERT REPORT ABAP-Anweisung 915 Inspektion Code Inspector 1034 Instanz ABAP Objects 194 Datenobjekt 250 Instanzattribut anlegen 129, 208 Instanzierbarkeit Klasse 204
1124
Vererbung 412 Instanzierung ABAP Objects 27 ABAP-Programm 502 Instanzkomponente Klasse 206 Instanzkonstruktor 3-Phasen-Modell 408 Ausnahme 131 implementieren 126, 131 Klasse 232 Schnittstelle 131 Vererbung 406 Instanzmethode anlegen 210 Integer Datenobjekt 258 Integration Broker Webservice 977 INTERFACE ABAP-Anweisung 416 Interface ABAP Objects 28, 413 anlegen 416 implementieren 418, 429 Objektorientierung 371 Polymorphie 449 Vererbung 434 Verwendersicht 424 Verwendung 414, 430 zusammensetzen 427 Interfacekomponente Interface 417 statisch 427 Interfacekomponentenselektor Interface 419 Interfacemethode implementieren 420 INTERFACE-POOL ABAP-Anweisung 171 Interface-Pool Programmtyp 171 Interfacereferenzvariable ABAP Objects 415, 423 INTERFACES ABAP-Anweisung 419, 427 Interface-View Web-Dynpro-Window 740
358.book Page 1125 Monday, September 4, 2006 8:51 AM
Index
interne Tabelle ABAP Dictionary 281 ändern 361 anhängen 357 asXML 1007 Datenobjekt 101 deklarieren 270 Eigenschaften 346 einfügen 355 generisch 352 Gruppenstufenverarbeitung 361 Initialwert 311 JCo 955 Kurzform 352 Laufzeitmessung 350 lesen 357 löschen 362 RFC API 945 Schleife 359 sortieren 363 übergeben 365 verdichtet einfügen 356 vergleichen 322, 365 verwenden 345 Zugriff 354 zuweisen 306, 364 interner Modus Hauptmodus 188 Speichergrenze 189 stapeln 188 Internet AS ABAP 160 Verbindung 957 Internet Communication Framework ICF 957 Internet Communication Manager AS ABAP 160 ICM 957 INTO LOOP 360 READ TABLE 358 INTO-Klausel SELECT 780 IS ASSIGNED logischer Ausdruck 878 Prädikat 323 IS BOUND logischer Ausdruck 890 Prädikat 323
IS INITIAL Prädikat 323 IS NULL WHERE-Klausel 787 IS SUPPLIED Prädikat 323, 384 iXML Library Bibliothek 995 parsen 997
J J2EE AS Java 153 Technologie 31 J2EE-Connector SAP JRA 929 Java AS Java 153 Programmiersprache 31 Java GUI SAP GUI 562 JavaScript Engine AS ABAP 158 JCo Connection Pool 950 direkte Verbindung 949 herunterladen 948 JCo-Klasse 949 Parameterübergabe 954 SAP Java Connector 948 JCO.addClientPool JCo 951 JCO.Attributes JCo-Klasse 949 JCO.Client JCo-Klasse 949 JCO.connect JCo 950 JCO.createClient JCo 949 JCO.disconnect JCo 950 JCO.Function JCo 953 JCO.getClient JCo 952 JCO.ParameterList JCo 954
1125
358.book Page 1126 Monday, September 4, 2006 8:51 AM
Index
JCO.Pool JCo-Klasse 951 JCO.PoolManager JCo-Klasse 951 JCO.releaseClient JCo 952 JCO.Repository JCo 953 JCO.Server JCo 956 JCO.Structure JCo 954 JCO.Table JCo 955 Job Hintergrundauftrag 701 JOB_CLOSE Hintergrundverarbeitung 701 JOB_OPEN Hintergrundverarbeitung 701 Jobübersicht Hintergrundverarbeitung 702 JOIN SELECT 793 Join FROM-Klausel 793 verknüpfen 794
K Kapselung Klasse 202 klassisches ABAP 502 Objektorientierung 193 Prozedur 203 Verwendung 242 Kernel AS ABAP 157 Kettensatz 100 ABAP-Syntax 100 Klammerung logischer Ausdruck 324 Rechenausdruck 311 Klasse ABAP Objects 194 abstrakt 400 anlegen 120, 198 Eigenschaft 204 final 403
1126
global 197 konkret 400 lokal 197 Objektorientierung 370 Objekttyp 196 testen 134 Klassenakteur anlegen 828 Object Services 826 Klassenkomponentenselektor ABAP-Syntax 214 Vererbung 404 Klassenkonstruktor anlegen 121 Klassenreferenzvariable ABAP Objects 422 klassische Ausnahme Funktionsbaustein 511 klassische Liste ausführbares Programm 707 Dynpro-Folge 709 Ereignis 711 erstellen 705 Formatierung 705 Kapselung 719 Transaktion 708 Verarbeitung 709 klassisches ABAP Verwendung 501 Klausel dynamisch angeben 904 Open SQL 777 Knowledge Warehouse verwenden 148 Kommentar 90 Kommentarzeile ABAP-Programm 90 Kommunikation asynchron 919 synchron 919 Kommunikationsszenarien RFC 926 Kommunikationstechnik AS ABAP 917 kompatibel Datenobjekt 298 Kompatibilitätsmodus Transaktionsdienst 844
358.book Page 1127 Monday, September 4, 2006 8:51 AM
Index
Kompilationseinheit ABAP-Programm 163 komplex Datentyp 252 Komponente Struktur 266 Komponentenangabe dynamisch 904 Komponenteninterface Interface 428 konkret Unterklasse 400 Konsolidierungssystem CTS 65 Konstante Datenobjekt 289 Klasse 209 Konstruktor anlegen 121 Klasse 231 Vererbung 406 Kontextmenü definieren 589 SAP GUI 589 Kontrollstruktur Verarbeitungsblock 324 konvertibel Datenobjekt 298 Konvertierung byteartiger Typ 301 Datum und Zeit 301 numerischer Typ 301 textartiger Typ 300 Zuweisung 299 Konvertierungsfehler Typkonvertierung 303 Konvertierungsregel elementarer Datentyp 300 interne Tabelle 306 Struktur 305 Typkonvertierung 299 Vergleich 320 Konvertierungsroutine ABAP Dictionary 310 Kopplung Vererbung 434 Korrektur- und Transportwesen CTS 65
Kundensystem Namensraum 66 Kurzdump Laufzeitfehler 527, 555 Kurzreferenz ABAP-Schlüsselwortdokumentation 147 Kurztext Nachricht 728
L Langtext Nachricht 728 Laufzeitanalyse aufrufen 1069 Laufzeitfehler abfangbar 546 Ausnahme 527 nicht-abfangbar 555 LDB_PROCESS Funktionsbaustein 495 LE Vergleichsoperator 319 LEAVE SCREEN ABAP-Anweisung 571 LEAVE TO LIST-PROCESSING ABAP-Anweisung 708 LEAVE TO SCREEN ABAP-Anweisung 571 LEAVE TO TRANSACTION ABAP-Anweisung 568 LEAVE TO TRANSACTION ABAP-Anweisung 170 Leerzeichen schließend 294, 331 LEFT OUTER JOIN SELECT 795 LENGTH TYPES 253 TYPES/DATA 264 Lesesperre Shared Objects 478 LIKE TYPES/DATA 253 WHERE-Klausel 788 LINE OFF TYPES/DATA 356 lines Beschreibungsfunktion 313
1127
358.book Page 1128 Monday, September 4, 2006 8:51 AM
Index
LINES OF APPEND 357 INSERT itab 356 Linie klassische Liste 706 Selektionsbild 685 Liste ABAP Objects 719 ALV-Liste 720 ausführbares Programm 494 klassisch 704 Listenausgabe erstellen 94 Listen-Cursor klassische Liste 705 Listen-Dynpro klassische Liste 706 Listenereignis behandeln 712 Ereignisblock 179, 180 Listenprozessor aufrufen 708 klassische Liste 706 Listenpuffer klassische Liste 706 Listenstufe klassische Liste 706 Literal Datenobjekt 292 literales XML-Element Simple Transformation 1011 LOAD-OF-PROGRAM ABAP-Anweisung 178 Ereignis 493, 498 LOCAL FRIENDS CLASS 239 Locale Textumgebung 162 log Gleitpunktfunktion 313 log10 Gleitpunktfunktion 313 Logical Database Builder Werkzeug 495 logische Datenbank Programmeigenschaft 176 Selektionsbild 673 Verwendung 495
1128
logischer Ausdruck ABAP-Syntax 318 IF/ELSEIF 325 WHERE 360 WHERE-Klausel 786 logischer Port Client-Proxy 986 LOG-POINT ABAP-Anweisung 558 lokale Klasse anlegen 135 Class-Pool 239 Definition 137 Funktionsgruppe 507 Implementierung 138 lokaler Typ Class-Pool 238 lokales Objekt Repository Browser 64 LOOP ABAP-Anweisung 359 LOOP AT SCREEN ABAP-Anweisung 576 LOOP WITH CONTROL Dynpro-Anweisung 631, 634 LOWER CASE PARAMETERS 676 LT Vergleichsoperator 319 LUW Datenbank 809 Logical Unit of Work 809
M Makro Verwendung 184 Mandant AS ABAP 820 SAP-System 76 Mandantenbehandlung Open SQL 820 Mandantenfeld Datenbanktabelle 75 Mandantenkennung SAP-System 76 Mandantenspalte Datenbanktabelle 819
358.book Page 1129 Monday, September 4, 2006 8:51 AM
Index
Mapping objektrelational 826 mathematische Funktion Funktion 313 Maus Doppelklick 585 MAX Aggregatfunktion 780 me Datenobjekt 295 Selbstreferenz 133, 221 Mehrfachinstanzierung Klasse 224 Mehrfachselektion Selektionskriterium 684 Mehrfachvererbung ABAP Objects 414 Objektorientierung 372 Memory Inspector aufrufen 1065 Werkzeug 1059 Menu Painter Werkzeug 584 Menüleiste SAP GUI 562, 583 MESSAGE ABAP-Anweisung 728 Message-Server AS ABAP 185 Messdatendatei Laufzeitanalyse 1071 Metadaten XML 991 meth( ) Methodenaufruf 385 METHOD ABAP-Anweisung 211 Methode abstrakt 401 anlegen 210 aufrufen 138, 385 deklarieren 121 final 404 funktional 375 implementieren 125 konkret 401 Objektorientierung 192, 370 Parameterschnittstelle 373 Polymorphie 449
Prozedur 176 Quelltext 126 redefinieren 396 Unterklasse 396 Methodenaufruf dynamisch 907 funktional 386 statisch 385 METHODS ABAP-Anweisung 210 Microsoft Windows SAP GUI 562 Mietwagenanwendung Beispiel 56 MIME Repository Object Navigator 662 MIN Aggregatfunktion 780 mod arithmetischer Operator 311 Model MVC 734, 745 Modellierung Objektorientierung 242 MODIFY dbtab ABAP-Anweisung 807 MODIFY itab ABAP-Anweisung 361 MODIFY SCREEN ABAP-Anweisung 576 Modularisierung interne 519 prozedural 502 MODULE ABAP-Anweisung 591 Dynpro-Anweisung 592 Modul-Pool Dialogprogrammierung 498 Programmtyp 173 Verwendung 501 Modultest ABAP Unit 1048 auswerten 1057 Definition 1048 MOVE ABAP-Anweisung 297 MOVE ?TO ABAP-Anweisung 444, 891
1129
358.book Page 1130 Monday, September 4, 2006 8:51 AM
Index
MOVE-CORRESPONDING ABAP-Anweisung 308 MULTIPLY ABAP-Anweisung 311 Mussfeld Dynpro 595 Selektionsbild 676 MVC Model View Controller 155, 561, 734 mySAP Business Suite Produktfamilie 151
N n ABAP-Typ 258, 261 NA Vergleichsoperator 322, 343 Nachricht anlegen 727 Ausnahmebehandlung 550 Dialogverarbeitung 730 SAP GUI 727 senden 728 Verwendung 732 Nachrichtenausgabe erstellen 96 Nachrichtenklasse Nachricht 728 Nachrichtennummer Nachricht 728 Nachrichtenpflege Werkzeug 727 Nachrichtentyp Nachricht 730 Namenskonvention Klasse 200 Kundensystem 66 Namensraum asXML 1005 Datenobjekt 248 Datentyp 255 Klasse 206 Simple Transformation 1011 Vererbung 395 XML 994 Native SQL AS ABAP 822
1130
Native-SQL-Schnittstelle AS ABAP 160 Navigationslink Web Dynpro ABAP 762 NE Vergleichsoperator 319 nicht-klassenbasierte Ausnahme definieren 548 NO INTERVALS SELECT-OPTIONS 681 NO-EXTENSION SELECT-OPTIONS 681 NOT boolescher Operator 323 WHERE-Klausel 786 NP Vergleichsoperator 322, 343 NS Vergleichsoperator 322, 343 numeric generischer Typ 288 numerisch Datentyp 259 numerische Funktion Funktion 313 numerisches Textfeld Datenobjekt 258, 261
O O/R-Mapping objektrelationales Mapping 826 OASIS Organization for the Advancement of Structured Information Systems 974 Oberklasse privat 413 Vererbung 389 object generischer Typ 443 Wurzelklasse 390 Object Navigator ABAP Workbench 60 Object Services Datenbankzugriff 825 Objekt ABAP Objects 194 asXML 1008 dynamisches Speicherobjekt 1060
358.book Page 1131 Monday, September 4, 2006 8:51 AM
Index
erzeugen 138 Objektorientierung 369 reale Welt 191 Software 192 Objektidentität Object Services 826 Objektkomponentenselektor ABAP-Syntax 220 verwenden 272 Objektliste Repository Browser 63 Objektlistentyp Repository Browser 63 Objektmenge Code Inspector 1033 objektorientierter Transaktionsmodus Transaktionsdienst 844 Objektorientierung Programmierung 191 Objektreferenz ABAP Objects 436 interne Tabelle 225 persistent 840 Speicheradresse 218 Objektreferenzvariable deklarieren 272 goldene Regel 438 Verwendersicht 438 Objektreferenzvariablen anlegen 219 Objekttyp ABAP-Typenhierarchie 250 OBLIGATORY PARAMETERS 676 obsoletes Sprachelement ABAP 37 öffentlich Sichtbarkeitsbereich 201 Vererbung 395 öffentlich instanzierbar Oberklasse 412 Offset-/Längenangabe Teilfeldzugriff 341 OK-Feld Dynpro-Feld 581, 582 Verwendung 588 OLTP Online Transaction Processing 106
ON JOIN 794 ON CHAIN-INPUT MODULE 595 ON CHAIN-REQUEST MODULE 595 ON COMMIT PERFORM 814 ON INPUT MODULE 594 ON para|selcrit AT SELECTION-SCREEN 690 ON REQUEST MODULE 594 ON ROLLBACK PERFORM 814 OOA Objektorientierte Analyse 194 OOD Objektorientiertes Design 194 OO-Transaktion anlegen 140 Dynpro 612 Transaktionscode 169 OPEN CURSOR ABAP-Anweisung 802 OPEN DATASET ABAP-Anweisung 846 Open SQL ABAP-Anweisungen 775 dynamisch 904 Performance 775 verwenden 102 Open-SQL-Schnittstelle AS ABAP 159 Operand ABAP-Anweisung 90 arithmetischer Ausdruck 312 dynamisch angeben 904 logischer Ausdruck 319 Operandenposition ABAP-Anweisung 246 Operator ABAP-Anweisung 90 arithmetischer Ausdruck 311 OPTIONAL METHODS 384
1131
358.book Page 1132 Monday, September 4, 2006 8:51 AM
Index
OR boolescher Operator 323 WHERE-Klausel 786 ORDER BY-Klausel SELECT 800 OTR Online Text Repository 542 Outbound-Plug Web Dynpro ABAP 760 OUTPUT MODULE 591 OVERLAY ABAP-Anweisung 332
P p ABAP-Typ 258, 259 Rechentyp 314 Package Builder Werkzeug 70 PACKAGE SIZE INTO-Klausel 783 PAI Dynpro-Ereignis 499 Ereignis 587 PROCESS AFTER INPUT 564 Selektionsbild 689 PAI-Modul Funktionsgruppe 507 Paket ABAP Workbench 63 Paketeigenschaft Paket 67 Paketprüfung Paket 70 Paketschnittstelle Paket 70 Überprüfung 65 Pakettyp Paket 67 Parallelverarbeitung aRFC 933 Parameter Selektionsbild 675 PARAMETERS ABAP-Anweisung 675 Parameterschnittstelle ausführbares Programm 700
1132
Ausnahme 536 Ereignis 461 Funktionsbaustein 509 Methode 210, 212 Unterprogramm 517 PARAMETER-TABLE CALL FUNCTION 910 CALL METHOD 907 Parametertransaktion Dialogtransaktion 498 Parameterübergabe Performance 378 Patterns Objektorientierung 194 PBO Dynpro-Ereignis 499 PROCESS BEFORE OUTPUT 564 Selektionsbild 689 PBO-Modul Funktionsgruppe 507 PERFORM ABAP-Anweisung 518 persistente Klasse anlegen 826 Object Services 826 persistentes Objekt ändern 838 erzeugen 835 löschen 839 SAP LUW 839 Persistenzabbildung Werkzeug 827 Persistenzdienst Object Services 826 Persistenzschicht AS ABAP 159 Picture Control Beispiel 661 CFW 646 Verschalung 656, 668 Plug Web Dynpro ABAP 760 POH PROCESS ON HELP-REQUEST 564 Polymorphie ABAP Objects 448 Beispiel 453 Nutzen 453, 458 Objektorientierung 193
358.book Page 1133 Monday, September 4, 2006 8:51 AM
Index
semantische Regeln 452 Verwendung 452 Pop-up-Level Container-Control 648 POSITION ABAP-Anweisung 705 POSIX-Standard regulärer Ausdruck 335 POV PROCESS ON VALUE-REQUEST 564 Prädikat logischer Ausdruck 322 WHERE-Klausel 787 Präsentationslogik Verschalung 107 Präsentationsschicht AS ABAP 155 Präsentationsserver SAP GUI 562 Pretty Printer ABAP Editor 90 Primärindex Datenbanktabelle 788 Primärschlüssel Datenbanktabelle 770 PRIMARY KEY ORDER BY-Klausel 801 privat Sichtbarkeitsbereich 201 Vererbung 395 privat instanzierbar Oberklasse 412 PROCESS AFTER INPUT Dynpro-Ereignis 499, 564 Ereignisblock 577 PROCESS BEFORE OUTPUT Dynpro-Ereignis 499, 564 Ereignisblock 577 PROCESS ON HELP-REQUEST Dynpro-Ereignis 564 Dynpro-Ereignisblock 599 PROCESS ON VALUE-REQUEST Dynpro-Ereignis 564 Dynpro-Ereignisblock 603 Produktivsystem CTS 65 Produktivteil ABAP-Programm 1053
PROGRAM ABAP-Anweisung 172, 173 Programmaufruf dynamisch 904 Programmeigenschaften festlegen 87 Programmeinleitung ABAP-Programm 91, 92 Programmgenerierung persistent 915 transient 912 Verwendung 911 Programmgruppe interner Modus 518 Programmiermodell objektorientiert 26 prozedural 26 Programmierrichtlinien ABAP 49 Programmiersprachen AS ABAP 157 Programmierung defensiv 242, 523 robust 523 Programmkonstruktor Ereignisblock 178 Programmprüfung erweitert 1027 Programmtyp ABAP-Programm 170 Empfehlung 174 Protokoll 922 Assertion 557 Proxy Webservice 977 Proxy-Objekt CFW 642 Prozedur klassisch 503 Verarbeitungsblock 164, 176 Prozeduraufruf dynamisch 906 Prozess ABAP-Laufzeitumgebung 162 Laufzeitumgebung 491 Prozessor ABAP-Laufzeitumgebung 162 Prüfkennzeichen Berechtigungsprüfung 862
1133
358.book Page 1134 Monday, September 4, 2006 8:51 AM
Index
Prüftabelle Dynpro 596 Eingabehilfe 601 Fremdschlüssel 87 Prüfvariante Code Inspector 1032 Pseudokommentar erweiterte Programmprüfung 1030 Publish-and-Subscribe Ereignis 460
Q qRFC API 940 ausführen 939 queued RFC 924 RFC API 947 Szenarien 925 qRFC-Manager qRFC 940 Qualitätsmanagement Code Inspector 1035 Quelltext Organisation 180 Query-Dienst Object Services 829 Query-Manager Object Services 829
R R/2 System 23 R/3 Produktfamilie 151 System 24, 151 RADIOBUTTON GROUP PARAMETERS 676 Rahmen Bildschirmelement 574 klassische Liste 706 Rahmenprogramm Funktionsgruppe 114, 506 RAISE EVENT ABAP-Anweisung 463 RAISE exc ABAP-Anweisung 549
1134
RAISE EXCEPTION ABAP-Anweisung 528 RAISING FORM 516 MESSAGE 550 METHODS 210, 536 RANGE ASSIGN 878 RANGE OF DATA 685 READ DATASET ABAP-Anweisung 847 READ REPORT ABAP-Anweisung 912 READ TABLE ABAP-Anweisung 357 READ-ONLY DATA 208, 265 RECEIVE RESULTS ABAP-Anweisung 933 RECEIVING Aktualparameter 387 Rechenausdruck ABAP-Syntax 311 Rechentyp Rechenausdruck 314 Rechenzeit analysieren 1068 REDEFINITION METHODS 397 REF TO DATA 219 TYPES/DATA 272, 423, 436, 882 REFERENCE METHODS 376 REFERENCE INTO LOOP 360 READ TABLE 358 Referenz Datentyp 252 XML 1008 Referenzsemantik Datenreferenz 868 dynamisches Speicherobjekt 1062 Zuweisung 285 Referenztyp ABAP Dictionary 280 deklarieren 272
358.book Page 1135 Monday, September 4, 2006 8:51 AM
Index
Referenzübergabe Formalparameter 376 Referenzvariable deklarieren 272 Initialwert 311 vergleichen 321 verwenden 125, 272 zuweisen 222, 307, 439 REGEX FIND 337 REPLACE 338 Registerkarte Dynpro 634 Registrierung Ereignis 460 regulärer Ausdruck Klasse 339 Sonderzeichen 336 suchen/ersetzen 335 Remote Function Call AS ABAP 160 RFC 921 remotefähiger Funktionsbaustein RFC 931 RFM 931 REPLACE ABAP-Anweisung 333 REPORT ABAP-Anweisung 172 Report anlegen 144 Reporting interaktiv 712 klassisches ABAP 491 programmieren 143 Prozess 494 Reporting-Ereignis Ereignisblock 179 Reporttransaktion ausführbares Programm 689 Repository Entwicklungsobjekte 62 Repository Browser Object Navigator 62 Repository-Infosystem Object Navigator 62 Repository-Objekt ABAP Workbench 62
RETURN ABAP-Anweisung 167, 329 RETURNING METHOD 210 METHODS 375 RFC 926 API 940 asynchron 922 Debugging 932 Kommunikationsszenarien 926 objektorientierte Steuerung 940 Programmierung 930 queued 924 Remote Function Call 921 synchron 922 transaktional 923 RFC API C-Routinen 940 RFC SDK herunterladen 941 Software Development Kit 927 RfcAccept RFC API 943 RFC-Bibliothek RFC API 941 RfcCall RFC API 943 RFC-Client Fremdsystem 942 JCo 948 RfcClose RFC API 943 RfcCreateTransID RFC API 946 RFC-Destination angeben 926, 931 Fremdsystem 944 HTTP-Verbindung 969 verwalten 926 RfcDispatch RFC API 943 RfcGetData RFC API 943 RfcGetName RFC API 943 RfcIndirectCallEx RFC API 946 RfcInstallFunction RFC API 943
1135
358.book Page 1136 Monday, September 4, 2006 8:51 AM
Index
RfcInstallTransactionControl RFC API 946 RfcLibrary externe RFC-Schnittstelle 940 RfcOpen RFC API 942 RfcReceive RFC API 943 RFC-Schnittstelle AS ABAP 921 extern 927 RfcSendData RFC API 943 RFC-Server Fremdsystem 943 JCo 956 Parameterübergabe 944 RFM JCo-Aufruf 955 Rollback Datenbank 810 ROLLBACK WORK ABAP-Anweisung 814 Persistenzdienst 839 Rollbereich interner Modus 188 RTTC Run Time Type Creation 893 RTTI Run Time Type Information 893 RTTS ASSIGN 881 CREATE DATA 887 Run Time Type Services 893 Rückgabewert Formalparameter 375 Run Time Type Creation RTTC 898 Run Time Type Information RTTI 894 Run Time Type Services RTTS 893
S S Nachrichtentyp 731 S_MEMORY_INSPECTOR Transaktion 1065
1136
SAAB Transaktion 557, 1043 SAP Change and Transport System Paketeigenschaft 65 SAP Easy Access Einstiegsprogramm 57 SAP Gateway JCo 956 RFC-Server 944 SAP GUI AS ABAP 156 SAP Graphical User Interface 562 SAP Help Portal verwenden 148 SAP JCo Java Connector 928 SAP JRA Java Resource Adapter 929 SAP List Viewer ALV 647 verwenden 144 SAP LUW AS ABAP 812 tRFC 937 SAP Memory Benutzersitzung 187 SAP NetWeaver Technologie-Plattform 24, 31, 151 SAP NetWeaver 2004s ABAP Trial Version 55, 1100 SAP NetWeaver Exchange Infrastructure XML 989 SAP-Basis R/3 151 sapitab.h RFC API 941 SAP-Menü SAP Easy Access 57 SAP-Pufferung Datenbanktabelle 821 saprfc.h RFC API 940 SAP-Sperre SAP LUW 816 SAP-Spool-System ABAP Objects 725 Druckliste 715 Schaltfläche Web Dynpro ABAP 755
358.book Page 1137 Monday, September 4, 2006 8:51 AM
Index
Schleife bedingt 328 durchführen 138 interne Tabelle 360 Kontrollstruktur 327 unbedingt 327 Schlüsselattribut persistente Klasse 828 Schlüsselwort ABAP-Anweisung 90 Schlüsselzugriff interne Tabelle 349 Schnittstelle Klasse 202, 414 Vererbung 439 Schnittstellen-Arbeitsbereich ABAP/Dynpro 580 Schnittstellenparameter anlegen 122 Parameterart 374 Parameterschnittstelle 374 Übergabeart 376 Schreibsperre Shared Objects 478 SCI Transaktion 1030 SCOV Transaktion 1074 Screen Painter Elementliste 576, 581, 582 Layout Editor 574 Quelltext-Editor 563 Werkzeug 572 SE30 Transaktion 1069 SE38 Transaktion 59 SE80 Transaktion 61 Sekundärindex Datenbanktabelle 788 Selbstreferenz Instanzkonstruktor 409 SELECT ABAP-Anweisung 777 Schleife 782 Zuweisungsregeln 786 SELECTION-SCREEN BEGIN OF SCREEN ABAP-Anweisung 674
SELECT-Klausel SELECT 778 SELECT-OPTIONS ABAP-Anweisung 680 SELECT-Schleife geschachtelt 791 verwenden 127 Selektionsbild anlegen 110, 674 aufrufen 688 Data Browser 105 Dynpro 672 Ereignis 689 GUI-Status 693 Prozessor 689 Verarbeitung 112, 689 verlassen 693 Verwendung 674 Selektionsbildereignis Ereignisblock 179 Selektionsbildverarbeitung dunkel 700 Selektionskriterium Selektionsbild 679 Selektionstabelle Selektionskriterium 681 WHERE-Klausel 790 Selektionstext anlegen 111 Selektionsbild 676 sender Ereignisparameter 462, 466 Separation of Concerns Dynpro 609 klassische Liste 711, 719 Konzept 560 Selektionsbild 674 Webservice 965 Serialisierung ABAP-XML 989 ST 1009 XSLT 1003 Service webbasiert 957 Service Definition Wizard Webservice 978 Service Wizard ICF 960
1137
358.book Page 1138 Monday, September 4, 2006 8:51 AM
Index
Services Verwendung 31 Session Breakpoint ABAP Debugger 1043 SET DATASET ABAP-Anweisung 848 SET EXTENDED CHECK ABAP-Anweisung 1029 SET HANDLER ABAP-Anweisung 468 SET PF-STATUS ABAP-Anweisung 587 SET SCREEN ABAP-Anweisung 569 SET TITLEBAR ABAP-Anweisung 587 SET-Methode Klasse 202 Shared Memory Applikationsserver 187, 471 SHARED MEMORY ENABLED CLASS 473 Shared Objects AS ABAP 470 erzeugen 481 Objektorientierung 372 Objektreferenz 474 Verwendung 479, 481 Zugriff 473 Shared Objects Memory Shared Memory 472 Verwaltung 472 Shared-Memory-fähig Klasse 473 Sharing dynamisches Datenobjekt 1061 interne Tabelle 307 SHIFT ABAP-Anweisung 332 SICF Transaktion 960 Sichtbarkeitsbereich Klasse 201 Vererbung 394 sign numerische Funktion 313 simple generischer Typ 288
1138
Simple Transformation AS ABAP 1011 aufrufen 1012 Performance 1011 ST 1009 Symmetrie 1010 symmetrisch/asymmetrisch 1018 Verwendung 964 sin Gleitpunktfunktion 313 SINGLE SELECT-Klausel 778 Singleton Muster 207 Prinzip 235 verwenden 126 sinh Gleitpunktfunktion 313 SKIP ABAP-Anweisung 705 SLIN Transaktion 1027 SM59 Transaktion 926 SOAP Simple Object Access Protocol 973 SOAP Runtime Web Service Framework 978 Softwarekomponente Paket 67 Softwarelogistik ABAP 39 AS ABAP 63 CTS 71 SOME WHERE-Klausel 798 SORT ABAP-Anweisung 363 SORTED TABLE TYPES/DATA 270, 348 sorted table generischer Typ 288 sortierte Tabelle Tabellenart 348 Verwendung 349 SPA/GPA-Parameter SAP Memory 187 space Datenobjekt 295
358.book Page 1139 Monday, September 4, 2006 8:51 AM
Index
Speicherabzug anlegen 1063 öffnen 1065 Rangliste 1066 vergleichen 1066 Speicheranalyse ABAP Debugger 1063 Speicherbereich AS ABAP 186 Speicherleck Beispiel 1068 Objekt 230 Ursachen 1059 Speichermedium persistent 769 Speicherobjekt dynamisch 1060 Sperre Shared Objects 478 Sperrkonzept AS ABAP 815 Sperrobjekt SAP-Sperre 816 Sperrtabelle SAP-Sperre 816 Spezialisierung Vererbung 391 SPLIT ABAP-Anweisung 332 Splitter-Container Beispiel 660 CFW 644 Spool-Auftrag erzeugen 716 Hintergrundverarbeitung 703 SQL Structured Query Language 771 SQL Trace Werkzeug 778 sqrt Gleitpunktfunktion 313 sRFC ausführen 931 synchroner RFC 922 ST Simple Transformations 1009 ST22 Transaktion 555
STANDARD TABLE TYPES/DATA 270, 347 standard table generischer Typ 288 Standardschlüssel interne Tabelle 351 Standardselektionsbild anlegen 697 ausführbares Programm 493, 673 drucken 716 Standardtabelle Tabellenart 347 Verwendung 349 Standardverarbeitungsblock ABAP-Programm 95 ST-Anweisung Simple Transformations 1011 STARTING AT CALL SCREEN 570 CALL SELECTION-SCREEN 688 STARTING NEW TASK CALL FUNCTION 933 START-OF-SELECTION Ereignis 493 Standardereignis 495 Verwendung 495 Startwert Selektionsbild 676 stateful Internet-Kommunikation 966 stateless Internet-Kommunikation 966 statische Komponente Klasse 207 verwenden 213 statische Methode anlegen 210 Redefinition 405 statischer Konstruktor implementieren 126 Klasse 234 Vererbung 411 statischer Typ Datenreferenzvariable 882 Interfacereferenzvariable 439 Objektreferenzvariable 436 Polymorphie 449 Referenzvariable 307 Vererbungsbaum 439
1139
358.book Page 1140 Monday, September 4, 2006 8:51 AM
Index
statisches Attribut anlegen 208 Shared Objects 475 Vererbung 404 Statusleiste SAP GUI 562 Statusmeldung Nachrichtentyp 731 Steploop Technik 631 ST-Programm Aufbau 1014 ST-Prozessor AS ABAP 158 string ABAP-Typ 263 Stringliteral Datenobjekt 293 strlen Beschreibungsfunktion 313, 342 Struktur ABAP Dictionary 280 asXML 1006 Datenobjekt 101 deklarieren 266 Initialwert 311 JCo 954 RFC API 945 RTTC 898 vergleichen 321 zuweisen 304 Strukturkomponente einbinden 268 verwenden 267 zuweisen 308 Strukturkomponentenselektor ABAP-Syntax 267 SUBMIT ABAP-Anweisung 168, 491 Standardselektionsbild 698 Subquery SELECT 797 Subroutinen-Pool anlegen 135 Programmtyp 172, 519 SUBSCREEN SELECTION-SCREEN 686 Subscreen Bildschirmelement 575
1140
Dynpro 635 Subscreen-Dynpro Selektionsbild 686 Subscreen-Dynpros Tabstrip-Seite 635 SUBSTRING FIND/REPLACE 334 SUBTRACT ABAP-Anweisung 311 Suchhilfe ABAP Dictionary 601 anlegen 82, 601 verwenden 116 Suchhilfepflege ABAP Dictionary 82 SUM Aggregatfunktion 780 super-> Pseudoreferenz 398 super->constructor Vererbung 406 sy Struktur 296 sy-dbcnt Systemfeld 778 sy-dynnr Systemfeld 569 symbolischer Name Feldsymbol 869 Symbolleiste SAP GUI 562, 583 Syntax prüfen 1026 Syntaxbereinigung ABAP Objects 28, 196 Syntaxdiagramm ABAP-Schlüsselwortdokumentation 147 Syntaxfehler ABAP-Programm 93 Syntaxprüfung 1026 Syntaxkonvention Verwendung 50 Syntaxprüfung ABAP-Programm 93 Syntaxwarnung Syntaxprüfung 1026 SYST Struktur 296
358.book Page 1141 Monday, September 4, 2006 8:51 AM
Index
SYSTEM_FAILURE RFC 932 Systembibliothek ABAP 25 System-Codepage Textumgebung 162 Systemdatencontainer eCATT 1076 Systemereignis GUI Control 651 Systemfeld Datenobjekt 295 Systemfunktionsleiste Icon 585 SAP GUI 562, 583 sy-subrc Systemfeld 297 sy-tabix Systemfeld 355, 360 sy-ucomm Systemfeld 582
T t ABAP-Typ 258, 262 T100 Datenbanktabelle 728 Tabellenart interne Tabelle 270, 347 Tabellendefinition ABAP Dictionary 75 Tabellenindex interne Tabelle 348 Tabellenparameter Funktionsbaustein 510 Unterprogramm 517 Tabellenpflege ABAP Dictionary 72 Tabellenschlüssel Datenbanktabelle 75 deklarieren 350 interne Tabelle 271, 349 Tabellentyp ABAP Dictionary 281 ABAP-Programm 270 generisch 288 TABLE INSERT 355
table generischer Typ 288 Table Control anlegen 627 Bildschirmelement 575 blättern 633 Dynpro 627 Wizard 629 TABLE KEY READ TABLE 358 TABLE OF TYPES/DATA 270 table_line Pseudokomponente 351 TABLES ABAP-Anweisung 580 FORM 517 TABLEVIEW CONTROLS 632 TABSTRIP CONTROLS 636 Tabstrip Bildschirmelement 575 Tabstrip Control Dynpro 634 Selektionsbild 686 Wizard 637 Tag XML 991 Tag Browser Object Navigator 1012 tan Gleitpunktfunktion 313 tanh Gleitpunktfunktion 313 TCP/IP Protokoll 922 Teilfeld Zugriff 341 Teilfeldadressierung Feldsymbol 873 Testaufgabe ABAP Unit 1050 Testdatencontainer eCATT 1076 Testeigenschaft ABAP Unit 1054 testen Werkzeuge 1023
1141
358.book Page 1142 Monday, September 4, 2006 8:51 AM
Index
Testhierarchie ABAP Unit 1050 Testklasse ABAP Unit 1050 anlegen 1054 Testkonfiguration eCATT 1076 Testlauf ABAP Unit 1057 Testmethode ABAP Unit 1050 anlegen 1054 Testskript eCATT 1076 Testsysteme CTS 65 Testteil ABAP-Programm 1053 Testverfahren statisch 1025 Textedit Control CFW 646 Verwendung 721 Textelement übersetzen 292 verwenden 110 Textelementpflege Werkzeug 111, 291 Textfeld Bildschirmelement 574 Datenobjekt 258, 261 Textfeldliteral Datenobjekt 293 Text-Pool Textumgebung 162 Textstring Datenobjekt 263 Textsymbol anlegen 111 Datenobjekt 290 Textelement 291 verwenden 110 Textumgebung ABAP-Laufzeitumgebung 162 AS ABAP 26 tief Datentyp 284 Struktur 285
1142
tiefes Datenobjekt Speicherbedarf 285, 1061 TIMES DO 327 Tipps & Tricks Laufzeitanalyse 1072 Titelleiste SAP GUI 562, 583 TO SAP-SPOOL SUBMIT 700, 716 Token ABAP-Anweisung 90 dynamisch angeben 903 Toolbar Control CFW 645 Top-Include Funktionsgruppe 108, 506 Include-Programm 180 TOP-OF-PAGE Listenereignis 706 Transaktion ausführen 141, 169 Programmausführung 139 SAP LUW 815 schachteln 843 Transaktionscode anlegen 139 aufrufen 169 Dialogtransaktion 498, 568 Entwicklungsobjekt 169 SAP Easy Access 59 Transaktion 139 Transaktionsdienst Object Services 841 verwenden 841 Transaktionskennung tRFC 937 Transaktionsmanager Transaktionsdienst 841 Transaktionsmodus Transaktionsdienst 844 Transaktionsobjekt Transaktionsdienst 841 transaktionsübergreifender Anwendungspuffer Daten-Cluster 856 TRANSFER ABAP-Anweisung 847
358.book Page 1143 Monday, September 4, 2006 8:51 AM
Index
Transformation Editor Werkzeug 1002, 1011 transientes Attribut persistente Klasse 838 TRANSLATE ABAP-Anweisung 332 Transport Repository-Objekt 65 Transport Organizer CTS 66, 70 Transportauftrag CTS 68 Transportschicht CTS 66 Paket 67 TRDIR Systemtabelle 915 Tree Control Beispiel 662 CFW 647 tRFC ausführen 937 RFC API 946 Status 939 transaktionaler RFC 923 Verwendung 924 TRFC_SET_QUEUE_NAME qRFC 939 trunc numerische Funktion 313 TRY ABAP-Anweisung 529 Kontrollstruktur 529 TRY-Block TRY-Kontrollstruktur 529 tt:cond 1019 tt:include 1015 tt:loop 1018 tt:parameter 1015 tt:ref 1015 tt:root 1014 tt:switch 1020 tt:template 1014 tt:transform 1014 tt:type 1015 tt:value 1016 tt:variable 1015 Typangabe dynamisch 904
TYPE CREATE OBJECT 437 DATA 249, 253 METHODS 380 TYPES 253 TYPE TABLE OF TYPES/DATA 352 Typenhierarchie ABAP 250 TYPE-POOL ABAP-Anweisung 174, 283 TYPES ABAP-Anweisung 217, 253 Typgruppe ABAP Dictionary 282 Programmtyp 173 Typisierung definieren 380 Funktionsbausteinparameter 510 generisch 287, 381 überprüfen 380 Unterprogrammparameter 517 vollständig 286, 381 Typklasse RTTS 894 Typkonvertierung Operandenposition 299 Zuweisung 298 Typname absolut 897 Typobjekt erzeugen 899 RTTC 898 RTTS 893
U UDDI Server 985 Universal Description, Discovery and Integration 973 UDDI-Registry Webservice 985 ULINE ABAP-Anweisung 706 UN/CEFACT United Nations Center for Trade Facilitation and Electronic Business 974
1143
358.book Page 1144 Monday, September 4, 2006 8:51 AM
Index
UNASSIGN ABAP-Anweisung 879 Unicode SAP-System 24 Unicode-Fragmentsicht Struktur 305 Unicode-Programm ABAP-Programm 175 Byte-/Zeichenkettenverarbeitung 331 Unicodeprüfungen aktiv Programmeigenschaft 175 Unicode-System AS ABAP 162 UNIQUE KEY TABLE 351 Unterfolge suchen/ersetzen 334 Unterklasse anlegen 391 implizit 391 Komponente 391 Vererbung 389 Unterprogramm aufrufen 518 Funktionsgruppe 507 Prozedur 177, 516 Verwendung 519 Unterprogrammaufruf dynamisch 910 Unterstruktur Struktur 266 Untertransaktion Transaktionsdienst 843 Up Cast Datenreferenzvariable 891 Interface 441 Interfacereferenzvariable 424 Objektreferenzvariable 440 Vererbung 441 UPDATE dbtab ABAP-Anweisung 806 UPDATE TASK CALL FUNCTION 813 URI Uniform Resource Identifier 994 URL Zugriff 962 User Breakpoint ABAP Debugger 1043
1144
USER-COMMAND SELECTION-SCREEN 694 USING FORM 516 PERFORM 518 UTC Coordinated Universal Time 318
V VALUE CONSTANTS 209, 290 DATA 265 METHODS 376 VALUE CHECK PARAMETERS 677 Variable Datenobjekt 289 Variante Laufzeitanalyse 1070 Variantentransaktion Dialogtransaktion 498 Verarbeitungsblock beenden 167 Dynpro-Ablauflogik 563, 564 Implementierung 164 Verarbeitungsblock ABAP-Programm 92 Verbuchung SAP LUW 813 Verbuchungsfunktionsbaustein Verbuchung 813 Verbuchungsworkprozess AS ABAP 813 Vererbung ABAP Objects 27, 389 Interface 434 Objektorientierung 193 Polymorphie 449 Vererbungsbaum ABAP Objects 390 Vergleich byteartig 321 Konvertierung 319 logischer Ausdruck 319 numerisch 320 WHERE-Klausel 787 zeichenartig 321
358.book Page 1145 Monday, September 4, 2006 8:51 AM
Index
Vergleichsoperator logischer Ausdruck 319 verkettete Liste Beispiel 889 Verschattung Datenobjekt 248 Verwendungsart SAP NetWeaver 152 Verzweigung bedingt 325 Kontrollstruktur 325 Verzweigungsliste erstellen 712 klassische Liste 706 VIA JOB SUBMIT 492, 700 VIA SELECTION-SCREEN SUBMIT 688 View anlegen 774 Datenbank-View 773 MVC 734, 745 Web Dynpro ABAP 738 View Designer Web Dynpro ABAP 738 View-Context Web-Dynpro-View 749 View-Layout Web-Dynpro-View 738, 751 View-Navigation Web Dynpro ABAP 759 vollständige Typisierung Verwendung 383 Volltextsuche ABAP-Schlüsselwortdokumentation 149 Vorwärtsnavigation ABAP Workbench 62, 76
W W Nachrichtentyp 731 W3C World Wide Web Consortium 974 wahr logischer Ausdruck 318 WAIT UNTIL ABAP-Anweisung 934
Warnung Nachrichtentyp 731 Watchpoint ABAP Debugger 1044 Web Dynpro ABAP 733 AS ABAP 155 Java 735 Wizard 746 Web Dynpro ABAP Beispielanwendung 767 Verwendung 734 Web Dynpro Explorer Werkzeug 737 Web Service Framework AS ABAP 975, 978 J2EE-Server 983 Web-Dynpro-Anwendung ausführen 743 Web Dynpro ABAP 742, 758 Web-Dynpro-Component Web Dynpro ABAP 735, 745 Web-Dynpro-Context Web-Dynpro-Controller 746 Web-Dynpro-View Navigation 761 Web Dynpro ABAP 749 Web-Dynpro-Window Web Dynpro ABAP 740 Web-Reports Beispiel 962 Webservice ABAP 971 anlegen 978 AS ABAP 975 Enterprise SOA 972 freigeben 981 publizieren 985 Service-Provider 975 Service-Requestor 976 Standardisierung 973 testen 983 UDDI-Registry 976 Verwendung 971 Webservice-Client anlegen 986 Webservice-Homepage Web Service Framework 983
1145
358.book Page 1146 Monday, September 4, 2006 8:51 AM
Index
Werkzeugbereich Object Navigator 62 Wertebereich Domäne 79, 85 Dynpro 595 Werteliste Dropdown-Listbox 605 Wertesemantik dynamisches Datenobjekt 1060 Feldsymbol 868 Zuweisung 285 Wertübergabe Formalparameter 377 WHEN ABAP-Anweisung 326 WHERE DELETE itab 363 LOOP 360 MODIFY itab 362 WHERE-Klausel SELECT 786 Verwendung 789 WHILE ABAP-Anweisung 328 Window Editor Web Dynpro Explorer 740 WITH SUBMIT 700 WITH KEY READ TABLE 358 Wizard Dynpro Control 627 Web Dynpro 746 Webservice 978 Workprozess Applikationsserver 185 Datenbankanmeldung 185 Datenbank-LUW 810 WRITE ABAP-Anweisung 705 ausführbares Programm 707 WRITE TO ABAP-Anweisung 309 WSADMIN Transaktion 983 WSCONFIG Transaktion 981 WSDL Web Services Description Language 973
1146
WSDL-Dokument anzeigen 984 URL 986 WS-I Web Service Interoperability Organization 974 Wurzelklasse Vererbungsbaum 390 Wurzelobjekt Shared Objects 481
X X Nachrichtentyp 732 x ABAP-Typ 258, 262 XI SAP NetWeaver Exchange Infrastructure 976 XML 989 AS ABAP 989 CALL TRANSFORMATION 1003 Dokument 992 Extensible Markup Language 990 XML-Dokument Baumdarstellung 996 wohlgeformt 996 xmlns XML-Namespace 994 XML-Parser iXML Library 995 XML-Renderer iXML Library 995 xsequence generischer Typ 288 XSLT DOM 1002 Extensible Stylesheet Language Transformations 1000 XSLT-Programm anlegen 1002 aufrufen 1003 Programmgenerierung 1001 Repository-Objekt 1001 XSLT-Prozessor AS ABAP 158, 1001 xstring ABAP-Typ 263
358.book Page 1147 Monday, September 4, 2006 8:51 AM
Index
Z Z_ABAP_BOOK Paket 66 Zahlenliteral Datenobjekt 292 zeichenartig Datentyp 259 Zeichenkette Operation 331 suchen/ersetzen 333 verarbeiten 330 Zeile Selektionsbild 686 Zeilentyp interne Tabelle 270, 346 Zeitfeld berechnen 315 Datenobjekt 258, 262 Gültigkeit 316 vergleichen 320 Zeitstempel Datum und Zeit 318 Zielsystem CTS 65 Zuweisung Datenobjekt 297 Down Cast 444 dynamisch formatiert 904 elementares Datenobjekt 300 formatiert 309 interne Tabelle 306 Referenzvariable 307 Struktur 304 Up Cast 440
1147
