Erste Schritte

Grundlegende Methoden und Konzepte anwenden

Mit lokalen Klassen arbeiten

Daten aus der Datenbank lesen

Mit strukturierten Datenobjekten arbeiten

Mit komplexen internen Tabellen arbeiten

Datenbankänderungen mit Business Objects implementieren

Das ABAP-RESTful-Anwendungsprogrammiermodell beschreiben

Daten verarbeiten

Objectives

After completing this lesson, you will be able to:

Führen Sie arithmetische Berechnungen durch.
Zeichenkettenverarbeitung anwenden.

Arithmetische Berechnungen

Arithmetische Ausdrücke sind ABAP-Ausdrücke mit einer Kombination aus Werten, Operatoren und Funktionen, die vom Laufzeitsystem verarbeitet werden, um ein Ergebnis zu erzeugen. Bei arithmetischen Ausdrücken hängt der Ergebnistyp vom Typ der Operanden ab, die als Eingabe in den Ausdruck verwendet werden.

Sie können einen arithmetischen Ausdruck an jeder beliebigen Position eines Leseoperanden verwenden, z.B. auf der rechten Seite einer Wertzuweisung.

Das folgende Video veranschaulicht die Grundlagen arithmetischer Ausdrücke.

Probieren Sie es aus: Arithmetische Berechnungen

Legen Sie wie in der ersten Übung dieser Schulung eine neue globale Klasse an, die das Interface IF_OO_ADT_CLASSRUN implementiert.

Kopieren Sie das folgende Code-Snippet in den Implementierungsteil der Methode if_oo_adt_classrun~main( ):

Code Snippet

12345678910111213141516171819202122232425262728293031

* Declarations
**********************************************************************

    " comment/uncomment these line for different result types
    TYPES t_result TYPE p LENGTH 8 DECIMALS 2.
*    TYPES t_result TYPE p LENGTH 8 DECIMALS 0.
*    TYPES t_result TYPE i.

    DATA result TYPE t_result.

* Calculations
**********************************************************************
    " comment/uncomment these lines for different calculations

    result = 2 + 3.
*    result = 2 - 3.
*    result = 2 * 3.
*    result = 2 / 3.
*
*    result = sqrt( 2 ).
*    result = ipow( base = 2 exp = 3 ).
*
*    result = ( 8 * 7 - 6 ) / ( 5 + 4 ).
*   result = 8 * 7 - 6 / 5 + 4.

* Output
**********************************************************************

    out->write( result ).

Drücken Sie STRG + F3, um die Klasse zu aktivieren, und F9, um sie als Konsolen-App auszuführen.
Probieren Sie mit dem Quelltext Verschiedenes aus, um sich mit den Konzepten vertraut zu machen.
- Entkommentieren Sie verschiedene Berechnungen und Typdefinitionen.
- Implementieren Sie eigene Berechnungen.

Stringverarbeitung

Zeichenketten-Templates sind ABAP-Ausdrücke vom Ergebnistyp „string". Sie können Zeichenketten-Templates an jeder beliebigen Position eines Leseoperanden verwenden, z.B. auf der rechten Seite einer Wertzuweisung.

Ein Zeichenketten-Template beginnt und endet mit einem Pipe-Symbol ( | ). Das einfachste Zeichenketten-Template enthält lediglich literalen Text. In dieser Form unterscheidet sich ein Zeichenketten-Template nicht wirklich von einem Stringliteral.

Was ein Zeichenketten-Template von einem Stringliteral unterscheidet, ist die Fähigkeit, Ausdrücke einzubetten. Ein eingebetteter Ausdruck ist ein ABAP-Ausdruck, der von einem Paar geschweifter Klammern ( { und } ) umgeben ist. Zur Laufzeit wertet ABAP den eingebetteten Ausdruck aus und übersetzt das Ergebnis in eine Zeichenkette. Im Endergebnis ersetzt diese Zeichenkette den eingebetteten Ausdruck (zusammen mit den umgebenden geschweiften Klammern).

Notiz

Die ABAP-Syntax erfordert mindestens ein Leerzeichen nach der öffnenden Klammer und mindestens ein Leerzeichen vor der schließenden Klammer.

Natürlich kann ein Zeichenketten-Template mehr als einen eingebetteten Ausdruck enthalten.

Innerhalb der geschweiften Klammern können beliebige ABAP-Ausdrücke platziert werden: arithmetische Ausdrücke, wie im obigen Beispiel, aber einzelne Variablen oder sogar Literale können als eingebettete Ausdrücke dienen.

Ein wichtiger Anwendungsfall für Zeichenketten-Templates ist die kontrollierte Formatierung der Daten für die Ausgabe.

