Sappress Abap Objects 358 PDF

Horst Keller, Sascha Krger
ABAP Objects
ABAP-Programmierung mit SAP NetWeaver
Auf einen Blick

Vorwort ............................................................................. 1 2 3 4 5 6 7 8 9 10 11 12 13 A Einleitung .......................................................................... Eine praktische Einfhrung ............................................... 19 23 55
ABAP-Grundlagen ............................................................. 151 Klassen und Objekte ........................................................ 191 Grundlegende ABAP-Sprachelemente .............................. 245 Weiterfhrende Konzepte von ABAP Objects ................. 369 Klassisches ABAP Ereignisse und Prozeduren ............... 489 Fehlerbehandlung ............................................................. 523 GUI-Programmierung mit ABAP ....................................... 559 Arbeiten mit persistenten Daten ...................................... 769 Dynamische Programmierung ........................................... 867 Externe Schnittstellen ...................................................... 917 Test- und Analysewerkzeuge ............................................ 1023 Anhang .............................................................................. 1077
Die Autoren .............................................................................. 1103 Index ........................................................................................ 1107
Inhalt
Vorwort .................................................................................................... 19
Einleitung ...........................................................................
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 knnen 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 23 25 26 26 29 31 32 42 42 43 49 50 51 51 52 52 53 53
1.2
1.3
Eine praktische Einfhrung ................................................

2.1 2.2 Funktionalitt 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 fr lokale Entwicklungsobjekte ........................ 2.3.2 Pakete fr transportierbare Entwicklungsobjekte ....... 2.3.3 Paket anlegen ........................................................... 2.3.4 Transport Organizer aufrufen .................................... Datenbanktabellen ................................................................ 2.4.1 Kundentabelle anlegen ............................................. 2.4.2 Datenelement anlegen ..............................................
55
56 57 57 60 63 64 65 66 70 71 72 76
2.3
2.4
Inhalt
2.5
2.6
2.7
2.8
2.9 2.10
2.4.3 Domne 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 Kettenstze ............................................................... 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 fr Reservierungen ................... 2.8.3 Anlegen einer Klasse fr Kundenobjekte ................... 2.8.4 Anwendungsprogramm ............................................. 2.8.5 Transaktionscode anlegen ......................................... 2.8.6 Transaktion ausfhren ............................................... 2.8.7 Reporting .................................................................. Zusammenfassung ................................................................. Verwendung der Schlsselwortdokumentation ......................
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 ..............................................................
3.1 ABAP und SAP NetWeaver .................................................... 3.1.1 SAP NetWeaver ........................................................ 3.1.2 Der Application Server ..............................................
151
151 151 152
Inhalt
3.2
3.3
3.4
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-Programmausfhrung ...................................... 3.2.3 ABAP-Programmaufrufe ............................................ 3.2.4 ABAP-Programmtypen .............................................. 3.2.5 Weitere Programmeigenschaften ............................... 3.2.6 Verarbeitungsblcke ................................................. 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 ..........................................................

4.1 4.2 4.3 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 ....................................................
191
191 194 196 197 198 206 206 208 210 213 215 216 218 218 221 222 224 226 229
4.4
4.5 4.6
Inhalt
4.7
4.8
4.9 4.10
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 ...............................

5.1 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 Ausdrcke .................................................. 5.2.1 Zuweisungen ............................................................. 5.2.2 Typkonvertierungen .................................................. 5.2.3 Spezielle Zuweisungen .............................................. 5.2.4 Berechnungen ........................................................... 5.2.5 Logische Ausdrcke .................................................. 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 fr die Zeichenkettenverarbeitung .......... 5.4.5 Vergleichsoperatoren fr die Zeichenkettenverarbeitung ........................................
245
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 343
5.2
5.3
5.4
10
Inhalt
5.5
Interne Tabellen .................................................................... 5.5.1 Eigenschaften interner Tabellen ................................ 5.5.2 Arbeiten mit internen Tabellen .................................
345 346 354
Weiterfhrende Konzepte von ABAP Objects ..................

6.1 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 Namensrume 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 fr 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 auslsen .................................................... 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 .........................................
369
373 373 385 389 389 391 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
6.2
6.3
6.4
6.5
6.6
11
Inhalt
6.6.3 6.6.4 6.6.5 6.6.6
Gebiet anlegen .......................................................... Sperren ..................................................................... Arbeiten mit Shared Objects ..................................... Verwaltung von Shared Objects ................................
475 478 479 485
Klassisches ABAP Ereignisse und Prozeduren ................

7.1 Ereignisorientierte Programmausfhrung .............................. 7.1.1 Ausfhrbare Programme ........................................... 7.1.2 Dialogtransaktionen .................................................. 7.1.3 Vergleich der klassischen Programmausfhrungen ..... Prozedurale Modularisierung ................................................. 7.2.1 Funktionsbausteine ................................................... 7.2.2 Unterprogramme ......................................................
489
491 491 498 500 502 503 516
7.2
Fehlerbehandlung ..............................................................
8.1 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 frheren Konzepten ........................ 8.2.5 Nicht abfangbare Laufzeitfehler ................................. Assertions .............................................................................. 8.3.1 Vorteile von Assertions ............................................. 8.3.2 Anwendung von Assertions .......................................
523
523 523 524 525 526 546 550 552 555 556 556 557
8.2
8.3
GUI-Programmierung mit ABAP ........................................

9.1 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 ................................
559
561 562 563 565 566 572 578 582
12
Inhalt
9.2
9.3
9.4
9.5
9.1.8 Kontextmens ........................................................... 9.1.9 Dialogmodule ........................................................... 9.1.10 Datentransport ......................................................... 9.1.11 Bedingte Modulaufrufe ............................................. 9.1.12 Eingabeberprfungen .............................................. 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 ausfhrbaren 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
Inhalt
10 Arbeiten mit persistenten Daten .......................................

10.1 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 Objektidentitt GUID ................................................ 10.2.4 Transaktionsdienst .................................................... Dateischnittstellen ................................................................. 10.3.1 Dateien des Applikationsservers ................................ 10.3.2 Dateien des Prsentationsservers .............................. Daten-Cluster ........................................................................ 10.4.1 Daten-Cluster ablegen .............................................. 10.4.2 Daten-Cluster einlesen .............................................. 10.4.3 Daten-Cluster lschen ............................................... 10.4.4 Beispiel zu Daten-Clustern ........................................ Berechtigungsprfungen ........................................................ 10.5.1 Berechtigungsobjekte und Berechtigungen ................ 10.5.2 Berechtigungsprfung ...............................................
769
770 772 775 808 819 825 826 829 839 841 845 846 851 855 855 857 857 858 860 860 861
10.2
10.3
10.4
10.5
11 Dynamische Programmierung ............................................

11.1 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 .......................
867
868 869 882 893 894 898 903 904 904 905 906 907 910
11.2
11.3
11.4
14
Inhalt
11.5
Programmgenerierung ........................................................... 11.5.1 Transiente Programmgenerierung .............................. 11.5.2 Persistente Programmgenerierung .............................
910 912 915
12 Externe Schnittstellen ........................................................

12.1
917
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 fr 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 fr 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
Inhalt
13 Test- und Analysewerkzeuge ............................................. 1023

13.1 Statische Testverfahren .......................................................... 13.1.1 Syntaxprfung ........................................................... 13.1.2 Erweiterte Programmprfung .................................... 13.1.3 Code Inspector .......................................................... Programmanalyse mit dem ABAP Debugger ........................... 13.2.1 Der neue ABAP Debugger mit Zwei-ProzessArchitektur ................................................................ 13.2.2 Oberflche 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 Ausfhrung und Analyse eines Testlaufs .................... 13.3.5 ABAP Unit im Code Inspector ................................... ABAP Memory Inspector ....................................................... 13.4.1 Dynamische Speicherobjekte ..................................... 13.4.2 Speicherabzge 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
13.2
13.3
13.4
13.5
13.6
A Anhang ............................................................................... 1077

