Beispiel zu Methoden in ABAP Objects
Das folgende Beispiel zeigt die Deklaration, Implementierung und Verwendung von Methoden in ABAP Objects.
Überblick
Das Beispiel arbeitet mit drei Klassen namens C_TEAM, C_BIKER und C_BICYCLE. Ein Verwender (ein Programm) kann Objekte der Klasse C_TEAM erzeugen. Über ein Selektionsbild fragt die Klasse C_TEAM nach der Anzahl von Mitgliedern pro Team.
Jedes Objekt der Klasse C_TEAM kann entsprechend der Anzahl von Mitgliedern pro Team Instanzen der Klasse C_BIKER erzeugen. Jede Instanz der Klasse C_BIKER erzeugt wiederum eine Instanz der Klasse C_BICYCLE.
Jede Instanz der Klasse C_TEAM kommuniziert über eine interaktive Liste mit dem Programmbenutzer. Der Programmbenutzer kann einzelne Mitglieder eines Teams für Aktionen auswählen. Die Instanzen der Klasse C_BIKER ermöglichen dem Programmbenutzer die Auswahl der Aktion über ein weiteres Selektionsbild.
Einschränkung
Die ABAP-Anweisungen zur Listenverarbeitungen stehen in ABAP-Objects noch nicht in vollem Umfang zur Verfügung. Um einfache Testausgaben zu erstellen, können jedoch folgende Anweisungen verwendet werden:
Beachten Sie, daß insbesondere die Funktionalität von Aufbereitungsoptionen und interaktiver Listenverarbeitung im derzeitigne Zustand nicht garantiert ist und sich zum nächsten Release inkompatibel ändern kann.
Deklarationen
Das Beispiel ist mit lokalen Klassen realisiert, da Selektionsbilder zu einem ABAP-Programm gehören und nicht in globalen Klassen definiert und aufgerufen werden können. Es folgen die Deklarationen der beiden globalen Selektionsbilder und der drei Klassen:
*******************************************************************
* Global Selection Screens
*******************************************************************
SELECTION-SCREEN BEGIN OF: SCREEN 100 TITLE tit1, LINE.
PARAMETERS members TYPE i DEFAULT 10.
SELECTION-SCREEN END OF: LINE, SCREEN 100.
*------------------------------------------------------------------
SELECTION-SCREEN BEGIN OF SCREEN 200 TITLE tit2.
PARAMETERS: drive RADIOBUTTON GROUP actn,
stop RADIOBUTTON GROUP actn,
gearup RADIOBUTTON GROUP actn,
geardown RADIOBUTTON GROUP actn.
SELECTION-SCREEN END OF SCREEN 200.
*******************************************************************
* Class Definitions
*******************************************************************
CLASS: c_biker DEFINITION DEFERRED,
c_bicycle DEFINITION DEFERRED.
*------------------------------------------------------------------
CLASS c_team DEFINITION.
PUBLIC SECTION.
TYPES: biker_ref TYPE REF TO c_biker,
biker_ref_tab TYPE STANDARD TABLE OF biker_ref
WITH DEFAULT KEY,
BEGIN OF status_line_type,
flag(1) TYPE c,
text1(5) TYPE c,
id TYPE i,
text2(7) TYPE c,
text3(6) TYPE c,
gear TYPE i,
text4(7) TYPE c,
speed TYPE i,
END OF status_line_type.
CLASS-METHODS: class_constructor.
METHODS: constructor,
create_team,
selection,
execution.
PRIVATE SECTION.
CLASS-DATA: team_members TYPE i,
counter TYPE i.
DATA: id TYPE i,
status_line TYPE status_line_type,
status_list TYPE SORTED TABLE OF status_line_type
WITH UNIQUE KEY id,
biker_tab TYPE biker_ref_tab,
biker_selection LIKE biker_tab,
biker like LINE OF biker_tab.
METHODS: write_list.
ENDCLASS.
*------------------------------------------------------------------
CLASS c_biker DEFINITION.
PUBLIC SECTION.
METHODS: constructor IMPORTING team_id TYPE i members TYPE i,
select_action,
status_line EXPORTING line
TYPE c_team=>status_line_type.
PRIVATE SECTION.
CLASS-DATA counter TYPE i.
DATA: id TYPE i,
bike TYPE REF TO c_bicycle,
gear_status TYPE i VALUE 1,
speed_status TYPE i VALUE 0.
METHODS biker_action IMPORTING action TYPE i.
ENDCLASS.
*------------------------------------------------------------------
CLASS c_bicycle DEFINITION.
PUBLIC SECTION.
METHODS: drive EXPORTING velocity TYPE i,
stop EXPORTING velocity TYPE i,
change_gear IMPORTING change TYPE i
RETURNING VALUE(gear) TYPE i
EXCEPTIONS gear_min gear_max.
PRIVATE SECTION.
DATA: speed TYPE i,
gear TYPE i VALUE 1.
CONSTANTS: max_gear TYPE i VALUE 18,
min_gear TYPE i VALUE 1.
ENDCLASS.
*******************************************************************
Beachten Sie, daß keine der drei Klassen öffentliche Attribute enthält. Die Zustände der Klassen werden ausschließlich durch ihre Methoden geändert. In der Klasse C_TEAM wird ein statischer Konstruktor CLASS-CONSTRUCTOR deklariert. In C_TEAM und C_BIKER wird jeweils ein Instanzkonstruktor CONSTRUCTOR in C_TEAM und C_BIKER deklariert.
Implementierungen
In den Implementierungsteilen werden alle Methoden implementiert, die in den Deklarationsteilen der entsprechechenden Klasse deklariert worden sind. Die Schnittstellen der Methoden werden schon bei der Deklaration festgelegt. Bei der Implementierung werden die Schnittstellenparameter wie lokale Daten verwendet.
Methoden der Klasse C_TEAM
Folgende Methoden werden zwischen den Anweisungen
CLASS c_team IMPLEMENTATION.
...
ENDCLASS.
implementiert:
CLASS_CONSTRUCTOR
METHOD class_constructor.
tit1 = 'Team members ?'.
CALL SELECTION-SCREEN 100 STARTING AT 5 3.
IF sy-subrc NE 0.
LEAVE PROGRAM.
ELSE.
team_members = members.
ENDIF.
ENDMETHOD.
Der statische Konstruktor wird vor der ersten Verwendung der Klasse C_TEAM in einem Programm ausgeführt. Er ruft das Selektionsbild 100 und setzt das statische Attribut TEAM_MEMBERS auf den entsprechenden Eingabewert. Dieses Attribut hat für alle Instanzen der Klasse C_TEAM den gleichen Wert.
CONSTRUCTOR
METHOD constructor.
counter = counter + 1.
id = counter.
ENDMETHOD.
Der Instanzkonstruktor wird direkt nach der Erzeugung einer Instanz der Klasse C_TEAM ausgeführt. Er dient zum Zählen der Instanzen von C_TEAM in dem statischen Attribut COUNTER und weist jeder Instanz die entsprechende Nummer im Instanzattribut ID zu.
CREATE_TEAM
METHOD create_team.
DO team_members TIMES.
CREATE OBJECT biker EXPORTING team_id = id
members = team_members.
APPEND biker TO biker_tab.
CALL METHOD biker->status_line IMPORTING line = status_line.
APPEND status_line TO status_list.
ENDDO.
ENDMETHOD.
Die öffentliche Instanzmethode CREATE_TEAM kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Sie dient der Erzeugung von Instanzen der Klasse C_BIKER unter Verwendung der privaten Referenzvariablen BIKER der Klasse C_TEAM. In der Anweisung CREATE OBJECT müssen die beiden Eingabeparameter des Instanzkonstruktors der Klasse C_BIKER übergeben werden. Die Referenzen auf die neuerzeugten Instanzen werden an die private interne Tabelle BIKER_TAB angehängt. Nach Ausführung der Methode enthält jede Zeile der internen Tabelle eine Referenz auf eine Instanz der Klasse C_BIKER. Diese Referenzen sind nur innerhalb der Klasse C_TEAM bekannt. Ein äußerer Verwender hat keinen Zufriff auf die Objekte der Klasse C_BIKER.
Zusätzlich ruft CREATE_TEAM die Methode STATUS_LINE in jedem neuerzeugten Objekt auf und hängt deren Ausgabeparameter LINE über den Arbeitsbereich STATUS_LINE an die private interne Tabelle STATUS_LIST.
SELECTION
METHOD selection.
CLEAR biker_selection.
DO.
READ LINE sy-index.
IF sy-subrc <> 0. EXIT. ENDIF.
IF sy-lisel+0(1) = 'X'.
READ TABLE biker_tab INTO biker INDEX sy-index.
APPEND biker TO biker_selection.
ENDIF.
ENDDO.
CALL METHOD write_list.
ENDMETHOD.
Die öffentliche Instanzmethode SELECTION kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Sie selektiert auf der gerade angezeigten Liste alle Zeilen, bei denen das Ankreuzfeld an der ersten Stelle gefüllt ist. Für diese Zeilen werden die zugehörigen Referenzvariablen aus der Tabelle BIKER_TAB in eine weitere private interne Tabelle BIKER_SELECTION geschrieben. Weiterhin ruft die Methode SELECTION die private Methode WRITE_LIST auf, die der Darstellung der Liste dient.
EXECUTION
METHOD execution.
CHECK NOT biker_selection IS INITIAL.
LOOP AT biker_selection INTO biker.
CALL METHOD biker->select_action.
CALL METHOD biker->status_line IMPORTING line = status_line.
MODIFY TABLE status_list FROM status_line.
ENDLOOP.
CALL METHOD write_list.
ENDMETHOD.
Die öffentliche Instanzmethode EXECUTION kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode ruft in jeder Instanz der Klasse C_BIKER, auf die eine Referenz in der Tabelle BIKER_SELECTION zeigt die zwei Methoden SELECT_ACTION und STATUS_LINE auf. Die Tabelle STATUS_LIST wird in der Zeile von dem Arbeitsbereich STATUS_LINE überschrieben, in der der eindeutige Schlüssel ID mit der Komponente ID des Arbeitsbereichs übereinstimmt, und durch Aufruf der privaten Methode WRITE_LIST ausgegeben.
WRITE_LIST
METHOD write_list.
SET TITLEBAR 'TIT'.
sy-lsind = 0.
SKIP TO LINE 1.
POSITION 1.
LOOP AT status_list INTO status_line.
WRITE: / status_line-flag AS CHECKBOX,
status_line-text1,
status_line-id,
status_line-text2,
status_line-text3,
status_line-gear,
status_line-text4,
status_line-speed.
ENDLOOP.
ENDMETHOD.
Die private Instanzmethode WRITE_LIST kann nur in den Methoden der Klasse C_TEAM aufgerufen werden. Die Methode dient der Darstellung der privaten internen Tabell STATUS_LIST auf der Grundliste (SY-LSIND = 0) des verwendenden Programms.
Methoden der Klasse C_BIKER
Folgende Methoden werden zwischen den Anweisungen
CLASS c_biker IMPLEMENTATION.
...
ENDCLASS.
implementiert:
CONSTRUCTOR
METHOD constructor.
counter = counter + 1.
id = counter - members * ( team_id - 1).
CREATE OBJECT bike.
ENDMETHOD.
Der Instanzkonstruktor wird direkt nach der Erzeugung einer Instanz der Klasse C_BIKER ausgeführt. Er dient zum Zählen der Instanzen von C_BIKER in dem statischen Attribut COUNTER und weist jeder Instanz eine daraus abgeleitete Nummer im Instanzattribut ID zu. Der Konstruktor hat zwei Eingabeparameter, TEAM_ID und MEMBERS, die bei der Erzeugung einer Instanz von C_BIKER übergeben werden müssen.
Weiterhin erzeugt der Instanzkonstruktor für jede Instanz der Klasse C_BIKER eine Instanz der Klasse C_BICYCLE. Die Referenz in der privaten Referenzvariablen BIKE jeder Instanz von C_BIKER zeigt auf eine zugehörige INSTANZ der Klasse C_BICYCLE. Kein äußerer Verwender kann auf diese Instanzen der Klasse C_BICYCLE zugreifen.
SELECT_ACTION
METHOD select_action.
DATA activity TYPE i.
tit2 = 'Select action for BIKE'.
tit2+24(3) = id.
CALL SELECTION-SCREEN 200 STARTING AT 5 15.
CHECK NOT sy-subrc GT 0.
IF gearup = 'X' OR geardown = 'X'.
IF gearup = 'X'.
activity = 1.
ELSEIF geardown = 'X'.
activity = -1.
ENDIF.
ELSEIF drive = 'X'.
activity = 2.
ELSEIF stop = 'X'.
activity = 3.
ENDIF.
CALL METHOD biker_action( activity).
ENDMETHOD.
Die öffentlich Instanzmethode SELECT_ACTION kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode sendet das Selektionsbild 200 an den Programmbenutzer und wertet die Eingabe aus. Nach der Auswertung wird die private Methode BIKER_ACTION der gleichen Klasse aufgerufen. Dabei wird deren Formalparameter ACTION mit dem Aktualparameter ACTIVITY in der Kurzschreibweise versorgt.
BIKER_ACTION
METHOD biker_action.
CASE action.
WHEN -1 OR 1.
CALL METHOD bike->change_gear
EXPORTING change = action
RECEIVING gear = gear_status
EXCEPTIONS gear_max = 1
gear_min = 2.
CASE sy-subrc.
WHEN 1.
MESSAGE i315(AT) WITH 'BIKE' id
' is already at maximal gear!'.
WHEN 2.
MESSAGE i315(AT) WITH 'BIKE' id
' is already at minimal gear!'.
ENDCASE.
WHEN 2.
CALL METHOD bike->drive IMPORTING velocity = speed_status.
WHEN 3.
CALL METHOD bike->stop IMPORTING velocity = speed_status.
ENDCASE.
ENDMETHOD.
Die private Instanzmethode BIKER_ACTION kann nur in den Methoden der Klasse C_BIKER aufgerufen werden. Je nach Wert des Eingabeparameters ACTION werden verschieden Methoden in der Instanz der Klasse C_BICYCLE aufgerufen, auf die die Referenz in der Referenzvariablen BIKE zeigt.
STATUS_LINE
METHOD status_line.
line-flag = SPACE.
line-text1 = 'Biker'.
line-id = id.
line-text2 = 'Status:'.
line-text3 = 'Gear = '.
line-gear = gear_status.
line-text4 = 'Speed = '.
line-speed = speed_status.
ENDMETHOD.
Die öffentliche Instanzmethode STATUS_LINE kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode füllt den strukturierten Ausgabeparameter LINE mit den aktuellen Attributwerten der jeweiligen Instanz.
Methoden der Klasse C_BICYCLE
Folgende Methoden werden zwischen den Anweisungen
CLASS c_bicycle IMPLEMENTATION.
...
ENDCLASS.
implementiert:
DRIVE
METHOD drive.
speed = speed + gear * 10.
velocity = speed.
ENDMETHOD.
Die öffentliche Instanzmethode DRIVE kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode ändert den Wert des privaten Attributs SPEED und übergibt ihn über den Ausgabeparameter VELOCITY an den Aufrufer.
STOP
METHOD stop.
speed = 0.
velocity = speed.
ENDMETHOD.
Die öffentliche Instanzmethode STOP kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode ändert den Wert des privaten Attributs SPEED und übergibt ihn über den Ausgabeparameter VELOCITY an den Aufrufer.
CHANGE_GEAR
METHOD change_gear.
gear = me->gear.
gear = gear + change.
IF gear GT max_gear.
gear = max_gear.
RAISE gear_max.
ELSEIF gear LT min_gear.
gear = min_gear.
RAISE gear_min.
ENDIF.
me->gear = gear.
ENDMETHOD.
Die öffentliche Instanzmethode CHANGE_GEAR kann von jedem Verwender der Klasse aufgerufen werden, der eine Referenzvariable mit einer Referenz auf eine Instanz der Klasse enthält. Die Methode ändert den Wert des privaten Attributs GEAR. Da der gleichnamige Formalparameter GEAR das Attribut in der Methode überdeckt, wird das Attribut mit der Selbstreferenz ME->GEAR adressiert.
Verwendung in einem Programm
Das folgende Programm zeigt, wie obige Klassen verwendet werden können. Die Deklarationen der Selektionsbilder und der lokalen Klassen und die Implementierungen der Methoden müssen auch Teil des Programms sein.
REPORT demo_abap_objects_methods NO STANDARD PAGE HEADING.
*******************************************************************
* Declarations and Implementations
*******************************************************************
...
*******************************************************************
* Global Program Data
*******************************************************************
TYPES team TYPE REF TO c_team.
DATA: team_blue TYPE team,
team_green TYPE team,
team_red TYPE team.
DATA COLOR(5) TYPE c.
*******************************************************************
* Program events
*******************************************************************
START-OF-SELECTION.
CREATE OBJECT: team_blue,
team_green,
team_red.
CALL METHOD: team_blue->create_team,
SET PF-STATUS 'TEAMLIST'.
WRITE ' Select a team! ' COLOR = 2.
*------------------------------------------------------------------
AT USER-COMMAND.
CASE sy-ucomm.
WHEN 'TEAM_BLUE'.
color = 'BLUE '.
FORMAT COLOR = 1 INTENSIFIED ON INVERSE ON.
*******************************************************************
Das Programm enthält drei Klassenreferenzvariablen mit Bezug auf die Klasse C_TEAM und erzeugt drei Objekte dieser Klasse, auf die die Referenzen in den Referenzvariablen zeigen, und ruft in jedem der Objekte die Methode CREATE_TEAM auf. Die Methode CLASS_CONSTRUCTOR der Klasse C_TEAM wird vor der Erzeugung des ersten Objekts ausgeführt. Der Status TEAMLIST der Grundliste erlaubt dem Benutzer die Auswahl von vier Funktionen:
Bei einer Benutzeraktion wird das Ereignis AT USER-COMMAND ausgelöst und je nach Auswahl werden öffentliche Methoden in einer der drei Instanzen von C_TEAM aufgerufen. Über die Auswahl von Zeilen in der Statusliste jeder Instanz, kann der Benutzer den Zustand der entsprechenden Objekte verändern.