Im ersten Beispiel ist die Variable „the_date" vom Typ D und enthält ein Datum im internen Format (Rohformat) JJJJMMTT (wobei JJJJ für das Jahr, MM für den zweistelligen Monat und TT für das zweistellige Datum steht). Wenn Sie die Variable „the_date" als eingebetteten Ausdruck in einem Zeichenketten-Template verwenden, entspricht das Ergebnis dem internen Format. Wenn Sie jedoch die Formatoption „DATE = <Datumsformat>" innerhalb der geschweiften Klammern hinzufügen, formatiert das System den Wert als Datum. Wenn Sie „DATE = ISO" hinzufügen, erfolgt die Ausgabe im ISO-Format. Mit „DATE = USER" hängt das Ausgabeformat von den Benutzereinstellungen des aktuellen Benutzers ab.

Das zweite Beispiel veranschaulicht einige der Optionen, die Sie für die Formatierung von Zahlen verwenden können. Mit NUMBER steuern Sie die allgemeine Formatierung von Zahlen, z.B., ob ein Dezimalpunkt oder ein Dezimalkomma verwendet wird. Mit SIGN steuern Sie die Position des Vorzeichens und ob ein Pluszeichen (+) angezeigt wird oder nicht. Mit STYLE können Sie aus mehreren vordefinierten Formaten wählen, z.B. einem wissenschaftlichen Format oder einem technischen Format.

Sie können Felder mit dem Verkettungsoperator && verbinden. Sie können eine beliebige Kombination aus Datenobjekten und Zeichenkettenausdrücken verbinden.

Die Bestandteile des Ausdrucks werden ohne Leerzeichen oder Trennzeichen verbunden. Falls Sie Leerzeichen oder ein anderes Trennzeichen benötigen, müssen Sie es selbst, wie im zweiten Beispiel dargestellt, als Teil des Ausdrucks einfügen.

Probieren Sie es aus: Stringverarbeitung

Legen Sie wie in der ersten Übung dieser Schulung eine neue globale Klasse an, die das Interface IF_OO_ADT_CLASSRUN implementiert.

Kopieren Sie das folgende Code-Snippet in den Implementierungsteil der Methode if_oo_adt_classrun~main( ):

Code Snippet

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

 METHOD if_oo_adt_classrun~main.

* Declarations
**********************************************************************
    TYPES t_amount TYPE  p LENGTH 8 DECIMALS 2.

    DATA amount   TYPE t_amount VALUE '3.30'.
    DATA amount1  TYPE t_amount VALUE '1.20'.
    DATA amount2  TYPE t_amount VALUE '2.10'.

    DATA the_date  TYPE d                     VALUE '19891109'.
    DATA my_number TYPE p LENGTH 3 DECIMALS 2 VALUE '-273.15'.

    DATA part1 TYPE string VALUE `Hello`.
    DATA part2 TYPE string VALUE `World`.

* String Templates
**********************************************************************

    " comment/uncomment the following lines for different examples
    DATA(text) = |Hello World|.
*    DATA(text) = |Total: { amount } EUR|.
*    DATA(text) = |Total: { amount1 + amount2 } EUR|.

* Format Options
**********************************************************************

    "Date
*    DATA(text) = |Raw Date: { the_date             }|.
*    DATA(text) = |ISO Date: { the_date Date = ISO  }|.
*    DATA(text) = |USER Date:{ the_date Date = USER }|.

    "Number
*    DATA(text) = |Raw Number { my_number                    }|.
*    DATA(text) = |User Format{ my_number NUMBER = USER      }|.
*    DATA(text) = |Sign Right { my_number SIGN = RIGHT       }|.
*    DATA(text) = |Scientific { my_number STYLE = SCIENTIFIC }|.

* String expression (concatenation Operator)
**********************************************************************

*    DATA(text) = part1 && part2.
*    DATA(text) = part1 && | | && part2.
*    DATA(text) = |{ amount1 } + { amount2 }| &&
*                 | = | &&
*                 |{ amount1 + amount2 }|.


* Output
**********************************************************************

    out->write( text ).

Drücken Sie STRG + F3, um die Klasse zu aktivieren, und F9, um sie als Konsolen-App auszuführen.
Probieren Sie mit dem Quelltext Verschiedenes aus, um sich mit den Konzepten vertraut zu machen.
- Entkommentieren Sie unterschiedliche Wertzuweisungen für die inline deklarierte Variable text, um ein anderes Ergebnis anzuzeigen.
- Probieren Sie eigene Zuweisungen aus.

Variablen deklarieren und Daten verarbeiten

In dieser Übung erstellen Sie ein Programm, das eine Berechnung basierend auf zwei Zahlen durchführt, dann das Ergebnis formatiert und ausgibt.

Vorlage:

keine

Lösung:

/LRN/CL_S4D400_BTS_COMPUTE (globale Klasse)

Aufgabe 1: Variablendeklaration

Legen Sie in Ihrem eigenen Paket eine neue globale Klasse an, und definieren Sie numerische Variablen für die Eingabe.

Schritte