A.1 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
16
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 fr 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
Ein Arzt, ein Hochbauingenieur und ein Informatiker unterhielten sich darber, was der lteste Beruf der Welt sei. Der Mediziner fhrte an: Schon in der Bibel heit es, dass Gott Eva aus Adams Rippe erschaffen hat. Dafr wurde natrlich 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 heit es, dass Gott die Ordnung des Himmels und der Erde aus dem Chaos geschaffen hat. Das war der erste und wahrscheinlich der spektakulrste Einsatz des Bauingenieurwesens. Deshalb, lieber Doktor, irren Sie sich: Ich habe den ltesten Beruf der Welt. Der Informatiker lehnte sich in seinem Stuhl zurck, lchelte und sagte dann verbindlich: Und wer, meine Herren, glauben Sie, hat das Chaos erschaffen? Grady Booch, Object- Oriented Analysis and Design with Applications
Weiterfhrende 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 Komplexitt ein. Ein Vorteil des objektorientierten Ansatzes ist die Bewltigung der Komplexitt. 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 Identitt. Der Zugang zu einem Objekt erfolgt ber Referenzvariablen, die auf diese Adresse zeigen. Ein Objekt in einem Programm, das eine Aufgabe lst, sollte ein reales Objekt der Aufgabe mglichst eins zu eins wiedergeben. Bei
Grundlagen
369
einem Objekt kann klar eine ffentliche Schnittstelle von den privaten und geschtzten, also nach auen 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 auslst (siehe Abschnitt 6.5.2).
Klassen sind Quelltext, der die Definition von mglichen Objekten enthlt. 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 fr alle Programme oder lokal in einem Programm. Sie knnen durch Vererbung spezialisiert werden (siehe Abschnitt 6.2), und sie knnen als ffentliche Schnittstelle eigenstndige 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 auen nderbar sein sollten. Zustzlich kann eine Klasse statische Attribute enthalten, die von allen Objekten der Klasse gemeinsam verwendet werden. Neben Variablen knnen statische Attribute auch Konstanten sein. Methoden ermglichen es Objekten, Operationen auszufhren. 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 Auslsen von Ereignissen interagieren. Eine Methode hat eine Parameterschnittstelle (siehe Abschnitt 6.1.1) und kann Ausnahmen weiterreichen (siehe Abschnitt 8.2). Zustzlich kann eine Klasse statische Methoden enthalten, die nur auf statische Attribute zugreifen und statische Ereignisse auslsen knnen.
Vielleicht haben Sie schon erkannt, wie mchtig 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 mglich ist. In diesem Kapitel werden wir Sie mit weiteren Konzepten
1 Fr ein Objekt einer Klasse sind die privaten Komponenten eines anderen Objekts der gleichen Klasse sichtbar.
370
bekannt machen, die fr 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 eingefhrt. In Abschnitt 6.1.1 untersuchen wir die Parameterschnittstelle von Methoden etwas genauer und gehen auerdem auf die verschiedenen Mglichkeiten des Methodenaufrufs ein. Spezialisierung durch Vererbung ABAP Objects untersttzt 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 enthlt neben ihren eigenen Komponenten die Komponenten ihrer direkten Oberklasse, die wiederum die Komponenten ihrer Oberklasse enthlt. Die Implementierung von Oberklassenmethoden kann in Unterklassen berschrieben werden. Wir beschreiben das Konzept der Vererbung in Abschnitt 6.2. Eigenstndige Interfaces Der ffentliche Sichtbarkeitsbereich einer Klasse ist deren Schnittstelle nach auen. ABAP Objects erlaubt es Ihnen, eigenstndige Interfaces anzulegen, die von Klassen als Teil ihrer Schnittstelle oder sogar als ihre gesamte Schnittstelle verwendet werden knnen. Objekte verschiedener Klassen, die das gleiche Interface verwenden, knnen von auen gleichartig behandelt werden. Ein eigenstndiges 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 ausschlielich 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 eigenstndigen Interfaces erlauben die Zuweisung von Objektreferenzen zwischen Referenzvariablen
Fortgeschrittene Konzepte
371
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 ausgefhrt. 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 auslsen, und Methoden anderer Objekte knnen 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 sptestens mit Beendigung des Programms aus dem Speicher gelscht. Aus diesem Grund kann normalerweise nicht programmbergreifend auf Objekte zugegriffen werden. Fr den programmbergreifenden 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 bewhrter fortgeschrittener Techniken, die ABAP Objects anhand der Vorbilder gngiger 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, wre nur die Kom-
372
Methodenschnittstellen und Methodenaufrufe
6.1
plexitt der Sprache gestiegen, ohne dass viel zustzlicher Nutzen fr SAP-Anwendungen gewonnen worden wre. Ganz nach dem ASAPPrinzip, also As Simple As Possible, wurde ABAP Objects so verstndlich wie mglich umgesetzt, wobei nur bewhrte objektorientierte Konzepte zum Einsatz kamen. Das Interfacekonzept wurde dem Beispiel von Java folgend als Ersatz fr die Mehrfachvererbung eingefhrt. Die richtige Anwendung von Vererbung und Interfaces stellt die Krnung der objektorientierten Programmierung dar und erlaubt Ihnen vielfache Mglichkeiten zur Bewltigung der Komplexitt.2 Die Vielfalt der Mglichkeiten, eine Parameterschnittstelle von Methoden zu definieren, ist dagegen eine ABAP-Spezialitt. Genauso ist das Konzept, Ereignisse als eigenstndige Komponenten von Klassen vollstndig in den Sprachumfang von ABAP Objects zu integrieren, nicht in allen objektorientierten Programmiersprachen enthalten.
6.1
In den vorausgegangenen Kapiteln haben wir schon hufig Methoden definiert und aufgerufen. Die folgenden beiden Abschnitte fhren 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 Zustze 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 ntig. Bei globalen Klassen kann man sich aber die Schnittstelle whrend der Implementierung anzeigen lassen.
2 Wir wollen aber auch nicht verschweigen, dass eine falsche oder falsch verstandene Verwendung von Konzepten wie der Vererbung zu groen Problemen fhren kann. Gerade wenn komplexe Anwendungen durch die weiterfhrenden Konzepte der Objektorientierung bewltigt werden sollen, ist eine sorgfltige objektorientierte Modellierung unabdingbar.
373
Formalparameter
Die Parameterschnittstelle einer Methode umfasst Formalparameter und Ausnahmen. Auf die Deklaration von Ausnahmen gehen wir in Abschnitt 8.2 ein. Formalparameter sind Schlsselwortparameter, an die beim Aufruf der Methode ein Aktualparameter angebunden werden muss oder kann. Formalparameter knnen innerhalb der Methode ber ihren Namen an Operandenpositionen verwendet werden, wobei die Art der Verwendung von den Parametereigenschaften abhngt. Fr einen Formalparameter knnen folgende Eigenschaften festgelegt werden:

Art des Parameters bergabeart fr 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 enthlt keine, einen oder nur wenige Eingabeparameter und einen Rckgabewert.
Keine berladung
An dieser Stelle sei auch angemerkt, dass Methoden in ABAP Objects nicht berladen werden knnen. D.h., Sie knnen nicht den gleichen Methodennamen mit unterschiedlichen Parameterschnittstellen verwenden, auch nicht bei der Redefinition in Unterklassen.
Parameterart Sie knnen 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, fr die die Referenzbergabe definiert ist, drfen in der Methode nicht berschrieben werden. Eingabeparameter, fr die die Wertbergabe definiert ist, werden beim Verlassen der Prozedur nicht an den Aktualparameter bergeben.
374
6.1
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, fr den die Wertbergabe definiert ist, wird bei Aufruf der Methode nicht der Wert des zugeordneten Aktualparameters zugewiesen. Ausgabeparameter drfen 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 drfen in der Methode berschrieben werden. Rckgabewert 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 Rckgabewert haben, fr den die Wertbergabe deklariert sein muss. In der Methode wird ein Rckgabewert wie ein Ausgabeparameter behandelt. Eine Methode mit einem Rckgabewert ist aber eine funktionale Methode, die auer dem Rckgabewert nur Eingabeparameter haben kann. Eine funktionale Methode kann an Operandenpositionen eingesetzt werden, an denen dann der Rckgabewert verwendet wird.3
Funktionale Methode
Funktionale Methoden nicht Funktionsbausteine sind die natrliche Erweiterung der eingebauten Funktionen (siehe Abschnitt 5.2.4) um selbst definierte Funktionen, so wie selbst definierte Datentypen die eingebauten ABAP-Typen erweitern.
375
Whlen 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 gendert wird, ist ein Eingabeparameter. Ein Parameter, der nur ausgegeben, aber nicht entgegengenommen wird, ist ein Ausgabeparameter oder ein Rckgabewert. Ein Parameter, der entgegengenommen, gendert und ausgegeben wird, ist ein Ein-/Ausgabeparameter. Das klingt zwar selbstverstndlich, Sie werden aber gleich sehen, dass sich Parameter technisch gesehen nicht unbedingt so verhalten mssen, wie es ihrer Art entsprche.
bergabeart Bis auf den Rckgabewert, fr den die Wertbergabe fest vorgeschrieben ist, knnen Sie fr jeden einzelnen Parameter die bergabeart entweder als Referenzbergabe oder als Wertbergabe definieren. Die Syntax fr die Referenzbergabe am Beispiel eines Eingabeparameters ipara ist:
REFERENCE METHODS meth IMPORTING ipara ...
oder gleichbedeutend auch

METHODS meth IMPORTING REFERENCE(ipara) ...
Die Syntax fr die Wertbergabe am Beispiel des Rckgabewerts return ist:

VALUE METHODS meth RETURNING VALUE(return) ...
Im Class Builder legen Sie die bergabeart dadurch fest, dass Sie das Ankreuzfeld Wertbergabe auf der Parameter-Registerkarte des Class Builder ankreuzen oder nicht. Sowohl in der Syntax als auch im Class Builder ist die Referenzbergabe also der Standard, der verwendet wird, wenn nichts angegeben ist. Was ist nun der Unterschied zwischen den bergabearten?
Referenzbergabe Bei der Referenzbergabe bekommt die Methode bei ihrem Aufruf unabhngig von der Parameterart fr jeden Formalparameter, fr den ein Aktualparameter angegeben ist, eine Referenz auf den
376
6.1
Aktualparameter bergeben und arbeitet dadurch mit dem Aktualparameter selbst. nderungen am Formalparameter wirken unmittelbar auf den Aktualparameter.
Wertbergabe Bei der Wertbergabe wird beim Aufruf der Methode fr 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 Rckgabewerte den Wert des Formalparameters zugewiesen.
Parameterart vs. bergabeart
Die bergabeart ist eine technische Eigenschaft, die das Verhalten eines Formalparameters festlegt. Nur bei der Wertbergabe entspricht das tatschliche Verhalten immer dem durch die Parameterart definierten Verhalten. Bei der Referenzbergabe
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 drfen per Referenz bergebene Eingabeparameter zwar nicht explizit in der Methode verndert werden, knnen aber durch Anbindung an globale Aktualparameter ihren Wert ndern, wenn diese whrend der Ausfhrung der Methode gendert werden
Aus diesem Grund sollte eine Methode immer so programmiert werden, dass das Verhalten ihrer Parameter der durch die Parameterart festgelegten Semantik entspricht:
Fhren Sie keinen Lesezugriff auf einen per Referenz bergebenen Ausgabeparameter aus, da sein Startwert nicht festgelegt ist. Wenn Sie Zeilen an eine interne Tabelle anhngen oder einen String verlngern, 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
sen einer Ausnahme setzen, damit ein Aufrufer eine adquate Ausnahmebehandlung durchfhren kann.
Referenzbergabe vs. Wertbergabe
Bei der Referenzbergabe sind also ein paar Vorsichtsmanahmen zu treffen, die es bei der Wertbergabe nicht gibt. Warum gibt es die Referenzbergabe dann berhaupt? Die Antwort liegt in der Performance. Eine Referenzbergabe ist in ABAP immer performanter als die Wertbergabe, da beim Prozeduraufruf kein lokales Datenobjekt angelegt werden muss und kein Datentransport stattfindet. Aus Performancegrnden ist die Referenzbergabe der Wertbergabe 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 zurckgegeben wird. Solche Flle sollten, wenn mglich, auf die bergabe von Parametern mit einer Gre von kleiner etwa 100 Byte beschrnkt werden.4 Das Beispiel in Listing 6.1 zeigt eine kleine und wahrscheinlich unerwartete Falle, in die man bei der unberlegten Verwendung der Referenzbergabe 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.
Performance vs. Robustheit
Bei Strings und internen Tabellen kann der Performance-Nachteil der Wertgegenber der Referenzbergabe sogar durch deren eingebaute Copy-on-WriteSemantik (Sharing, siehe Abschnitt 5.1.7) aufgehoben werden. Dies gilt insbesondere fr Eingabeparameter, solange sie nicht gendert werden.
378
6.1
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 whrend des ersten und 2, 2, 2 whrend 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 Wertbergabe 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 Einfhrung einer lokalen Hilfsvariablen in main, der sy-index zugewiesen und die dann an meth2 bergeben wird, wrde auch meth2 das erwartete Ergebnis liefern.
379
Typisierung Sie mssen jeden Formalparameter einer Methode typisieren. Mit Typisierung ist gemeint, dass Sie einem Formalparameter einen Typ zuordnen. Die Syntax hierfr ist hnlich wie bei der Datendeklaration ein TYPE- oder LIKE-Zusatz, den Sie hinter jedem Formalparameter angeben mssen, 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 fr jeden Verwender der Methode zugnglich sein muss, knnen fr ffentliche Methoden nur eingebaute ABAP-Typen, globale Typen aus dem ABAP Dictionary oder Typen aus dem ffentlichen Sichtbarkeitsbereich einer globalen Klasse angegeben werden. Bei geschtzten Methoden sind zustzlich Typen aus dem geschtzten Sichtbarkeitsbereich der Klasse und bei privaten Methoden Typen aus dem privaten Sichtbarkeitsbereich sowie lokale Typen des Class-Pools mglich. Das Besondere an der Typisierung im Vergleich zu einer Datendeklaration ist, dass ein Formalparameter seinen tatschlichen Datentyp erst in dem Moment erhlt, in dem er bei einem Methodenaufruf an einen Aktualparameter gebunden wird. Der Formalparameter bernimmt dann smtliche technischen Eigenschaften des Aktualparameters.
berprfung der Typisierung
Damit ein Aktualparameter bergeben werden kann, muss sein Datentyp zur Typisierung des Formalparameters passen. Genauer gesagt, mssen seine technischen Typeigenschaften kompatibel zum Datentyp sein, der fr die Typisierung verwendet wurde. Die technischen Eigenschaften eines Elementartyps sind der eingebaute ABAPTyp (c, d, f, i, n, p, t, string, x, xstring), die Lnge (bei c, n, p, x) und die Anzahl der Nachkommastellen (fr 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 Tabellenschlssel.
380
6.1
Die Typisierung eines Formalparameters kann vollstndig oder generisch sein. Fr die vollstndige Typisierung beziehen Sie sich mit TYPE auf einen vollstndigen Datentyp oder mit LIKE auf ein Datenobjekt. Fr die generische Typisierung knnen 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 Tabellenschlssel nicht komplett definiert ist. Whrend vollstndig typisierte Formalparameter in der Methode immer wie lokale Datenobjekte dieses Typs betrachtet werden knnen, 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 knnen sich in den nicht-technischen Eigenschaften, wie z.B. Komponentennamen, von der Typisierung unterscheiden. Neben ihrer Rolle zur berprfung des Datentyps eines angebundenen Aktualparameters definiert die Typisierung, wie der Formalparameter als Operand von Anweisungen in der Methode verwendet werden kann. Mit einer Ausnahme knnen 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, fr 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.
Generische Typisierung
Operandenposition
Wie z.B. der dynamische Zugriff auf eine Komponente bei einer Operation auf einer internen Tabelle.
381
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 aufgefhrt, wobei Anweisungen, die fr die jeweilige Typisierung zu Syntaxfehlern fhren, auskommentiert sind:
Der Eingabeparameter ipar von Methode meth1 ist vollstndig generisch typisiert. Er kann der lokalen Variablen num zugewiesen werden. Es knnen aber keine Leseoperationen fr interne Tabellen ausgefhrt werden. Beim Methodenaufruf knnen beliebige
382
6.1
Datenobjekte an den Formalparameter bergeben werden. Wrde aber eine interne Tabelle bergeben, kme es bei der Zuweisung an num zu einer Ausnahme.
Der Eingabeparameter ipar von Methode meth2 ist mit einer bezglich Tabellenart, Zeilentyp und Tabellenschlssel generischen internen Tabelle typisiert. Er kann nicht der lokalen Variablen num zugewiesen werden. Es knnen nur Schlsselzugriffe fr interne Tabellen ausgefhrt werden, da nur diese bei allen Tabellenarten mglich sind. Beim Methodenaufruf knnen beliebige interne Tabellen an den Formalparameter bergeben werden. Der Eingabeparameter ipar von Methode meth3 ist mit einer bezglich Zeilentyp und Tabellenschlssel generischen Indextabelle typisiert. Er kann nicht der lokalen Variablen num zugewiesen werden. Es knnen aber alle Zugriffe fr interne Tabellen ausgefhrt werden, da bei Indextabellen Schlssel- und Indexzugriffe mglich sind. Beim Methodenaufruf knnen nur Indextabellen, aber keine Hash-Tabellen an den Formalparameter bergeben werden.
Formalparameter sollten mglichst 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 mssen, bleiben Sie immer so spezifisch wie mglich. 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 gegenber any table empfohlen. Je generischer Sie typisieren, desto umsichtiger mssen Sie bei der Verwendung des Formalparameters in der Implementierung sein, um Ausnahmen zu vermeiden. Dementsprechend mssten Zuweisungen vllig generisch typisierter Formalparameter vermieden werden, wenn Sie nicht vorher eine berprfung des Typs zur Laufzeit vornehmen (siehe Abschnitt 11.2) oder mgliche Ausnahmen behandeln (siehe Abschnitt 8.2) wollen. Falls generische Typisierung nicht notwendig ist, typisieren Sie immer vollstndig. Nur vollstndig typisierte Formalparameter verhalten sich immer gleich und knnen lokal getestet werden. Achten Sie insbesondere darauf, nicht aus Versehen generisch zu typisieren,
Generisch vs. vollstndig
383
wenn eigentlich vollstndige Typisierung gewnscht ist. Eine gngige Falle sind dabei interne Tabellentypen mit generischem Schlssel.
Versorgungsart Fr jeden Formalparameter, der einen Wert erwartet, d.h. Eingabeparameter und Ein-/Ausgabeparameter, muss standardmig beim Methodenaufruf ein Aktualparameter angegeben werden. Die Zuordnung von Aktualparametern an Ausgabeparameter und Rckgabewerte ist immer optional. Fr 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 ...
Fr 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 tatschlich bei jedem Aufruf der Methode eine andere Eingabe notwendig ist. Anderenfalls zwingen Sie Ihre Aufrufer dazu, unntige Aktualparameter anzugeben, fr die hufig sogar typgerechte Hilfsvariablen angelegt werden mssen. Sorgen Sie dafr, dass optionale Parameter immer passend initialisiert werden. Mit dem speziellen Prdikat
... IS SUPPLIED ...
384
6.1
knnen 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 Mglichkeiten zusammen, wie Methoden statisch aufgerufen werden knnen. Daneben gibt es auch die Mglichkeit des dynamischen Methodenaufrufs (siehe Abschnitt 11.4). Beim Aufruf einer Methode mssen an alle nicht-optionalen Formalparameter, d.h. alle Eingabe- und Ein-/Ausgabeparameter, die nicht als optional gekennzeichnet sind, Aktualparameter bergeben werden. An optionale Formalparameter knnen Aktualparameter angebunden werden. Die Aktualparameter mssen zur Typisierung der Formalparameter passen. Wir stellen die statischen Methodenaufrufe in Abhngigkeit von der Komplexitt der Methodenschnittstelle dar.
Statische Methodenaufrufe Die einfachste Methode hat keine Schnittstellenparameter. Dementsprechend einfach ist der Methodenaufruf. Die Anweisung ist:
meth( ). Kein Parameter
Mit meth geben Sie die Methode so an, wie Sie sie als Komponente einer Klasse bzw. eines Objekts an der aktuellen Stelle adressieren knnen, 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:
meth( dobj ). Ein Eingabeparameter
Dabei wird das Datenobjekt dobj als Aktualparameter an den Eingabeparameter bergeben. Wenn die Methode mehrere Eingabeparameter hat, ist die Anweisung:
meth( i1 = dobj1 i2 = dobj2 ... ). Mehrere Eingabeparameter
385
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 natrlich auch statt diesen verwendet werden. Schlielich und endlich knnen 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 unntiges 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 bentigt. Zur Erinnerung: Eine funktionale Methode hat beliebig viele Eingabeparameter und genau einen per Wert bergebenen Rckgabewert.
386
6.1
Dabei nimmt RECEIVING den Rckgabewert 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, aufgefhrt werden. Bei Ausfhrung der Anweisung wird die Methode aufgerufen und der Rckgabewert als Operand verwendet. Im gezeigten Fall wird er also dobj zugewiesen. Die Zuordnung von Aktualparametern an die Eingabeparameter erfolgt mit den drei bereits erklrten Syntaxformen fr 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 fr interne Tabellen
Wenn eine funktionale Methode, die an einer Operandenposition aufgerufen wurde, eine klassenbasierte Ausnahme nach auen reicht, kann diese innerhalb einer TRY-Kontrollstruktur behandelt werden.8 Ab SAP NetWeaver 2007 werden funktionale Methoden wie eingebaute Funktionen und ganze arithmetische Ausdrcke an fast allen Operandenpositionen einsetzbar sein, wo dies sinnvoll ist. Insbesondere werden sie als Aktualparameter fr Eingabeparameter von Methoden mglich sein, was Verkettungen von Methodenaufrufen erlauben wird.
8 Klassische Ausnahmen sind in diesem Fall nicht behandelbar.
387
In Listing 6.3 haben wir zwei funktionale Methoden get_area und get_volume zur Berechnung der Kreisflche 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
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 Bauplne oder Konstruktionsvorschriften fr Objekte. Stellen Sie sich jetzt vor, Sie schreiben die Klassen PKW und LKW. Sie wollen fr beide Klassen Methoden implementieren, die die Objekte steuern oder Informationen ber ihre Position und Geschwindigkeit zurckgeben. Bereits zu diesem Zeitpunkt lsst sich absehen, dass Sie einige Teile der Klassen doppelt schreiben mssen. Mit dem Vererbungsmechanismus einer objektorientierten Programmiersprache stehen Ihnen hier Mglichkeiten zur Verfgung, 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, knnen wir feststellen, dass es sich in beiden Fllen um Spezialflle eines Fahrzeugs handelt. Wollen wir eine dritte Klasse Kipper abbilden, handelt es sich dabei wiederum um den SpezialOberklassen und Unterklassen
389
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 heit, 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 fr unsere bisherigen Klassen, bei denen wir berhaupt noch nicht von Vererbung gesprochen haben. Fr jede Klasse lassen sich ihre Oberklassen entlang eines eindeutigen Pfads des Vererbungsbaums zu genau einem Wurzelknoten des Baums zurckverfolgen. Der Wurzelknoten ist die Oberklasse smtlicher Klassen des Vererbungsbaums. Abbildung 6.1 stellt diesen Zusammenhang grafisch dar. Der Wurzelknoten des Vererbungsbaums in ABAP Objects ist die vordefinierte leere und abstrakte Klasse object.
object
Wurzelklasse
CLASS c1 DEFINITION [INHERITING FROM object].
CLASS c2 DEFINITION [INHERITING FROM object].
CLASS c11 DEFINITION INHERITING FROM c1.
CLASS c12 DEFINITION INHERITING FROM c1.
Abbildung 6.1 Vererbungsbaum in ABAP Objects
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
Vererbung
6.2
Vererbung bedeutet nichts anderes, als dass eine Unterklasse smtliche 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 hinzufgen oder Methoden redefinieren, wovon die Oberklasse keine Kenntnis hat. In Unterklassen knnen immer nur Elemente hinzugefgt werden. Es widersprche dem Vererbungsgedanken, etwas wegzunehmen. Die direkten Unterklassen der Wurzelklasse object knnen demnach keine Komponenten aus ihrer leeren Oberklasse bernehmen, sondern nur neue Komponenten hinzufgen. Genau diese Situation besteht fr unsere bisherigen Klassen: Alle Klassen in ABAP Objects, die nicht explizit von einer anderen Klasse erben, sind implizit direkte Unterklassen von object. Wenn wir jetzt Unterklassen von explizit definierten Klassen bilden, erben diese deren Komponenten und knnen neue Komponenten hinzufgen. 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. 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 ausdrcken 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).
Ableitung
Implizite Unterklassen
Spezialisierung/ Generalisierung
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
INHERITING FROM
CLASS subclass DEFINITION INHERITING FROM superclass. ... ENDCLASS.
Es handelt sich also um einen simplen Zusatz zur Anweisung CLASS DEFINITION. Fr 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 ermglichen 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. Fr jede Klasse, die keinen expliziten Zusatz INHERITING FROM hat, ergnzt 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
Vererbung
6.2
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
truck_ref->unload( ). ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).
Die Klasse vehicle enthlt ein geschtztes 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 zustzlichen Attribut fr die Fracht und zustzlichen Methoden load und unload zum Beladen bzw. Entladen. Die Klasse car erhlt in diesem Beispiel noch keine zustzlichen Komponenten. Das bedeutet, dass sich ihre Objekte nicht von denen der Klasse vehicle unterscheiden. Da keine Methoden hinzugekommen sind, bentigt 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 knnen in beiden Unterklassen verwendet werden. Die Methoden load und unload gibt es aber nur in truck.
6.2.3
Sichtbarkeitsbereiche und Namensrume 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 smtliche Komponenten ihrer Oberklassen, wobei sich deren Sichtbarkeit nicht ndert. Das bedeutet, in einer Unterklasse sind nur die ffentlichen und geschtzten 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
Vererbung
6.2
In den Sichtbarkeitsbereichen einer Unterklasse sind also folgende Komponenten enthalten:
PUBLIC Der ffentliche Sichtbarkeitsbereich einer Unterklasse enthlt smtliche ffentlichen Komponenten aller Oberklassen zuzglich der hinzugekommenen eigenen ffentlichen Komponenten. Diese Komponenten sind von auen ber Komponentenselektoren ansprechbar. PROTECTED Der geschtzte Sichtbarkeitsbereich einer Unterklasse enthlt smtliche geschtzten Komponenten aller Oberklassen zuzglich der hinzugekommenen eigenen geschtzten Komponenten. Diese Komponenten sind nicht von auen ber Komponentenselektoren ansprechbar. Von auen gesehen hat geschtzt die gleiche Bedeutung wie privat. PRIVATE Der private Sichtbarkeitsbereich einer Unterklasse enthlt nur die eigenen privaten Komponenten. Diese Komponenten sind nur in den Methodenimplementierungen der Unterklasse ansprechbar.
Namensraum
Da alle in einer Klasse sichtbaren Komponenten eindeutige Namen haben mssen, liegen smtliche ffentlichen und geschtzten Komponenten aller Klassen auf einem Pfad des Vererbungsbaums in einem Namensraum und mssen eindeutige Namen haben. Private Komponenten, die nur innerhalb einer Klasse sichtbar und in Unterklassen nicht verwendbar sind, mssen 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, knnen Sie als Entwickler nie wissen, welche Unterklassen Ihre Klasse auer den von Ihnen definierten nach einiger Zeit haben wird. Wenn Sie dann nachtrglich neue Komponenten im ffentlichen oder geschtzten Bereich Ihrer Klasse einbauen und irgendeine Unterklasse zufllig eine namensgleiche eigene Komponente enthlt, machen Sie diese syntaktisch inkorrekt. Richtig sicher ist also nur das Hinzufgen von privaten Komponenten. In globalen Klassen ist also
395
nicht nur die Schnittstelle nach auen, sondern auch die Schnittstelle zu eventuellen Unterklassen stabil zu halten. Um die Unterklassen einer Klasse zumindest auf das gleiche Paket einzuschrnken, sollten nicht-finale Klassen deshalb bevorzugterweise in Paketen organisiert sein, bei denen die Eigenschaft Paketprfung als Server eingeschaltet ist (siehe Abschnitt 2.3.3).
6.2.4
Methodenredefinition
Eine Unterklasse bernimmt bei der Vererbung alle ffentlichen und geschtzten Methoden smtlicher Oberklassen zu ihren eigenen Komponenten.11 Beim Aufruf einer Methode in der Unterklasse luft 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 fr den speziellen Zweck einer Unterklasse ist. In einigen Fllen muss zur Implementierung der Oberklasse etwas hinzugefgt werden, in anderen Fllen muss die Implementierung vollstndig gendert werden. Die Semantik der Methode fr den ueren 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, knnen Instanzmethoden in Unterklassen redefiniert werden. Statische Methoden knnen nicht redefiniert werden. Die Redefinition einer Methode bedeutet eine neue Implementierung der Methode in einer Unterklasse bei unvernderter Schnittstelle.12 Die Deklaration der Methode erfolgt weiterhin in ihrer Oberklasse. Frhere Implementierungen der Methode in vorangehenden Oberklassen bleiben ebenfalls dort erhalten. Bei der Redefinition einer Methode in einer Unterklasse wird eine zustzliche 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 fr eine berschriebene bzw. redefinierte Methode eine eigene vernderte Parameterschnittstelle festgelegt werden. ABAP Objects untersttzt diesen Mechanismus zurzeit nicht.
396
Vererbung
6.2
Verwendung der Unterklasse und weiterer Unterklassen die frheren Implementierungen verschattet. Jede Referenz, die auf ein Objekt der Unterklasse zeigt, verwendet die redefinierte Methode. Das ist unabhngig vom Typ der Referenzvariablen (mehr dazu in Abschnitt 6.4). Dies gilt insbesondere auch fr die Selbstreferenz me. Wenn also eine Oberklassenmethode meth1 einen Aufruf einer Methode meth2 der eigenen Klasse enthlt, die in einer Unterklasse redefiniert wird, fhrt der Aufruf der Methode meth1 in einer Instanz der Oberklasse zur Ausfhrung der ursprnglichen Methode meth2 und der Aufruf von meth1 in einer Instanz der Unterklasse zur Ausfhrung der redefinierten Methode meth2. Eine redefinierte Methode greift wie die eigenen Methoden der Unterklasse auf die privaten Attribute der Unterklasse zu. Die Syntax zur Redefinition einer Instanzmethode in einer Unterklasse ist:
METHODS meth REDEFINITION. Zugriff
REDEFINITION
Diese Anweisung muss im Deklarationsteil der Unterklasse im gleichen Sichtbarkeitsbereich wie die eigentliche Deklaration der Methode in der Oberklasse aufgefhrt 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 (hierfr mit der Funktion Einstellungen des Class Builders den Eintrag auch geerbte Komponenten anzeigen whlen), markieren und die Funktion Redefinieren whlen (siehe Abbildung 6.3).
Abbildung 6.3 Redefinition einer geerbten Methode
Fr 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 knnen wie bei normalen Methoden zur Implementierung navigie-
Implementierung
397
ren. Bei lokalen Klassen mssen Sie die Implementierung wie gehabt selbst im Implementierungsteil eintragen.
Pseudoreferenz
In der Implementierung einer redefinierten Methode kann mittels der Pseudoreferenz super-> auf die ursprngliche Methode der direkten Oberklasse zugegriffen werden. Damit wird die Verschattung der redefinierten Methode umgangen. Diese Pseudoreferenz verwenden Sie immer dann, wenn Sie die Funktionalitt der Oberklasse zunchst bernehmen und dann ergnzen 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
Vererbung
6.2
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 eingefhrt, die in accelerate nicht berschritten werden darf. Deshalb wird in der Neuimplementierung die Geschwindig-
399
keit erst durch Aufruf von super->accelerate durch die vorherige Implementierung gesetzt, dann aber berprft 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 ursprngliche Semantik. Sie sehen, dass hier Programmierdisziplin gefordert ist, da wir die Methoden auch vllig anders implementieren knnten (mehr dazu in Abschnitt 6.4.3). Ein Testwerkzeug, das helfen kann, die Stabilitt von Anwendungen zu berprfen, ist ABAP Unit (siehe Abschnitt 13.3).
6.2.5
Abstrakte Klassen und Methoden
Wenn Sie eine Klasse nur als Vorlage fr Unterklassen verwenden wollen und keine Objekte dieser Klasse selbst bentigen, knnen Sie sie als abstrakte Klasse definieren. Die Syntax fr 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 knnen keine Objekte mit CREATE OBJECT erzeugt werden. Abstrakte Klassen dienen stattdessen als Vorlage fr Unterklassen. Von abstrakten Klassen knnen konkrete
400
Vererbung
6.2
Unterklassen abgeleitet werden, von denen dann Objekte erzeugt werden knnen. Auch einzelne Instanzmethoden knnen als abstrakt gekennzeichnet werden. Die Syntax ist:
METHODS meth ABSTRACT.
Im Class Builder knnen 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 knnen abstrakte Methoden nur in abstrakten Klassen angelegt werden. Ansonsten knnte 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 knnen sowohl konkrete als auch abstrakte Methoden deklariert werden. Konkrete Methoden werden wie gewohnt deklariert und implementiert. Die konkreten Methoden knnen sogar die abstrakten Methoden aufrufen, da ja Namen
Implementierung
401
und Schnittstellen vollstndig 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 rudimentr, und es werden keine Objekte von ihr erzeugt. Um dies grundstzlich zu verbieten, kann die Klasse, wie in Listing 6.6 gezeigt, abstrakt definiert werden. Listing 6.6 zeigt nur die Unterschiede gegenber 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 fllt 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
Vererbung
6.2
bereits teilweise implementierte Funktionalitt zur Verfgung, knnen jedoch selbst noch keine sinnvollen Operationen auf ihren Attributen ausfhren. In einem Gehaltsabrechnungssystem knnen Sie sich beispielsweise eine Klasse vorstellen, die schon viele Aufgaben wie berweisungsttigkeiten etc. implementiert, die eigentliche Gehaltsabrechnung aber nur abstrakt enthlt. Es ist dann die Aufgabe verschiedener Unterklassen, fr verschiedene Anstellungsverhltnisse die richtige Abrechnung durchzufhren. Da ABAP Objects keine Mehrfachvererbung untersttzt, 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 unabhngig von der Position in der Vererbungshierarchie lsen knnen.
Interfaces
6.2.6
Finale Klassen und Methoden
Wie abstrakte Klassen und Methoden die Definition von Unterklassen erfordern, um berhaupt mit den Klassen arbeiten zu knnen, kann es umgekehrt Situationen geben, in der Sie eine ganze Klasse oder eine einzelne Methode vor unkontrollierter Spezialisierung schtzen 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 sptere nderungen durchfhren 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 fr die Definition einer finalen Klasse ist:
CLASS class DEFINITION FINAL. ... ENDCLASS. FINAL
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 knnen keine Unterklassen mehr abgeleitet werden. Eine finale Klasse schliet demnach einen
403
Pfad der Vererbungshierarchie vollstndig ab. Alle Instanzmethoden einer finalen Klasse sind automatisch final. In einer nicht-finalen Klasse knnen einzelne Instanzmethoden als final deklariert werden. Die Syntax ist:
METHODS meth FINAL.
Im Class Builder knnen 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 knnen aber nur ihre statischen Komponenten verwendet werden. Die Deklaration von Instanzkomponenten in einer solchen Klasse ist zwar mglich, aber nicht sinnvoll.
6.2.7
Statische Attribute in der Vererbung
Zur Verwendung einer statischen Komponente einer Klasse sind keine Instanzen der Klasse ntig. 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 geschtzten statischen Attribute aller Oberklassen. Umgekehrt teilt sich eine Oberklasse ihre ffentlichen und geschtzten 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 auen sind ber den Klassenkomponentenselektor (=>) mit allen beteiligten Klassennamen oder von innen in allen beteiligten Klassen, in denen ein statisches Attribut sichtbar ist, mglich. 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
Vererbung
6.2
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 gehrt, wird unabhngig vom im Klassenkomponentenselektor verwendeten Klassennamen immer die Klasse angesprochen, in der das Attribut deklariert ist. Dies ist wichtig fr den Aufruf des statischen Konstruktors (siehe Abschnitt 6.2.8). Ein statischer Konstruktor wird bei der ersten Ansprache einer Klasse ausgefhrt. Wenn ein statisches Attribut ber den Klassennamen einer Unterklasse adressiert wird, aber in einer Oberklasse deklariert ist, wird nur der statische Konstruktor der Oberklasse ausgefhrt. Da statische Komponenten genau einmal in einem Pfad vorkommen sollen, um von allen Unterklassen gemeinsam genutzt zu werden, drfen statische Methoden in ABAP Objects nicht redefiniert werden.
Statischer Konstruktor
Statische Methoden
6.2.8
Konstruktoren in der Vererbung
Konstruktoren dienen der Initialisierung der Attribute einer Klasse (siehe Abschnitt 4.7). Whrend Instanzkonstruktoren die Instanz-
405
attribute jedes einzelnen Objekts bei der Instanzierung setzen knnen, sind die statischen Konstruktoren fr die statischen Attribute der Klasse vor dem ersten Zugriff auf die Klasse zustndig. Da in der Vererbung eine Unterklasse smtliche Attribute ihrer Oberklassen erbt, stellt sich automatisch die Frage, wie die Konstruktoren dafr 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 vllig unabhngig voneinander sein mssen. Um Namenskonflikte zu verhindern,
knnen Instanzkonstruktoren von Oberklassen in Unterklassen nicht redefiniert werden knnen Instanzkonstruktoren nicht explizit mit constructor( ) aufgerufen werden
super->constructor
Der Instanzkonstruktor wird automatisch nach dem Anlegen eines Objekts mit dem Befehl CREATE OBJECT ausgefhrt. Da eine Unterklasse alle fr sie sichtbaren Attribute ihrer Oberklassen enthlt, deren Inhalt wiederum von Instanzkonstruktoren dieser Klassen gesetzt werden kann, muss der Instanzkonstruktor einer Unterklasse dafr sorgen, dass auch die Instanzkonstruktoren smtlicher Oberklassen ausgefhrt werden.13 Hierfr 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 knnen die privaten Attribute von Oberklassen nur in deren Konstruktoren initialisiert werden.
406
Vererbung
6.2
der Regel, dass Konstruktoren nicht explizit aufgerufen werden knnen. In Oberklassen, in denen der Instanzkonstruktor nicht explizit deklariert und implementiert ist, wird die implizit immer vorhandene Implementierung des Instanzkonstruktors ausgefhrt. Diese sorgt automatisch fr den Aufruf des Instanzkonstruktors der nchsthheren Oberklasse. Vor der Ausfhrung eines Instanzkonstruktors mssen dessen nichtoptionale Eingabeparameter versorgt werden. Diese werden wie folgt gesucht:
Eingabeparameter
Versorgung bei CREATE OBJECT Ausgehend von der Klasse des erzeugten Objekts, wird der erste explizit definierte Instanzkonstruktor im zugehrigen 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 zugehrigen Pfad des Vererbungsbaums gesucht.
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 knnen versorgt werden. Nicht-optionale Eingabeparameter mssen 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 nchstmgliche explizite Instanzkonstruktor betrachtet und, falls vorhanden, dessen Schnittstelle versorgt werden. Beim Arbeiten mit Unterklassen mssen Sie also den gesamten Pfad des Vererbungsbaums gut kennen, da es durchaus passieren kann, dass
Vererbungsbaum
407
beim Erzeugen eines Objekts einer Unterklasse, die im Vererbungsbaum weit unten liegt, Parameter an den Konstruktor einer viel nher zum Wurzelknoten hin liegenden Oberklasse bergeben werden mssen. Der Instanzkonstruktor einer Unterklasse wird durch den von der Syntax geforderten Aufruf super->constructor( ... ) in zwei Teile zerlegt. In den Anweisungen vor dem Aufruf verhlt sich der Konstruktor wie eine statische Methode. Dort hat er keinen Zugriff auf die Instanzattribute seiner Klasse. Erst nach dem Aufruf knnen auch Instanzattribute adressiert werden.
3-Phasen-Modell
Die Ausfhrung eines Instanzkonstruktors einer Unterklasse lsst 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 ausfhren:
Phase 1 Hier knnen Vorbereitungen fr den Aufruf des Instanzkonstruktors der Oberklasse getroffen werden wie die Bestimmung von Aktualparametern fr dessen Schnittstelle. Phase 2 In dieser Phase wird der Instanzkonstruktor der Oberklasse ausgefhrt, der falls implementiert wieder in drei Phasen abluft. Phase 3 Die Attribute der Oberklassen sind jetzt richtig initialisiert. Mit diesen Werten knnen die ntigen Initialisierungen fr die eigenen Instanzattribute vorgenommen werden.
408
Vererbung
6.2
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 hchsten Oberklasse, deren Instanzattribute adressiert werden knnen. Bei der Rckkehr in die Konstruktoren der darunter liegenden Unterklassen knnen 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 Selbstreferenz
409
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
Vererbung
6.2
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 knnen das Verhalten des Programms am besten nachvollziehen, wenn Sie es zeilenweise im ABAP Debugger ausfhren.
Statische Konstruktoren Jede Klasse hat einen statischen Konstruktor namens class_
constructor. Bezglich des Namensraums entlang eines Vererbungs-
baums gilt fr den statischen Konstruktor das Gleiche wie fr den Instanzkonstruktor. Bei der ersten Ansprache einer Unterklasse in einem Programm wird ihr statischer Konstruktor ausgefhrt. Zuvor mssen aber die vorhergehenden statischen Konstruktoren des gesamten Vererbungsbaums ausgefhrt worden sein. Da ein statischer Konstruktor nur ein einziges Mal whrend der Ausfhrung eines Programms aufgerufen werden soll, wird bei erster Ansprache einer Unterklasse nach der nchsthheren Oberklasse gesucht, deren statischer Konstruktor noch nicht ausgefhrt wurde. Dann wird erst deren statischer Konstruktor ausgefhrt und danach sukzessive der aller folgenden Unterklassen bis zur angesprochenen Unterklasse. Im Unterschied zu Instanzkonstruktoren muss ein statischer Konstruktor hierfr nicht explizit den statischen Konstruktor seiner Oberklasse aufrufen. Stattdessen sorgt die Laufzeitumgebung automatisch dafr, dass die statischen Konstruktoren in der richtigen Reihenfolge aufgerufen
Aufruf
411
werden. Sie knnen 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 smtlicher 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 Zustze CREATE PUBLIC|PROTECTED|PRIVATE der Anweisung CLASS bzw. die entsprechenden Einstellungen des Class Builder steuern fr 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 unabhngig von der Oberklasse steuern. Geschtzt instanzierbare Oberklasse Der Instanzkonstruktor der Oberklasse ist in Unterklassen sichtbar. Wenn bei einer Unterklasse die Instanzierbarkeit nicht explizit festgelegt ist, erbt sie die geschtzte Instanzierbarkeit der Oberklasse. Die Instanzierbarkeit einer Unterklasse kann explizit auf eine der drei Arten festgelegt werden. Eine Unterklasse kann die Sichtbarkeit ihres eigenen Instanzkonstruktors unabhngig von der Oberklasse steuern und damit auch den geschtzten Instanzkonstruktor der Oberklasse im angegebenen Bereich verffentlichen. Privat instanzierbare Oberklasse Der Instanzkonstruktor der Oberklasse ist nur in der Oberklasse sichtbar. Dabei sind zwei Flle zu unterscheiden:
412
Interfaces
6.3
Unterklasse ist kein Freund der Oberklasse Da niemand auer 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 Verffentlichung des Oberklassenkonstruktors im angegebenen Bereich bedeuten wrde. 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 verffentlichen.
Private Oberklasse
Wenn in einem Pfad des Vererbungsbaums eine Oberklasse fr die private Instanzierbarkeit definiert wurde, kann also keine Unterklasse von ueren 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 fr 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 beschrnkt wird.
6.3
Interfaces
Interfaces in ABAP Objects sind eigenstndige Schnittstellen von Klassen.
413
6.3.1
Schnittstelle
Grundlagen
Der einzige fr einen Verwender relevante Teil einer Klasse ist ihre ffentliche Schnittstelle, die durch die Komponenten ihres ffentlichen Sichtbarkeitsbereichs aufgebaut ist. Alle anderen Komponenten sind fr 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 knnen. Da ABAP Objects keine Mehrfachvererbung untersttzt, beschrnkt sich die Verwendung von abstrakten Klassen zur Definition von Schnittstellen aber ausschlielich auf ihre Unterklassen. Es ist aber durchaus wnschenswert, auch allgemein gltige Schnittstellen definieren zu knnen, die gleichberechtigt in mehreren Klassen verwendbar sind. Solche Schnittstellen werden durch Interfaces verwirklicht. Interfaces sind eigenstndig definierbare Schnittstellen ohne Implementierung, die in Klassen eingebunden und dort implementiert werden knnen. Interfaces dienen einer loseren Kopplung zwischen einer Klasse und einem Verwender, da sie eine zustzliche Zugriffsschicht (Protokoll) zur Verfgung stellen. Dabei sind zwei Szenarien mglich:
Keine Mehrfachvererbung
Entkopplung
Eine Klasse stellt ihre ffentliche Schnittstelle dem Verwender ganz oder teilweise in einem oder mehreren Interfaces zur Verfgung und entkoppelt ihn damit von der eigentlichen Klassendefinition. Jedes Interface beschreibt einen eigenstndigen 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 mchte, und definiert ein Interface mit smtlichen von ihm gewnschten Komponenten. Jede Klasse, die diese Aufgabe erfllen will, verwendet das Interface und stellt die Funktionalitt zur Verfgung.
BAdI
Ein sehr schnes Anwendungsbeispiel fr 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
Interfaces
6.3
eigentliche Funktionalitt eines BAdI wird aber erst in Folgesystemen durch die Verwendung des Interface in Klassen und deren Implementierung zur Verfgung gestellt.14 Da Interfaces nur Schnittstellen ohne Implementierung sind, knnen 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. Hierfr dienen spezielle Interfacereferenzvariablen. Diese knnen auf Objekte aller Klassen zeigen, die ihr Interface enthalten. Da beliebige Klassen das gleiche Interface einbinden knnen, 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 ueren Verwendern abgetrennten Inneren sind Interfaces sozusagen leere Schalen, die von Klassen statt ihrer eigenen Schalen oder als Teile ihrer eigenen Schalen verwendet werden knnen.15
INTERFACE if_serializable. METHODS serialize ... ... ENDINTERFACE. INTERFACE if_writeable. METHODS write_list ... ... ENDINTERFACE.
Interfacereferenzvariablen
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 groe 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
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. Whrend eine Klasse alle Aspekte einer Klasse beschreibt, beschreibt ein Interface nur einen Teilaspekt. Wie schon gesagt, knnen Interfaces als spezielle abstrakte Klassen ohne Implementierung angesehen werden, fr die eine Mehrfachverwendung mglich ist. Dementsprechend unterscheidet sich die Deklaration eines Interface kaum von der einer Klasse. Wie bei Klassen unterscheiden wir auch globale und lokale Interfaces, fr deren Verwendbarkeit das Gleiche wie fr globale und lokale Klassen gilt: Globale Interfaces knnen in jedem Programm verwendet werden, dessen Paketzuordnung dies erlaubt. Lokale Interfaces knnen 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 knnen exakt die gleichen Komponenten wie Klassen enthalten. Im Unterschied zu Klassen mssen Interfaces aber nicht in verschiedene Sichtbarkeitsberei-
416
Interfaces
6.3
che unterteilt werden, da Interfacekomponenten immer nur in den ffentlichen Sichtbarkeitsbereich von Klassen eingebunden werden. Um ein globales Interface anzulegen, verwenden Sie wie fr globale Klassen den Class Builder. Im Object Navigator whlen Sie Anlegen Klassenbibliothek Interface. In der Transaktion SE24 whlen Sie nach der Auswahl von Anlegen den Objekttyp Interface statt Klasse aus.16 Abbildung 6.7 zeigt den Class Builder fr ein globales Interface ZIF_ DRIVE_OBJECT. Sie sehen die von Klassen gewohnte Oberflche. 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 knnen.
Class Builder
Abbildung 6.7 Globales Interface
Der Class Builder generiert die zugehrigen 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
kann ein Interface-Pool auer 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 fr 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 vollstndig deklariert, jedoch nicht implementiert. hnlich wie die Unterklassen abstrakter Klassen deren abstrakte Methoden implementieren, mssen 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 fr 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 wrden solche Deklarationen nichts nutzen. In Class-Pools sind sie mglich, 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 knnen auch statische Methoden ohne Implementierung definiert werden. Dies ist in abstrakten Klassen nicht mglich, da statische Methoden nicht redefinierbar sind.
418
Interfaces
6.3
Die Syntax zur Implementierung von Interfaces ist:

CLASS class DEFINITION. PUBLIC SECTION. INTERFACES: intf1, intf2 ... ... ... ENDCLASS.
INTERFACES
Interfaces werden also mit der Anweisung INTERFACES im ffentlichen Sichtbarkeitsbereich einer Klasse eingebunden. In den ffentlichen Sichtbarkeitsbereich einer globalen Klasse knnen 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 gelscht und das Interface ZIF_DRIVE_OBJECT aus Abbildung 6.7 angegeben. In den Spalten Abstrakt und Final knnen 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 ausgedrckt. 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 ... intf~comp
419
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 knnen ebenfalls gleichnamige Komponenten enthalten. Alle liegen in einem Namensraum und werden in der Klasse durch unterschiedliche Prfixe 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. Fr jede einzelne Methode kann in der Detailsicht (siehe Abbildung 6.5) eingestellt werden, ob sie abstrakt oder final sein soll. Die INTERFACESAnweisung hat dafr die optionalen Zustze ABSTRACT METHODS und FINAL METHODS. Ansonsten kann eine Interfacemethode in einer Klasse aber nicht mehr gendert werden. Bei Interfaceattributen ist es hnlich. Die einzige Eigenschaft, die beim Einbinden in eine Klasse gendert werden kann, ist der Startwert (Zusatz DATA VALUES zu INTERFACES). Eine Klasse muss smtliche konkreten (nicht-abstrakten) Methoden aller eingebundenen Interfaces in ihrem Implementierungsteil implementieren. Im Class Builder geschieht dies wie blich durch Auswahl von Quelltext fr jede Interfacemethode. In der Klasse ZCL_ VEHICLE_WITH_INTF haben wir im Wesentlichen die Methodenimplementierungen von ZCL_VEHICLE bernommen (siehe Listing 6.10).
420
Interfaces
6.3
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 ausschlielich Interfaces einbindet, wird die gesamte ffentliche Schnittstelle der Klasse durch Interfaces definiert, und die Begriffe Interface und uere Schnittstelle sind fr die Klasse tatschlich gleichbedeutend. Dies ist in unserer Beispielklasse ZCL_VEHICLE_WITH_INTF der Fall. Die bisher durch eigene Komponenten der Klasse aufgebaute Schnittstelle nach auen wurde vollstndig 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 knnte 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
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 knnen 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 knnte man versucht sein, die Interfacekomponenten eines Objekts wie folgt anzusprechen:
... cref->intf~comp ...
Das funktioniert tatschlich. Sie knnen es mit unserer Klasse ZCL_ VEHICLE_WITH_INTF ausprobieren. Diese Art des Zugriffs ist aber nicht besonders schn. Der uere Verwender einer Klasse soll auf eine Schnittstelle mit einfachen Komponenten zugreifen knnen, ohne sich um die technische Zusammensetzung der Schnittstelle kmmern zu mssen. 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
Interfaces
6.3
obigem Zugriff. Kurz gesagt, der Interfacekomponentenselektor sollte nur innerhalb von Klassen (und Interfaces, siehe Abschnitt 6.3.6) verwendet werden. Fr den Zugriff auf Interfacekomponenten in Objekten enthlt ABAP Objects Interfacereferenzvariablen. Dabei handelt es sich um Objektreferenzvariablen, die mit Bezug auf ein Interface deklariert werden:
DATA ref TYPE REF TO intf. Interfacereferenzvariable
Eine Interfacereferenzvariable kann auf die Objekte smtlicher Klassen zeigen, die das Interface intf implementieren. Mit einer solchen Referenzvariablen knnen alle Komponenten des Interface eines Objekts direkt ber
... iref->comp ...
angesprochen werden. Im Gegensatz zu cref->intf~comp drckt 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, hinzugefgt 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
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 knnen 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 Fllen gengt 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 bentigen aber nicht unbedingt eine Klassenreferenzvariable fr die Objekterzeugung. Voraussetzung ist nur, dass die Klasse class (oder eine ihrer Oberklassen) das Interface intf enthlt.
Verwendersicht
Ein Verwender von Objektreferenzvariablen arbeitet in der Regel mit Objekten, ohne sich um die Details ihrer Implementierung kmmern zu mssen. 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 ausschlielich mit solchen Objektreferenzvariablen, die alle mit Bezug auf unser Beispielinterface ZIF_DRIVE_OBJECT angelegt werden. Hierfr 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 enthlt, die Methoden aber spezifisch implementiert, indem die
424
Interfaces
6.3
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 angehngt. Dann wird diese Tabelle an die Methode output bergeben, wo Zeile fr Zeile die Interfacemethode show_speed ausgefhrt 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
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 vllig neue Qualitt. Die interne Tabelle ist wie dort eine Sammlung von Zeigern auf Objekten. Da es sich aber um Interfacereferenzvariablen handelt, knnen 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 fr den oben erwhnten 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 tatschliche Implementierung spielt fr sie keine Rolle. Dies entspricht genau dem Konzept der Polymorphie, das in Abbildung 6.14 dargestellt ist und das wir im zugehrigen Abschnitt noch genauer unter die Lupe nehmen werden. Im Moment gengt es, zu sehen, dass syntaktisch absolut identische Methodenaufrufe in einer Schleife zu unterschiedlichen Ausgaben fhren.
426
Interfaces
6.3
6.3.5
Zugriff auf statische Interfacekomponenten
Da Interfaces die gleichen Komponenten wie Klassen enthalten knnen, sind auch statische Komponenten mglich. Auf die statischen Komponenten eines Interface knnen Sie nicht mit dem Namen des Interface und dem Klassenkomponentenselektor zugreifen. Die einzige Ausnahme sind mit CONSTANTS deklarierte Konstanten:
... intf=>const ...
Die statischen Komponenten gehren nmlich 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 knnen. Um instanzunabhngig auf die statischen Komponenten von Interfaces zuzugreifen, mssten Sie den Namen einer implementierenden Klasse und den Interfacekomponentenselektor verwenden:
... class=>intf~comp ...
Dies sollte aus den in Abschnitt 6.3.4 erwhnten Grnden aber die Ausnahme bleiben. Stattdessen sollten implementierende Klassen Aliasnamen (siehe Abschnitt 6.3.7) fr die statischen Komponenten von Interfaces deklarieren und diese damit wie die eigenen statischen Komponenten ber den Klassennamen ansprechbar machen. Natrlich knnen Sie auch immer mit Interfacereferenzvariablen auf statische Komponenten zugreifen, nachdem Sie Objekte von den implementierenden Klassen erzeugt haben.
Aliasnamen
6.3.6
Interfaces zusammensetzen
In Abbildung 6.9 fllt auf, dass der Class Builder fr ein Interface genau wie fr 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
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 enthlt, heit zusammengesetztes oder auch geschachteltes Interface. Ein Interface, das in einem anderen Interface eingebunden ist, heit 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 mglich. Im obigen Beispiel wird das Komponenteninterface intf1 des zusammengesetzten Interface intf2 zu einem Komponenteninterface von intf3. Ein zusammengesetztes Interface enthlt jedes Komponenteninterface genau ein einziges Mal. Obwohl intf1 sowohl direkt als Komponenteninterface von intf3 als auch indirekt ber
428
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 wrde. 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 ursprnglichen 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. Implementierung
429
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 zustzlich zu intf4 eines oder mehrere der brigen Interfaces intf1, intf2 oder intf3 auffhren, ndert sich an den Komponenten und dem Implementierungsteil der Klasse gar nichts, da der Compiler bei einer Klasse wie in zusammengesetzten Interfaces immer dafr sorgt, dass jede Komponente nur einmal vorhanden ist.
Zugriff
Fr den Zugriff auf Objekte, deren Klasse ein zusammengesetztes Interface implementiert, gilt das Gleiche, als wrde 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 hierfr nicht verwendet werden. Er kann aber in einem zusammengesetzten Interface verwendet werden, um die Komponenten von Komponenteninterfaces wie eigene Komponenten zugnglich zu machen.
6.3.7
Aliasnamen fr Interfacekomponenten
Der vollstndige Name einer Komponente, die durch ein Interface zu einer Klasse oder einem anderen Interface hinzugefgt wird, lautet intf~comp. Fr 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 knnen also beim Implementieren von Interfaces im Deklarationsteil einer Klasse oder beim Zusammensetzen von Inter-
430
Interfaces
6.3
faces in der Deklaration eines Interface vergeben werden. Im Class Builder knnen Sie Aliasnamen fr Klassen wie fr Interfaces auf der Registerkarte Aliases eintragen (siehe Abbildung 6.12).
Abbildung 6.12 Aliasnamen
Aliasnamen in Klassen In Klassen gehren Aliasnamen zum Namensraum der Komponenten einer Klasse und mssen dort, wie die anderen Komponenten auch, einem Sichtbarkeitsbereich zugeordnet werden. Die Sichtbarkeit eines Aliasnamens von auerhalb 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 hierfr wie fr ZCL_VEHICLE_WITH_INTF (siehe Abbildung 6.12) einen Aliasnamen accelerate fr 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
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 fr die Objekterzeugung ohnehin bekannt sein mssen, 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 gendert.
432
Interfaces
6.3
Eine Klasse kann mit Aliasnamen ihre Interfacekomponenten sozusagen als klassenspezifische Komponenten verffentlichen. Insbesondere knnen 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 mssen 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 htten diese nderung direkt in ZCL_ VEHICLE vorgenommen. Smtliche Verwender wren syntaktisch inkorrekt geworden. Durch die gleichzeitige Einfhrung von Aliasnamen wre die Klasse aber unverndert ansprechbar geblieben.
Aliasnamen in zusammengesetzten Interfaces Da in zusammengesetzten Interfaces keine Verkettungen von Namen mglich sind, stellen Aliasnamen in Komponenteninterfaces die einzige Mglichkeit dar, solche Komponenten zu adressieren, die im zusammengesetzten Interface sonst nicht zur Verfgung stnden. 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 wre das nicht mglich, da die Bezeichnung intf2~intf1~m1 nicht erlaubt ist. Jetzt kann
433
ein Verwender von intf3 auf die Komponente meth1 in intf1 zugreifen, ohne etwas ber die Zusammensetzung des Interface wissen zu mssen:
DATA i_ref TYPE REF TO intf3. ... i_ref->meth1( ... ).
Ohne Aliasnamen in intf3 msste der Zugriff wie folgt aussehen:

i_ref->intf1~meth1( ... ).
Der Verwender msste 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 heien wie die Originalnamen.
6.3.8
Interfaces und Vererbung
Zum Abschluss unserer Beschreibung von Interfaces wollen wir noch kurz auf das Verhltnis von Interfaces zur Vererbung eingehen und beide Konzepte nochmals zusammenfassend gegenberstellen. Die Konzepte von Interfaces und Vererbung sind unabhngig voneinander und vollstndig miteinander vertrglich. In den Klassen eines Vererbungsbaums knnen 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 knnen in Unterklassen redefiniert werden. Interfacemethoden knnen zwar in der Deklaration des Interface nicht als abstrakt oder final gekennzeichnet werden, jede Klasse kann dies aber bei der Implementierung des Interface fr sich festlegen.
Kopplung
Der Einsatz von Vererbung ist immer sinnvoll, wenn unterschiedliche Klassen in einer Generalisierungs-/Spezialisierungsbeziehung
434
Interfaces
6.3
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 knnen. Der groe Nutzen der Vererbung ist, dass die Unterklassen alle bereits in der Oberklasse programmierten Eigenschaften bernehmen und damit wieder verwenden. Gleichzeitig besteht dadurch eine uerst enge Kopplung zwischen Ober- und Unterklassen. Eine Unterklasse hngt stark von ihren Oberklassen ab, da sie in der Regel zum Groteil 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 smtliche Unterklassen. Umgekehrt knnen 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 smtliche Klassen eines Pfads des Vererbungsbaums ein sinnvolles Ganzes ergeben. Eher gefhrlich ist es dagegen, sich einfach durch Definition einer Unterklasse an irgendeine Oberklasse anzuhngen, wenn sie nicht zum gleichen Paket gehrt 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 zustzliche Schicht eingefhrt, die den Verwender von einer expliziten Klasse entkoppelt und dadurch viel unabhngiger macht. Interfaces erlauben es dem Verwender, mit verschiedensten Klassen uniform umzugehen, ohne dass die Klassen gleichzeitig miteinander gekoppelt sein mssen. In der objektorientierten Modellierung bieten Interfaces eine von Klassen unabhngige Abstraktion an: Unabhngig von der tatschlichen Implementierung knnen die Dienstleistungen beschrieben werden, die ein Verwender braucht. Zudem realisieren Interfaces gewissermaen auch einen Aspekt der Mehrfachvererbung, da mehrere Interfaces in einer Klasse implementiert werden knnen. Wenn eine Programmierspra19 Ein vollstndiges Paketkonzept, das es erlaubt, solche Angaben in der Paketschnittstelle vorzugeben und zu berprfen, wird aber erst im kommenden Release verwirklicht.
Entkopplung
435
che eine echte Mehrfachvererbung zulsst, wird Mehrfachvererbung in der Regel auch nur im Sinn von Interfaces verwendet. Das heit, nur abstrakte Klassen mit ausschlielich abstrakten Methoden kommen als verschiedene Oberklassen einer einzigen Unterklasse in Frage. Ansonsten wrde 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 nachtrgliche nderungen an Interfaces smtliche Klassen, die das Interface implementieren, syntaktisch inkorrekt machen knnen.
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 knnen 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 nher 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 fr Referenzvariablen, nmlich 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
Index
#EC erweiterte Programmprfung 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 Allgemeiner Berichts Aufbereitungs Prozessor 23 Anforderungen 30 klassisch 489 Programmiermodelle 490 ABAP Debugger klassisch 1036 konfigurieren 1039 neu 1036 Oberflche 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-Schlsselwortdokumentation 148 ABAP-Laufzeitanalyse Werkzeug 1068 ABAP-Laufzeitumgebung AS ABAP 153, 161 Virtual Machine 94
A
A Nachrichtentyp 732 ABAP Advanced Business Application Programming 23
1107
Index
ABAP-Programm aktivieren 94 anlegen 87 Aufbau 163 aufrufen 167 ausfhren 94, 166 kopieren 97 laden 167, 189 Modularisierung 198 testen 1023 Typ 170 ABAP-Prozessor AS ABAP 158 ABAP-Schlsselwortdokumentation 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 Abwrtskompatibilitt ABAP 38, 489 ABAP Objects 195 acos Gleitpunktfunktion 313 ADD ABAP-Anweisung 311
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
1108
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 ausfhren 932 Verwendung 923
arithmetischer Ausdruck Rechenausdruck 311 AS Application Server 152 AS ABAP Application Server ABAP 24, 153 System 184 Trial Version 38, 51 Verfgbarkeit 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
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 ausfhrbares Programm ABAP-Laufzeitumgebung 492 aufrufen 168 ausfhren 491 Programmtyp 172 Verwendung 501 Ausgabefeld Selektionsbild 685 Ausgabeparameter Ereignis 461 Formalparameter 375 Funktionsbaustein 510 Auslieferungsklasse Datenbanktabelle 73 Ausnahme abfangen 529 auslsen 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 Aufrumarbeiten 534 durchfhren 102
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 Berechtigungsprfung 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
1110
Index
Barrierefreiheit Produktstandard 719 BEGIN OF TYPES/DATA 266 Beispielbibliothek ABAP-Schlsselwortdokumentation 150 Benutzerdialog anlegen 106 entkoppeln 106 Benutzermen SAP Easy Access 57 Benutzerschnittstelle AS ABAP 155 Benutzersitzung Applikationsserver 187 Benutzungsoberflche ABAP 559 Berechtigung Berechtigungsprfung 861 prfen 861 Berechtigungsgruppe Berechtigungsprfung 863 Berechtigungsobjekt Berechtigungsprfung 860 Berechtigungsprofil Berechtigungsprfung 861 Berechtigungsprfung AS ABAP 860 Beschreibungsfunktion Funktion 313 BETWEEN Prdikat 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 Bltterleiste 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 Bndelung SAP LUW 812 Business Key Objektidentitt 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
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
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 regulrer Ausdruck 339 CL_ABAP_MEMORY_AREA Shared Objects 479 CL_ABAP_REGEX regulrer 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
1112
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
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
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
1114
Index
DATA BUFFER Daten-Cluster 855 Datei Applikationsserver 846 lesen 847 lschen 848 ffnen 846 Prsentationsserver 851 schlieen 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 einfgen oder ndern 807 Zeile lschen 808 Zeilen einfgen 805 Datenbank-View ABAP Dictionary 773 auslesen 792 Daten-Cluster ablegen 855 AS ABAP 855 einlesen 857 lschen 857 Datendeklaration durchfhren 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
Index
Datentyp ABAP Dictionary 254, 273 ABAP-Typenhierarchie 250 Datenobjekt 249 definieren 253 Domne 79 eigenstndig 253 elementar 257 gebunden 253 generisch 258 global 254, 273 Klasse 216 Klasse/Interface 254 lokal 124 programmlokal 255 Typgruppe 255 Verwendung 256 Datenbertragung AS ABAP 918 Datenverarbeitung betriebswirtschaftlich 30 Datenwurzel Simple Transformation 1013 Datumsfeld berechnen 315 Datenobjekt 258, 261 Gltigkeit 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
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
1116
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 ausfhren 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 Domne ABAP Dictionary 279 anlegen 79, 279 Datenelement 78 Domnenpflege 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 Eingabeberprfung 595 Feld 578 Funktionsgruppe 607
1117
Index
Nummer 572 Prozess 499 prfen 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 Datenbergabe 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
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 Eingabeberprfung automatisch 595 definieren 597, 598 Nachricht 731 Selektionsbild 691 Eingebauter Typ Datenelement 78 eingebauter Typ ABAP Dictionary 276 ABAP-Programm 257 Einrckung 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
1118
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 Entwicklerschlssel 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 auslsen 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
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 Domne 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
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 Fremdschlssel Datenbanktabelle 86 Fremdschlsselbeziehung Datenbanktabelle 770 Freund Klasse 205 Freundschaft Klasse 205 FRIENDS CLASS 205
1120
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 geschtzt Sichtbarkeitsbereich 201 Vererbung 395 geschtzt instanzierbar Oberklasse 412 geschtzter Bereich TRY-Block 529 GET Ereignis 493 GET DATASET ABAP-Anweisung 848 GET REFERENCE ABAP-Anweisung 883
1121
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 berprfung 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 Objektidentitt 840
GUI-Status ABAP-Programm 566 Beispiel 615 Funktionen 584 klassische Liste 712 prfen 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 ausfhrbares Programm 491, 700 einplanen 704 tRFC 938 Hostvariable Native SQL 823 HTML Oberflche 733 HTML GUI SAP GUI 562 HTTP(S) Protokoll 957
1122
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 Prdikat 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
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-Schlsselwortdokumentation 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
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
1124
Index
interne Tabelle ABAP Dictionary 281 ndern 361 anhngen 357 asXML 1007 Datenobjekt 101 deklarieren 270 Eigenschaften 346 einfgen 355 generisch 352 Gruppenstufenverarbeitung 361 Initialwert 311 JCo 955 Kurzform 352 Laufzeitmessung 350 lesen 357 lschen 362 RFC API 945 Schleife 359 sortieren 363 bergeben 365 verdichtet einfgen 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 Prdikat 323 IS BOUND logischer Ausdruck 890 Prdikat 323
IS INITIAL Prdikat 323 IS NULL WHERE-Klausel 787 IS SUPPLIED Prdikat 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 Parameterbergabe 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
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 Jobbersicht Hintergrundverarbeitung 702 JOIN SELECT 793 Join FROM-Klausel 793 verknpfen 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
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 ausfhrbares 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 Kompatibilittsmodus Transaktionsdienst 844
1126
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-Schlsselwortdokumentation 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 schlieend 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
Index
LINES OF APPEND 357 INSERT itab 356 Linie klassische Liste 706 Selektionsbild 685 Liste ABAP Objects 719 ALV-Liste 720 ausfhrbares 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
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
1128
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 Menleiste 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
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
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
1130
Index
erzeugen 138 Objektorientierung 369 reale Welt 191 Software 192 Objektidentitt 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-/Lngenangabe 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
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 Paketprfung Paket 70 Paketschnittstelle Paket 70 berprfung 65 Pakettyp Paket 67 Parallelverarbeitung aRFC 933 Parameter Selektionsbild 675 PARAMETERS ABAP-Anweisung 675 Parameterschnittstelle ausfhrbares Programm 700
Ausnahme 536 Ereignis 461 Funktionsbaustein 509 Methode 210, 212 Unterprogramm 517 PARAMETER-TABLE CALL FUNCTION 910 CALL METHOD 907 Parametertransaktion Dialogtransaktion 498 Parameterbergabe 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 lschen 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
1132
Index
semantische Regeln 452 Verwendung 452 Pop-up-Level Container-Control 648 POSITION ABAP-Anweisung 705 POSIX-Standard regulrer Ausdruck 335 POV PROCESS ON VALUE-REQUEST 564 Prdikat logischer Ausdruck 322 WHERE-Klausel 787 Prsentationslogik Verschalung 107 Prsentationsschicht AS ABAP 155 Prsentationsserver SAP GUI 562 Pretty Printer ABAP Editor 90 Primrindex Datenbanktabelle 788 Primrschlssel 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 Programmprfung 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 Prfkennzeichen Berechtigungsprfung 862
1133
Index
Prftabelle Dynpro 596 Eingabehilfe 601 Fremdschlssel 87 Prfvariante Code Inspector 1032 Pseudokommentar erweiterte Programmprfung 1030 Publish-and-Subscribe Ereignis 460
Q
qRFC API 940 ausfhren 939 queued RFC 924 RFC API 947 Szenarien 925 qRFC-Manager qRFC 940 Qualittsmanagement 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
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
1134
Index
Referenzbergabe 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 regulrer Ausdruck Klasse 339 Sonderzeichen 336 suchen/ersetzen 335 Remote Function Call AS ABAP 160 RFC 921 remotefhiger 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 ausfhrbares 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
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 Parameterbergabe 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 Rckgabewert 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
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 Schaltflche Web Dynpro ABAP 755
1136
Index
Schleife bedingt 328 durchfhren 138 interne Tabelle 360 Kontrollstruktur 327 unbedingt 327 Schlsselattribut persistente Klasse 828 Schlsselwort ABAP-Anweisung 90 Schlsselzugriff 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 Sekundrindex 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
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-fhig 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
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
1138
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 ausfhren 931 synchroner RFC 922 ST Simple Transformations 1009 ST22 Transaktion 555
STANDARD TABLE TYPES/DATA 270, 347 standard table generischer Typ 288 Standardschlssel interne Tabelle 351 Standardselektionsbild anlegen 697 ausfhrbares 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
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
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 prfen 1026 Syntaxbereinigung ABAP Objects 28, 196 Syntaxdiagramm ABAP-Schlsselwortdokumentation 147 Syntaxfehler ABAP-Programm 93 Syntaxprfung 1026 Syntaxkonvention Verwendung 50 Syntaxprfung ABAP-Programm 93 Syntaxwarnung Syntaxprfung 1026 SYST Struktur 296
1140
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 Tabellenschlssel 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 blttern 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
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
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 ausfhren 141, 169 Programmausfhrung 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 transaktionsbergreifender Anwendungspuffer Daten-Cluster 856 TRANSFER ABAP-Anweisung 847
1142
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 ausfhren 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 berprfen 380 Unterprogrammparameter 517 vollstndig 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
Index
UNASSIGN ABAP-Anweisung 879 Unicode SAP-System 24 Unicode-Fragmentsicht Struktur 305 Unicode-Programm ABAP-Programm 175 Byte-/Zeichenkettenverarbeitung 331 Unicodeprfungen 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
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
1144
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 vollstndige Typisierung Verwendung 383 Volltextsuche ABAP-Schlsselwortdokumentation 149 Vorwrtsnavigation 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 ausfhren 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
Index
Werkzeugbereich Object Navigator 62 Wertebereich Domne 79, 85 Dynpro 595 Werteliste Dropdown-Listbox 605 Wertesemantik dynamisches Datenobjekt 1060 Feldsymbol 868 Zuweisung 285 Wertbergabe 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 ausfhrbares Programm 707 WRITE TO ABAP-Anweisung 309 WSADMIN Transaktion 983 WSCONFIG Transaktion 981 WSDL Web Services Description Language 973
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
1146
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 Gltigkeit 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