Legen Sie eine neue globale Klasse an, die das Interface IF_OO_ADT_CLASSRUN implementiert (Namensvorschlag: ZCL_##_COMPUTE, wobei ## für Ihre Gruppennummer steht).
1. Wählen Sie File→New→ABAP Class.
2. Geben Sie den Namen Ihres Pakets in das Feld Package ein. Geben Sie im Feld Name den Namen ZCL_##_COMPUTE ein, wobei ## für Ihre Gruppennummer steht.
3. Geben Sie eine Beschreibung ein.
4. Wählen Sie im Gruppenrahmen Interfaces die Option Add.
5. Geben Sie IF_OO_ADT_CLASSRUN ein. Wenn das Interface in der Trefferliste angezeigt wird, fügen Sie es mit Doppelklick zur Klassendefinition hinzu.
6. Wählen Sie Next.
7. Wählen Sie Ihren Transportauftrag aus, und wählen Sie Finish.
Deklarieren Sie in der Methode IF_OO_ADT_CLASSRUN~MAIN zwei Variablen für Ganzzahlwerte (Namensvorschläge: number1 und number2).
1. Fügen Sie folgenden Code hinzu:
  Code Snippet
```
1234

    DATA number1 TYPE i.
    DATA number2 TYPE i.
```
Implementieren Sie für jede der beiden numerischen Variablen eine Wertzuweisung. Weisen Sie der ersten Variable einen negativen Wert und der zweiten Variable einen positiven Wert zu.
1. Fügen Sie folgenden Code hinzu:
  Code Snippet
```
1234

    number1 = -8.
    number2 =  3. 
```

Aufgabe 2: Datenverarbeitung

Berechnen Sie ein Verhältnis, und schreiben Sie das Ergebnis in die Konsole.

Schritte

Implementieren Sie einen arithmetischen Ausdruck, der das Verhältnis der beiden Zahlen berechnet. Speichern Sie das Ergebnis in einer Variablen, die Sie mit einer Inline-Deklaration deklarieren (Namensvorschlag: result).
1. Fügen Sie folgenden Code hinzu:
  Code Snippet
```
123

    DATA(result) = number1 / number2.
```
Implementieren Sie ein Zeichenketten-Template, das einen Text wie diesen zusammensetzt:„6 / 3 = 2", mit den tatsächlichen Werten der Variablen anstelle von 6, 3 und 2. Speichern Sie das Ergebnis in einer Variablen, die Sie mit einer Inline-Deklaration deklarieren (Namensvorschlag: output).
1. Fügen Sie folgenden Code hinzu:
  Code Snippet
```
123

    DATA(output) = |{ number1 } / { number2 } = { result }|.
```
Rufen Sie die Methode out->write( … ) auf, um den Text in die Konsole zu schreiben.
1. Fahren Sie wie in der vorangegangenen Übung fort.

Aufgabe 3: Aktivieren und testen

Aktivieren und testen Sie die Konsolen-App.

Schritte

Aktivieren Sie die Klasse.
1. Drücken Sie Strg + F3, um die Klasse zu aktivieren.
Führen Sie die Konsolen-App aus.
1. Drücken Sie F9, um die Konsolen-App auszuführen.
Testen Sie die App mit verschiedenen Eingabewerten.
1. Bearbeiten Sie die Wertzuweisungen, aktivieren Sie sie, und führen Sie sie wie zuvor aus.

Aufgabe 4: Genauigkeit des Ergebnisses kontrollieren

Stellen Sie sicher, dass das Ergebnis auf einen Wert mit 2 Dezimalstellen und nicht auf einen ganzzahligen Wert gerundet wird.

Schritte

Anstelle einer Inline-Deklaration verwenden Sie eine explizite Deklaration der Variable result. Verwenden Sie einen numerischen Typ, der es ermöglicht, die Anzahl der Dezimalstellen festzulegen.
1. Fügen Sie am Anfang der Methode if_oo_adt_classrun~main folgenden Code hinzu:
  Code Snippet
```
123

    DATA result TYPE p LENGTH 8 DECIMALS 2.
```
2. Ersetzen Sie in der Codezeile mit der Inline-Deklaration DATA(result) mit result.

Aktivieren Sie die Klasse, und testen Sie sie erneut.

Fahren Sie wie zuvor fort.

Vergleichen Sie Ihren Quelltext mit dem folgenden Auszug aus der Musterlösung:

Code Snippet

12345678910111213141516171819202122232425262728293031323334

 METHOD if_oo_adt_classrun~main.

* Declarations
**************************

    DATA number1 TYPE i.
    DATA number2 TYPE i.

    DATA result TYPE p LENGTH 8 DECIMALS 2.

    
* Input Values
**************************

    number1 = -8.
    number2 =  3.

* Calculation
**************************

*    DATA(result) = number1 / number2.   "with inline declaration 
 
   result = number1 / number2.

    DATA(output) = |{ number1 } / { number2 } = { result }|.

* Output
**************************

    out->write( output ).

  ENDMETHOD.

Next lesson