Sappress Abap Objects 358 PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Sappress Abap Objects 358 PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Horst Keller, Sascha Krger

Auf einen Blick

Die Autoren .............................................................................. 1103 Index ........................................................................................ 1107

Eine praktische Einfhrung ................................................

Klassen und Objekte ..........................................................

231 232 234 237 238 238 239 240 243

Grundlegende ABAP-Sprachelemente ...............................

345 346 354

Weiterfhrende Konzepte von ABAP Objects ..................

6.6.3 6.6.4 6.6.5 6.6.6

475 478 479 485

Klassisches ABAP Ereignisse und Prozeduren ................

GUI-Programmierung mit ABAP ........................................

10 Arbeiten mit persistenten Daten .......................................

11 Dynamische Programmierung ............................................

910 912 915

12 Externe Schnittstellen ........................................................

13 Test- und Analysewerkzeuge ............................................. 1023

A Anhang ............................................................................... 1077

A.2 A.3 A.4 A.5 A.6 A.7 A.8

Die Autoren ........................................................................................... 1103 Index ...................................................................................................... 1107

Weiterfhrende Konzepte von ABAP Objects

Weiterfhrende Konzepte von ABAP Objects

Weiterfhrende Konzepte von ABAP Objects

Weiterfhrende Konzepte von ABAP Objects

Methodenschnittstellen und Methodenaufrufe

Methodenschnittstellen und Methodenaufrufe

Parameterschnittstelle von Methoden

Weiterfhrende Konzepte von ABAP Objects

Parameterart Sie knnen folgende Parameter definieren:

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

oder gleichbedeutend auch

Die Syntax fr die Wertbergabe am Beispiel des Rckgabewerts return ist:

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Performance vs. Robustheit

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Methodenschnittstellen und Methodenaufrufe

Weiterfhrende Konzepte von ABAP Objects

Weiterfhrende Konzepte von ABAP Objects

CLASS c1 DEFINITION [INHERITING FROM object].

CLASS c2 DEFINITION [INHERITING FROM object].

CLASS c11 DEFINITION INHERITING FROM c1.

CLASS c12 DEFINITION INHERITING FROM c1.

Abbildung 6.1 Vererbungsbaum in ABAP Objects

Weiterfhrende Konzepte von ABAP Objects

CLASS subclass DEFINITION INHERITING FROM superclass. ... ENDCLASS.

Abbildung 6.2 Vererbung im Class Builder

Weiterfhrende Konzepte von ABAP Objects

truck_ref->unload( ). ENDMETHOD. ENDCLASS. START-OF-SELECTION. demo=>main( ).

Sichtbarkeitsbereiche und Namensrume in der Vererbung

In den Sichtbarkeitsbereichen einer Unterklasse sind also folgende Komponenten enthalten:

Weiterfhrende Konzepte von ABAP Objects

Abbildung 6.3 Redefinition einer geerbten Methode

Weiterfhrende Konzepte von ABAP Objects