First-hand knowledge.

Reading Sample
Modularization involves placing specific sequences of ABAP statements in a
module, instead of placing all the statements in a single main program.
In this sample chapter, you will learn to modularize your program using
object-oriented programming, with classes, global classes, function modules
and subroutines.

“Making Programs Modular”

Contents

Index

The Author

Brian O‘Neill
Getting Started with ABAP
451 Pages, 2016, $49.95/€49.95
ISBN 978-1-4932-1242-2

www.sap-press.com/3869
© 2016 by Rheinwerk Publishing, Inc. This reading sample may be distributed free of charge. In no way must the file be altered, or
individual pages be removed. The use for any commercial purpose other than promoting the book is strictly prohibited.
Making Programs Modular

So far, this book has covered a number of technical methods that

allow you to do specific things using ABAP programs. You discovered
different ways to process data, read data from a database, and work
with data in working memory. In this chapter, we will discuss how to
organize, or modularize, your program using object-oriented pro-
gramming to complete all of these tasks. We will cover modulariza-
tion using classes, global classes, function modules and subroutines.

Modularization involves placing specific sequences of ABAP state- What is

ments in a module, instead of placing all the statements in a single modularization?
main program. There are two very important reasons that you need
to modularize your program instead of having just one long program
that executes from the beginning to the end. First, you want to write
programs that are easy for other programmers to read and under-
stand. Second, you want to be able to reuse common functions mul-
tiple times in a single program or across multiple programs and avoid
redundancy.

In addition, modularization has the added benefit of making ABAP

programs easier to support and enhance after they have been written.

Separation of Concerns
Separation of concerns is a principal used to separate a program into
different layers, each with its own function. Imagine an ABAP pro-
gram that was created to report on some data from the database. You
could break that program into three different parts, one part to read
the data from the database, another part to process the data, and a
third part to display the results, as shown conceptually in Figure 6.1.

217
 Making Programs Modular Separation of Concerns
6 6

In order to avoid writing procedural nightmare programs, use the Why use separation
REPORT ZABAP_PROGRAM separation of concerns principal to keep each unit focused on per- of concerns?
forming only one function, and name each unit based on the function
that it performs. This makes it much easier to understand the pro-
gram, fix it, and enhance it. Remember that you may write the pro-
READ DATA FROM DATABASE
gram once, but someone else may have to fix or change it, possibly
years later! Therefore, after using the plan in Figure 6.1, if users
returned to you and said that they wanted additional data from the
READ DATA
PROCESS DATA PROCESS DATA database, you would know exactly what unit to change, and if they
DISPLAY DATA wanted the ability to refresh the data, you would know that you can
add the ability to call the read data from the database after displaying
the data. If you had just one long program, it would be harder to find
DISPLAY DATA out exactly where you need to make changes, and you definitely
would not be able to reuse any particular unit; the program would all
be one long unit.

Figure 6.1 Using Seperation of Concerns to Break a Program into Single-Function Of course, each person’s interpretation of a unit focused on perform-
Units
ing only one function might be different. That’s where this concept
can become more of an art than a science. If the units are made too
When you break your program into these three different sections, small, it can be confusing because there are so many; if they are made
you then have one place to make changes to any of those functions. too large, it can be confusing because there’s so much code in a single
Procedural programs Back in the ancient days of computing, people would write long pro- unit. Remember that you’re both writing a program and trying to
grams using punch cards that had to be executed from the beginning make it easy for the next person to fix and enhance.
to the end and probably scheduled to run at a certain time. Today, Figure 6.2 expands on the original conceptual drawing in Figure 6.1 Naming different
applications are used by people in real time, which means that you to demonstrate breaking up and naming units for each function that units
need to change your application to meet the user’s sometimes crazy they perform. This example demonstrates a program that gets a list of
expectations. Programs designed to run from the beginning to end possible flights based on a search, calculates the price of the flight
are called procedural programs. options, and displays the results to the user. Each unit completes one
In a typical ABAP journey, it’s normal to see an old program written function, and each unit has a descriptive name. If a person said that
in a procedural format—and then you’ll hear from a user that the pro- there was an issue with the price being calculated, you would know
gram is supposed to process data in some way that isn’t working. exactly what unit of code he or she was talking about.
You’ll have to go through the long process of reading the program and
debugging to figure out where the data is changed, only to find that
the data is read and changed all over the place.

218 219
 Making Programs Modular Introduction to Object-Oriented Programming
6 6

oriented ABAP). The fact is that there is no ABAP versus OO-ABAP:

just ABAP with good developers and bad developers.
GET_AVAILABLE_FLIGHTS
REPORT ZABAP_PROGRAM
If you have written object-oriented programs in other languages, you
will find that there are a few ABAP quirks, but all of the concepts that
you have seen in other languages will apply in ABAP as well.
READ DATA FROM DATABASE GET_CUSTOMER_DATA

What Is an Object?
READ DATA A programming object is designed around the idea of objects in the
PROCESS DATA PROCESS DATA CALCULATE_TOTAL_PRICE
DISPLAY DATA
real world. A good introductory conceptual example is that of a car.
A car has attributes that describe its current state, such as fuel level
and current speed, and attributes that describe the object, such as
DISPLAY DATA DISPLAY_RESULTS manufacturer and model. There are also a few methods that describe
how we interact with the car, such as accelerate, decelerate, and
refuel. Figure 6.3 shows a conceptual drawing of this car object.
Figure 6.2 Seperation of Concerns with Named Code Units
Attributes Methods
Changing units Just because you created certain units of code when the application
of code was created doesn’t mean that you can’t add more. It’s common to
have to add additional functionality in a single unit of code, in which Accelerate

case you should determine if the additional functionality might need

to be in its own functional unit of code. If each unit is expected to per- Fuel: 100
form one function, ask yourself if the new code is really completing Speed: 0
Manufacturer: Toyota Decelerate
that same function or if it’s its own unit. Also, anytime the new code Model: Tundra
is something that could be reused, then it should be in its own unit.
Once your code is completed and working, it is always good practice
to go back and see what kind of improvements you can make to your Refuel
code and find any code that is repeated and could be modularized.

Now that you understand the concept of Separation of Concerns, we

Figure 6.3 The Car Object
will cover how to utilize it using object-oriented programming.

Each of the object’s methods is a functional unit designed to complete

Introduction to Object-Oriented Programming one task. Each attribute of the object is a variable that all of the meth-
ods have access to. The pseudocode in Listing 6.1 shows what the
OOP The recommended method for modularizing ABAP programs is to use code in the accelerate method could look like.
object-oriented programming. There are some people in the ABAP
community who are unsure about object-oriented programming and
have even posed the idea that there is ABAP and OO-ABAP (object-

220 221
 Making Programs Modular Structuring Classes
6 6

METHOD ACCELERATE. one object that holds all of the logic for your program. Each method
SPEED = SPEED + 5. will represent a single function, as discussed in the section on the sep-
ENDMETHOD.
aration of concerns principle. Looking back at Figure 6.2, each differ-
Listing 6.1 Pseudocode of Accelerate Method
ent unit could be represented as a method in a flight finder class, as
shown in Figure 6.5.
Classes Now, say that the example in Figure 6.3 specifically refers to a Toyota
Tundra, but you want to create additional objects for different types
Methods
of cars. This is where classes come in. Each object is actually an instan-
tiation of a class, and you can have multiple objects of the same class. Attributes GET_AVAILABLE_FLIGHTS
Again think back to the real-life example of a car; the Toyota Tundra
is a type of car, and all cars can accelerate, decelerate, and refuel, but
GET_CUSTOMER_DATA
this particular car is going at a certain speed and has a certain fuel
level. When creating objects, all of the code is stored in the class, but
you can create multiple objects that use that code, and each will have CALCULATE_TOTAL_PRICE
its own set of attributes to describe it, as shown conceptually in Fig-
ure 6.4. You can think of the class in this example as a mold, whereas
DISPLAY_RESULTS
the objects are those items created from that mold.

Car Class Figure 6.5 Flight Finder Class Concept

Fuel:
Speed:
Brand: Each class method can be created with the ability to take and return Passing data to
Manfuctaurer:
data. For example, when creating the method for calculating the total methods
price in Figure 6.5, you could pass a value containing the results from
the get available flights method.

Structuring Classes
Now that you understand some of the concepts of object-oriented
programming, you can begin to learn how to create classes and
Car Object 1 Car Object 2
Fuel: 100 Fuel: 10 objects in ABAP. If the object-oriented concepts do not make sense
Speed: 10 Speed: 0
Brand: Toyota Brand: Nissan yet, perhaps seeing the actual code in action will help. We’ll first
Manufacturer: Tundra Manufacturer: Sentra
cover how to create a local class within a program and then how to
create a global class that can be used across multiple programs.
Figure 6.4 Relationship between Class and Object
Implementation vs. Definition
Modularizing with Object-Oriented Programming In ABAP, every class requires a definition and an implementation.
Just because you are using object-oriented programming doesn’t The definition lists the different attributes and methods of a class,
mean you have to use it to build multiple objects. You could also have

222 223
 Making Programs Modular Structuring Classes
6 6

whereas the implementation contains the actual code for all of the CLASS lcl_car IMPLEMENTATION.
methods. The definition must come before the implementation and ENDCLASS.

must also come before an object is created from the class. The class is Listing 6.3 Creating an Object from a Class

defined by using the CLASS keyword, followed by the name of the

class and then either DEFINITION or IMPLEMENTATION depending on Public and Private Sections
what you are declaring. The example in Listing 6.2 contains the defi- Before adding attributes and methods to the class definition, you will
nition of a class with no attributes or methods. Prefix the class name need to decide whether those attributes and methods should be pub-
with lcl to indicate that it’s a local class, meaning that it’s being cre- lic, private, or protected.
ated inside of an ABAP Program. Since we are demonstrating local
Public attributes and methods can be used within the class or outside Public
classes, you can insert the code in this section into any ABAP program
of the class, from the main program, or even from another class.
for testing. Since both the definition and implementation are con-
tained within a CLASS and ENDCLASS keyword, they do not need to be Private attributes and methods can only be used from within the class Private
next to each other when being defined. itself, meaning that another class or the main program is unable to
read the attributes or call the methods that are listed as private.
CLASS lcl_car DEFINITION.
ENDCLASS.
Protected attributes and methods can only be used from within the Protected
CLASS lcl_car IMPLEMENTATION.
ENDCLASS. class itself, just like the private attributes and methods. The difference
Listing 6.2 Definition and Implementation of a Class with protected attributes and methods is that they can be inherited
from a subclass, unlike a private attribute or class. We will revisit pro-
Creating Objects tected attributes and methods when we cover inheritance later in the
chapter.
Now that you’ve created a basic class, you can create objects of that
class. Remember that a class is like a design, and you can build multi- The public and private sections are defined in the class implementa-
ple objects using that design. tion using the PUBLIC SECTION and PRIVATE SECTION keywords. Listing
6.4 adds those sections to the class definition.
Object variables There are two parts to creating an object. The first part is to define the
object variable. This is just like creating variables, which we intro- CLASS lcl_car DEFINITION.
duced in Chapter 2, except that you will use TYPE REF TO instead of PUBLIC SECTION.
PRIVATE SECTION.
just TYPE to indicate the class to be used when creating the object. The ENDCLASS.
example in Listing 6.3 uses the prefix o_ to indicate an object. ClASS lcl_car IMPLEMENTATION.
ENDCLASS.
For objects, you then use the command CREATE OBJECT followed by Listing 6.4 Adding the Public and Private Sections to the Class Definition
the object variable to instantiate the object, as shown in Listing 6.3
Just like creating your own data types using the TYPES command, the
Next, you can add attributes to public or private sections, by creating Attributes
class definition must come before creating an object using that class.
variables, just like the ones discussed in Chapter 2. The variables
CLASS lcl_car DEFINITION. must be defined after a section to determine whether they’re public
ENDCLASS. or private.
DATA: o_car TYPE REF TO lcl_car. These attributes will be available globally to all of your methods; if
CREATE OBJECT o_car.
they’re public, they’ll also be available globally outside of your

224 225
 Making Programs Modular Structuring Classes
6 6

methods. Listing 6.5 adds public attributes for fuel, speed, brand, ENDCLASS.
and manufacturer and a private attribute for the current gear. ClASS lcl_car IMPLEMENTATION.
METHOD accelerate.
Read Only attributes Public attributes can also be given a READ-ONLY property, which will ENDMETHOD.
METHOD decelerate.
make them readable outside of the class and changeable only from ENDMETHOD.
within the class. In Listing 6.5, the attribute d_manufacturer is set to METHOD refuel.
be read-only. ENDMETHOD.
ENDCLASS.
CLASS lcl_car DEFINITION. Listing 6.6 Adding Public Classes to the Car Class
PUBLIC SECTION.
DATA: d_fuel TYPE i,
d_speed TYPE i, Now, you can add code to the methods. The code will go in the class Implementation
d_brand TYPE string, implementation section, and each method will share all of the attri-
d_manufacturer TYPE string READ-ONLY. butes declared in the definition. Listing 6.7 adds some programming
PRIVATE SECTION.
DATA: d_gear TYPE i. logic to each of the methods, and you can see that they are all able to
ENDCLASS. access the class attributes.
ClASS lcl_car IMPLEMENTATION.
ENDCLASS. You can also declare variables within methods, such as ld_max in the Local variables
Listing 6.5 Adding Public and Private Attributes to the Car Class REFUEL method shown in Figure 6.11. These variables are considered
local variables since they will not be visible or usable outside of the
Class Methods methods in which they’re declared. For that reason, they are prefixed
Definition Methods are the place to store all of your code, in single units of work with a ld_ meaning local data variable, instead of d_, meaning global
designed to complete one function. Each method should have a name data variable.
describing the action that it will complete. First, you have to define CLASS lcl_car DEFINITION.
the method using the keyword METHODS in the class definition, and PUBLIC SECTION.
then write the method’s code in the class implementation in between DATA: d_fuel TYPE i,
d_speed TYPE i,
the words METHOD and ENDMETHOD. Listing 6.6 expands on the car d_brand TYPE string,
example to add the definition and an empty implementation for the d_manufacturer TYPE string.
accelerate, decelerate, and refuel methods. When adding methods, METHODS: accelerate,
decelerate,
you will get a syntax error if the method is not defined in both the
refuel.
definition and implementation of the class. PRIVATE SECTION.
DATA: d_gear TYPE i.
CLASS lcl_car DEFINITION. ENDCLASS.
PUBLIC SECTION. ClASS lcl_car IMPLEMENTATION.
DATA: d_fuel TYPE i, METHOD accelerate.
d_speed TYPE i, d_speed = d_speed + 5.
d_brand TYPE string, d_fuel = d_fuel – 5.
d_manufacturer TYPE string. ENDMETHOD.
METHODS: accelerate, METHOD decelerate.
decelerate, d_speed = d_speed – 5.
refuel. d_fuel = d_fuel – 2.
PRIVATE SECTION. ENDMETHOD.
DATA: d_gear TYPE i. METHOD refuel.

226 227
 Making Programs Modular Structuring Classes
6 6

DATA: ld_max TYPE I VALUE 100. ENDMETHOD.

d_fuel = ld_max. METHOD refuel.
ENDMETHOD. DATA: d_max TYPE i VALUE 100.
ENDCLASS. d_fuel = 100.
Listing 6.7 Adding Logic to Methods in the Car Class ENDMETHOD.
ENDCLASS.
Listing 6.8 How to Call a Method in an Object
Calling methods Now that you’ve defined some methods which contain some code,
you can define an object, create it, and call the methods contained in
Now you can set a breakpoint within the method and execute the pro- Methods in the
the object. To call an object’s method, you enter the object name fol-
gram and you will see the execution stack will show where the execution stack
lowed by an arrow (->), then the method name, and then the open
method was called from. If you are using Eclipse, the stack should
and close parentheses (()), with any parameters in between the
look like what we see in Figure 6.6. The accelerate method is listed
parentheses. Table 6.1 shows how a method is called via an example
and before that is START-OF-SELECTION, which is the ABAP event that
using the car object created earlier in this section.
starts executing our code.
Object->method_name(parameters) o_car->accelerate()

Table 6.1 How to Call a Method

The code for calling methods has to be included after the object has
been defined and created, but it can come before the definition of the
Figure 6.6 Execution Stack in Eclipse
object, as shown in Listing 6.8.

CLASS lcl_car DEFINITION. Now, we can select the start-of-selection item in the stack to see
PUBLIC SECTION. the line of code where the accelerate method was called as shown in
DATA: d_fuel TYPE i,
d_speed TYPE i, Figure 6.7.
d_brand TYPE string,
d_manufacturer TYPE string.
METHODS: accelerate,
decelerate,
Figure 6.7 Eclipse Showing Where the Start-Of-Selection Stack
refuel.
PRIVATE SECTION.
DATA: d_gear TYPE i. We can do the same thing from the SAP GUI debugger, when your
ENDCLASS.
breakpoint inside of the accelerate method is hit, you will notice the
DATA: o_car TYPE REF TO lcl_car.
CREATE OBJECT o_car. ABAP and Screen Stack section will appear as shown in Figure 6.8.
o_car->accelerate( ).
ClASS lcl_car IMPLEMENTATION.
METHOD accelerate.
d_speed = d_speed + 5.
d_fuel = d_fuel – 5.
ENDMETHOD.
METHOD decelerate.
d_speed = d_speed – 5.
d_fuel = d_fuel – 2. Figure 6.8 ABAP and Screen Stack in SAP GUI

228 229
 Making Programs Modular Structuring Classes
6 6

We can then click the START-OF-SELECTION item and the debugger CLASS lcl_car DEFINITION.
will bring up the section of code that called our accelerate method as PUBLIC SECTION.
DATA: d_fuel TYPE i,
shown in Figure 6.9. d_speed TYPE i,
d_brand TYPE string,
d_manufacturer TYPE string.
METHODS: accelerate IMPORTING ip_accel_rate TYPE i,
decelerate,
refuel.
PRIVATE SECTION.
Figure 6.9 SAP GUI Debugger Execution Stack DATA: d_gear TYPE i.
ENDCLASS.
DATA: o_car TYPE REF TO lcl_car.
Importing, Returning, Exporting, and Changing CREATE OBJECT o_car.
o_car->accelerate( 5 ).
When using your car class, users do not want to accelerate at a rate of ClASS lcl_car IMPLEMENTATION.
5; they want to specify the amount of acceleration to occur, which METHOD accelerate.
makes sense. There are a few ways to pass data to and from methods, d_speed = d_speed + ip_accel_rate.
d_fuel = d_fuel – 5.
as described in Table 6.2.
ENDMETHOD.
METHOD decelerate.
Importing A copy of one or more variables is passed to the method. d_speed = d_speed – 5.
Returning The actual variable is returned by the method. Returning can d_fuel = d_fuel – 2.
only be used to return one variable. ENDMETHOD.
METHOD refuel.
Exporting A copy of one or more variables are returned from the d_fuel = 100.
method. ENDMETHOD.
ENDCLASS.
Changing The actual variable is passed to the method, and any changes
to that variable will change the original. (Also known as Listing 6.9 Adding the Ability to Import Variables in Methods
passing by reference.)
Next, you can change the method to check if the fuel is at zero; if it is, Returning
Table 6.2 Ways to Pass Data to and from a Method
then the car will not accelerate. When you call the method, you want
to know if it worked or not, so return a Boolean parameter that will
Importing You can change the accelerate method to import a variable to indi- be true if the method worked and false if it did not. The Boolean
cate the amount of speed that you want to increase by. This is handled parameter is defined in the class definition using the RETURNING key-
in Listing 6.9 by adding the IMPORTING command followed by a vari- word followed by VALUE and the variable name within parentheses, as
able definition for the variable that will be copied in to the method shown in Listing 6.10, with the prefix rp indicating a returning
and used to set the rate of acceleration for the car object. After adding parameter.
the IMPORTING variable in the definition, that variable can now be
accessed in the method implementation. The prefix ip here indicates Because the returning parameter is a Boolean, also create the Boolean
an IMPORTING parameter. variable d_is_success in the main program and set it to the result of
the method call in Listing 6.10, meaning that d_is_success will be set
Now that you’ve defined the IMPORTING parameter, you also can pass to the value of rp_is_success after calling the accelerate method.
the value for that parameter within the parentheses when calling the
method, as shown in Listing 6.9.

230 231
 Making Programs Modular Structuring Classes
6 6

CLASS lcl_car DEFINITION. CREATE OBJECT o_car.

PUBLIC SECTION. IF o_car->accelerate(5) = abap_true.
DATA: d_fuel TYPE i, WRITE: ‘It worked!’.
d_speed TYPE i, ENDIF.
d_brand TYPE string, …
d_manufacturer TYPE string. Listing 6.11 Using the Returning Parameter as Part of an IF Statement
METHODS: accelerate IMPORTING ip_accel_rate TYPE i
RETURNING VALUE(rp_is_success)
TYPE bool, If you want to import multiple parameters, you can do so by includ- Import multiple
decelerate, ing the additional parameters after the IMPORTING command in the parameters
refuel.
class definition. When you list multiple variables, you will also need
PRIVATE SECTION.
DATA: d_gear TYPE i. to specify which variable you are passing within the parentheses, as
ENDCLASS. shown in Listing 6.12.
DATA: o_car TYPE REF TO lcl_car,
d_is_success TYPE bool. CLASS lcl_car DEFINITION.
CREATE OBJECT o_car. PUBLIC SECTION.
d_is_succcess = o_car->accelerate(5). DATA: d_fuel TYPE i,
ClASS lcl_car IMPLEMENTATION. d_speed TYPE I,
METHOD accelerate. d_brand TYPE string,
IF d_fuel – 5 > 0. d_manufacturer TYPE string.
d_speed = d_speed + ip_accel_rate. METHODS: accelerate IMPORTING ip_accel_rate TYPE i
d_fuel = d_fuel – 5. ip_other_param TYPE i
rp_is_success = abap_true. RETURNING VALUE(rp_is_success)
ELSE. TYPE bool,
rp_is_success = abap_false. decelerate,
ENDIF. refuel.
ENDMETHOD. PRIVATE SECTION.
METHOD decelerate. DATA: d_gear TYPE i.
d_speed = d_speed – 5. ENDCLASS.
d_fuel = d_fuel – 2. DATA: o_car TYPE REF TO lcl_car,
ENDMETHOD. d_is_success TYPE bool.
METHOD refuel. CREATE OBJECT o_car.
d_fuel = 100. d_is_succcess = o_car->accelerate( ip_accel_rate = 5
ENDMETHOD. ip_other_param = 1 ).
ENDCLASS. ClASS lcl_car IMPLEMENTATION.
Listing 6.10 Class Including Returning Parameter ..
ENDCLASS.
Listing 6.12 Adding Multiple IMPORTING Parameters
Method chaining The returned variable can also be used in line with other ABAP key-
words using method chaining, which was added to the ABAP language
You can also mark parameters as optional by adding OPTIONAL after Optional parameters
in ABAP 7.02. For example, you can call the accelerate method from
the parameter’s definition, which means that the parameter will have
Listing 6.10 from within an IF statement and use the returning
an initial value when the method runs if a value is not entered for that
parameter as part of the IF statement, as shown in Listing 6.11.
parameter. If there are multiple importing parameters but only one is
… not marked as optional, you can pass only the required parameter
DATA: o_car TYPE REF TO lcl_car,
without identifying the parameter names, as shown in Listing 6.13.
d_is_success TYPE bool.

232 233
 Making Programs Modular Structuring Classes
6 6

CLASS lcl_car DEFINITION. PRIVATE SECTION.

PUBLIC SECTION. DATA: d_gear TYPE i.
DATA: d_fuel TYPE i, ENDCLASS.
d_speed TYPE i, DATA: o_car TYPE REF TO lcl_car,
d_brand TYPE string, d_is_success TYPE bool.
d_manufacturer TYPE string. CREATE OBJECT o_car.
METHODS: accelerate IMPORTING ip_accel_rate TYPE i o_car->accelerate( EXPORTING ip_accel_rate = 5
ip_other_param TYPE i OPTIONAL IMPORTING ep_is_success = d_is_success ).
RETURNING VALUE(rp_is_success) ClASS lcl_car IMPLEMENTATION.
TYPE bool, ..
decelerate, ENDCLASS.
refuel. Listing 6.14 EXPORTING Parameters
PRIVATE SECTION.
DATA: d_gear TYPE i.
ENDCLASS. The last option for passing variables to or from methods is CHANGING. Changing
DATA: o_car TYPE REF TO lcl_car, CHANGING parameters are passed into a method like IMPORTING
d_is_success TYPE bool.
parameters but can also be changed and returned like EXPORTING
CREATE OBJECT o_car.
d_is_succcess = o_car->accelerate( 5 ). parameters. Unlike with an IMPORTING parameter, when calling a
ClASS lcl_car IMPLEMENTATION. method and using a CHANGING parameter, you will always have to
..
specify that it is a CHANGING parameter. Just as with EXPORTING
ENDCLASS.
parameters, you can’t have both a CHANGING and a RETURNING param-
Listing 6.13 Optional Importing Parameters
eter. The car object example has been updated to use a CHANGING
parameter in Listing 6.15.
Returning multiple The RETURNING parameter only allows you to return one parameter,
parameters but if you need to return multiple parameters, you can use EXPORTING CLASS lcl_car DEFINITION.
parameters. EXPORTING parameters are defined just like IMPORTING PUBLIC SECTION.
DATA: d_fuel TYPE i,
parameters, but using both requires identifying which parameters are d_speed TYPE I,
IMPORTING and which are EXPORTING when calling the corresponding d_brand TYPE string,
method, as shown in Listing 6.14. d_manufacturer TYPE string.
METHODS: accelerate IMPORTING ip_accel_rate TYPE i
Exporting The parameters that are EXPORTING from the method will be IMPORT- CHANGING cp_is_success TYPE bool,
decelerate,
ING into the main program; note how the naming changes in Listing
refuel.
6.14. You cannot use both EXPORTING and RETURNING in the same PRIVATE SECTION.
method definition. EXPORTING parameters are always optional. DATA: d_gear TYPE i.
ENDCLASS.
CLASS lcl_car DEFINITION. DATA: o_car TYPE REF TO lcl_car,
PUBLIC SECTION. d_is_success TYPE bool.
DATA: d_fuel TYPE i, CREATE OBJECT o_car.
d_speed TYPE I, o_car->accelerate( EXPORTING ip_accel_rate = 5
d_brand TYPE string, CHANGING cp_is_success = d_is_success ).
d_manufacturer TYPE string. ClASS lcl_car IMPLEMENTATION.
METHODS: accelerate IMPORTING ip_accel_rate TYPE i ..
EXPORTING ep_is_success TYPE bool, ENDCLASS.
decelerate, Listing 6.15 CHANGING Parameters
refuel.

234 235
 Making Programs Modular Structuring Classes
6 6

CREATE OBJECT o_car EXPORTING ip_manufacturer = ‘Toyota’

Returning vs. Exporting/Changing ip_model = ‘Tundra’.
d_is_success = o_car->accelerate( 5 ).
When possible, use RETURNING parameters to help write more concise, ClASS lcl_car IMPLEMENTATION.
easier-to-read code. RETURNING parameters will also make your ABAP METHOD constructor.
d_manufacturer = ip_manufacturer.
code look more similar to other object-oriented languages, allowing
d_model = ip_model.
someone who learned other languages first to more easily understand ENDMETHOD.
your program. The real power of RETURNING parameters is the ability to ..
use method chaining with other ABAP keywords, as shown in Listing ENDCLASS.
6.11. Listing 6.16 Car Object with a Constructor

The constructor is typically used to set variables that determine the

Constructors state of the object, but it can be used to initialize the object in any
Constructors are special methods used to set the state of an object way. For example, the constructor can read data from a database table
before you start calling its methods. For example, you can set the to fill some private or public variables. Remember that the construc-
manufacturer and model of the car object when you first create it tor will only be run once when creating the object.
using a constructor.
Recursion
Creating a A constructor is created by creating a method called constructor.
constructor When using separation of concerns, you can use recursion to reuse a
This method will be called by the CREATE OBJECT keyword, and any
unit of work thanks to method chaining, which we introduced in Lis-
required parameters must be passed when using CREATE OBJECT.
ting 6.11. Recursion works by calling a method from inside the same
The example in Listing 6.16 specifies the model and manufacturer
method, which can make your code much more compact and under-
in the constructor, and those parameters are used to update the
standable than following a procedural approach, which may just
class attributes.
result in one long program with the same code repeated over and
CLASS lcl_car DEFINITION. over. Because you call a method from inside the same method using
PUBLIC SECTION. the results of the earlier call, recursion only works when you use a
DATA: d_fuel TYPE i,
d_speed TYPE i, RETURNING parameter in your method.
d_model TYPE string,
d_manufacturer TYPE string. To demonstrate recursion, let’s write a method to calculate a given Fibonacci sequence
METHODS: accelerate IMPORTING ip_accel_rate TYPE i number of the Fibonacci sequence. The Fibonacci sequence is an
RETURNING VALLUE(rp_is_success) infinite sequence starting with 0 and 1 and then adding the current
TYPE bool,
decelerate,
number to the last number to get the next number in the sequence.
refuel, For example: 0, 1, 1, 2, 3, 5, 8, and 13. If you are familiar with agile
constructor scrum planning, you may have used Fibonacci numbers to estimate
IMPORTING ip_manufacturer TYPE string
work.
ip_model TYPE string.
PRIVATE SECTION.
In Listing 6.17, to calculate the Fibonacci number you recursively call
DATA: d_gear TYPE i.
ENDCLASS. the calculate method, meaning that we call it from within the cal-
DATA: o_car TYPE REF TO lcl_car, culate method and set the returning value to its result. During this
d_is_success TYPE bool.

236 237
 Making Programs Modular Structuring Classes
6 6

call, call with a value of one less than the current importing parameter
and add the result of that to the result of calling the method with a rp_value = calculate(4-1) + calculate(4-2).
value of two less than the current importing parameter. You don’t
want the recursive call to run forever, of course, so if the method is
called with a value of one or less, it will return the value of the param-
eter that was called. Try running the code in Listing 6.17 in debug rp_value = calculate(3-1) + calculate(3-2). rp_value = calculate(2-1) + calculate(2-2).
mode and step through the program to see the recursion in action.

CLASS lcl_fibonacci DEFINITION.

PUBLIC SECTION.
Return 1 Return 1 Return 0
METHODS: calculate IMPORTING ip_place TYPE i rp_value = calculate(2-1) + calculate(2-2).
RETURNING VALUE(rp_value) TYPE i.
ENDCLASS.
DATA: o_fib TYPE REF TO lcl_fibonacci,
d_result TYPE i.
CREATE OBJECT o_fib. Return 1 Return 0 1+0+1+1+0=3
d_result = o_fib->calculate( 4 ).
CLASS lcl_fibonacci IMPLEMENTATION.
METHOD calculate. Figure 6.10 Fibonacci Recursive Call
IF ip_place <= 1.
rp_value = ip_place.
ELSE. Inheritance
rp_value = calculate( ip_place –
When using object oriented programming, we have the ability to take
1 ) + calculate( ip_place – 2 ).
ENDIF. on attributes and methods from another class through the use of
ENDMETHOD. inheritance. The class that we are inheriting from is called a superclass
ENDCLASS. and the class that is inheriting is called a subclass.
Listing 6.17 Calculating a Fibonacci Number with Recursion
Inheritance, like recursion, is a powerful benefit of object-oriented
Figure 6.10 provides a conceptual image of what is happening during programming that we do not necessarily use with every program that
the recursive call in Listing 6.17 when trying to find the fourth num- we write.
ber of the Fibonacci sequence. Because the code only returns the In Listing 6.18, we added a new class, called lcl_truck which inherits INHERITING FROM
importing parameter value when it is 1 or less, the numbers added up from the car class by using the INHERITING FROM keyword as part of
are always 1 or 0. the class definition. Since lcl_truck inheriting from lcl_car, we can
A need for a recursive method will not exist in every ABAP program call all of the same methods that are in lcl_car and it will execute the
that you write, but when it can be used, it’s very useful and can make code in the lcl_car implementation. This class can be defined below
your program much more understandable. the code that we have already covered.

…
CLASS lcl_truck DEFINITION
INHERITING FROM lcl_car.
ENDCLASS.

DATA: o_truck TYPE REF TO lcl_truck.

238 239
 Making Programs Modular Global Classes
6 6

CREATE OBJECT o_truck. CLASS lcl_car DEFINITION.

o_truck->accelerate(5). PUBLIC SECTION.
DATA: d_fuel TYPE i,
CLASS lcl_truck IMPLEMENTATION. d_speed TYPE i,
ENDCLASS. d_model TYPE string,
Listing 6.18 Demonstrating Class Inheritance d_manufacturer TYPE string.
METHODS: …
PRIVATE SECTION.
Redefining methods We also have the option of redefining a method so that we use the DATA: d_gear TYPE i.
code inside the lcl_truck implementation instead of the lcl_car PROTECTED SECTION.
DATA: d_protected TYPE i.
implementation. To do that, we need to declare the method in the
ENDCLASS.
subclass without any parameters and include the REDEFINITION key- …
word as shown in Listing 6.19. Notice that we still have access to the CLASS lcl_truck DEFINITION
INHERITING FROM lcl_car.
same public variables and the returning parameter that we were able
PUBLIC SECTION.
to use in the superclass method. METHODS: accelerate REDEFINITION.
ENDCLASS.
… …
CLASS lcl_truck DEFINITION CLASS lcl_truck IMPLEMENTATION.
INHERITING FROM lcl_car. METHOD accelerate.
PUBLIC SECTION. d_speed = 1.
METHODS: accelerate REDEFINITION. rp_is_success = abap_true.
ENDCLASS. d_protected = 1.
ENDMETHOD.
DATA: o_truck TYPE REF TO lcl_truck. ENDCLASS.
CREATE OBJECT o_truck.
Listing 6.20 Class Demonstrating a Protected Attribute
o_truck->accelerate(5).

CLASS lcl_truck IMPLEMENTATION. Global Classes

METHOD accelerate.
d_speed = 1. So far, you’ve learned about local classes, which are created and run
rp_is_success = abap_true. inside of a local program. However, there are many use cases in which
ENDMETHOD.
ENDCLASS.
you’ll want to use classes across multiple programs. A common use of
Listing 6.19 Demonstrating Redefining a Method in a Subclass
global classes is to create interfaces with custom tables that you have
written. This allows for a couple of things: First, you can handle lock-
ing of tables within the methods of your class, instead of having to
Protected section Unlike methods in the superclass, methods in the subclass are unable
lock and unlock tables in the programs that access the table. Second,
to access the private methods or attributes of the superclass. If you
you can write methods that allow you to access the data in your cus-
want to create attributes or methods that are private but can also be
tom table(s) without having to write your own SELECT statements.
accessed from inside of a subclass, then you must define them in the
How you use global classes really depends on the design of your
protected section. In Listing 6.20 we demonstrate this by adding a
tables and applications and the problem that you’re trying to solve.
protected variable to the lcl_car definition which we can then call
from within the lcl_truck class.

240 241
 Making Programs Modular Global Classes
6 6

Multiple views The code for creating and changing the classes is mostly the same as
what you saw for local classes. When using SAP GUI to create the
class, there are two views: a source code view and a forms view. The
resulting code will be the same, but the forms view allows the ABAP
system to write some of the code itself.

Source control One thing that is different about using global classes is the way that
they’re broken up into different pieces. Each piece has its own source
control history and must be activated on its own. The breakup of a
class into different pieces makes it possible for multiple developers to
work on the same class simultaneously.

The different pieces of a global class are the public, private, and pro-
tected sections and each method implementation. This allows you to
Figure 6.11 Creating a New Global Class in Eclipse
treat each method as an individual program in terms of source control
and activation. The public, private, and protected sections are a bit of
You’ll see your new class with the basic structure for a class laid out Global class
a special case, however. These sections are automatically generated keywords
for you, as shown in Figure 6.12. This should look familiar; it’s the
when using the forms view in SAP GUI, so any comments entered in
same structure that you saw with the local classes. The only change is
these areas will be overwritten. You can still create and edit these sec-
the addition of the PUBLIC keyword, indicating a global class. Addi-
tions with your own code, which will be kept, but any comments will
tionally, FINAL keyword is optional and indicates that the class cannot
be lost.
be inherited from and the CREATE PUBLIC keyword, allows an object
to be created from the class anywhere where the class is visible.
How to Create Global Classes in Eclipse
Using Eclipse to create classes is the preferred method and we’ll look
at that first, but we will also cover how to create them using Transac-
tion SE80 later in the section.

To begin, select File 폷 New 폷 ABAP Class; you’ll see the New ABAP
Class wizard appear. Select the package $TMP to save the new class
as a local object, enter “ZCL_GLOBAL_CLASS” as the class name, and
enter “Global Class” as the description, as shown in Figure 6.11. Just
as with ABAP programs, your class needs to be prefixed with a Z. You
can use the prefix ZCL to indicate that the class you’re creating is a
Figure 6.12 New Class Created in Eclipse
custom global class.

How to Create Global Classes in Transaction SE80

If you’re using Transaction SE80 as your ABAP IDE, select CLASS/
Interface from the dropdown in the center of left side of the screen,
type “ZCL_GLOBAL_CLASS” in the textbox below the dropdown in
the center left of the screen, and press (Enter).

242 243
 Making Programs Modular Global Classes
6 6

You will be prompted with a popup asking if you want to create ZCL_
GLOBAL_CLASS because it doesn’t exist as shown in Figure 6.13.
Click the Yes button.

Figure 6.13 Create Class/Interface Popup

Figure 6.15 Forms View of a Class, with Source Code-Based Button Highlighted
In the next popup, enter “Global Class” in the Description field and
leave the rest of the options set to their defaults, as shown in Figure The source code view shown in Figure 6.16 should look similar to Source code view
6.14. The Final checkbox indicates that other classes cannot inherit what you saw when working with local classes. Whichever method
from this class. Select the Save button to continue. you choose to use should be based on personal preference, but the
source code view is recommended if you are going to use Transaction
SE80 as your primary IDE.

Figure 6.14 Create Class Popup

In the Create Object Directory Entry popup, click the Local Object Figure 6.16 New Class in the Source Code View
button or enter “$TMP” for the package name, and click the Save but-
ton. For production objects, you should use a package created for Using the Form-Based View in Transaction SE80
your project. You can now return to the form-based view by clicking the Form-
Forms view After creating the class, the editor will show the class in the default Based button, if you are still looking at the source code view. The
forms view. The forms view can be used to change the structure of the form-based view will generate the code for the class definition and
class and add attributes and methods, and it will generate the class add the method definitions to the class implementation. Everything
definition code automatically. You can also click the Source Code- in the form-based view can be done manually in the source code
Based button (Figure 6.15) to view the entire class as code. view; which you use is a matter of personal preference.

244 245
 Making Programs Modular Global Classes
6 6

There are many things that you can do with classes that I haven’t cov- The next column, Typing Method, indicates whether the data type
ered yet and things that are out of scope for this book, so don’t feel should be created using the keyword TYPE, TYPE REF TO, or LIKE. Select
overwhelmed by all of the tabs and options in the form-based view. the typing method Type. Next, the Associated Type column indicates
In this section, you will learn how to use the form-based view to add the data type to be used for the parameter; enter “I” to indicate an
methods and attributes to a class. integer data type. You can also add a default value and description; as
with the method description, this description is only visible to other
Creating a method First, create a new method. To do so, select the Methods tab and
developers using the form-based view.
enter “METHOD1” in the first row of the Method column; this will
name your new method METHOD1. Next, under Level, select Instance Next, add a second parameter named “rp_value”. This parameter
Method. When you worked with local classes earlier in the chapter, should be of type returning with a typing method of TYPE and an asso-
those were instance methods; static methods are out of scope for this ciated type of i for integer. Both parameters are shown in Figure 6.18.
book and should be avoided if possible.

Next, select Public under Visibility; this will set the method as public
by defining it in the public section of the class definition. You can also
add a description in the last column, which will only be visible from
the form-based view. The name of your method should typically be
descriptive enough on its own. The end result should look as shown
in Figure 6.17.
Figure 6.18 Adding Parameters Using the Form-Based View

Now, click the Methods button to return to the methods list, and Method
double-click your method to enter the method implementation, implementation
where you can write your code. You will notice that the editor
restricts you to only the method you selected. From here, you can also
Figure 6.17 Adding a Method Using the Form-Based View click the Signature button to toggle the signature display that will
show the parameters you defined for the method as shown in Figure
Parameters Next, select the method and click the Parameter button. From here, 6.19.
you can add parameters for your method. The parameter name goes
in the first column; enter “ip_parameter”. The next column, Type,
indicates whether the parameter is importing, exporting, returning,
or changing. Select Importing for this parameter.

Next, there are two checkboxes, one for Pass Value and one for
Optional. You’re required to pass a value for returning parameters,
but can pass a value for any importing parameters as well. Passing a Figure 6.19 Editng a Method Using the Form-Based View
value for a parameter means that any changes to the parameter in the
method will change the parameter that was passed into the method
Next, click Back to return to the form-based view and click on the Attributes
instead of changing a copy of that parameter. The Optional checkbox
Attributes tab to add some attributes to your new class. Enter “D_I”
will make that parameter optional.

246 247
 Making Programs Modular Obsolete Modularization
6 6

in the first row of the Attribute column to indicate that the attribute
name will be D_I. Next, select Instance Attribute under the Level
column. Static attributes are out of scope for this book and should be
avoided if possible.

Next, set Visibility to public to indicate that this attribute will be

defined in the public section. The Read-Only checkbox will make the
attribute read-only from outside of the class, but the attribute can still
be changed within your methods. Next, set Typing to Type and Asso-
ciated Type to I for integer.

The button to the right of the Associated Type column is used to cre-
ate complex types (Figure 6.20). Clicking that button will take you to
the public, private, or protected section so that you can add your own
custom attributes that aren’t defined in the ABAP Data Dictionary.

Figure 6.21 Viewing the Code Generated by the Form-Based View

Figure 6.20 Adding Attributes Using the Form-Based View

Obsolete Modularization
Now that you’ve added a method and some variables using the form-
based view, save your changes and click the Source Code-Based Now that you are familiar with modularizing your code using the
View button to see the automatically generated code (Figure 6.21). modern object oriented approach, we will also cover some of the
You will notice that the generated code still closely resembles what obsolete modularization techniques. You will need to be familiar with
you saw with the local classes. The only differences are some added these techniques when working with old code or may need to use
comments before the method and an added exclamation point (!) them for technical reasons.
before the method parameters. The exclamation point is an escape
symbol that allows you to use an ABAP keyword such as RETURNING as Function Modules
the name of a variable. Using function modules cannot be avoided in many ABAP programs,
because some of SAP’s standard functionality requires it in areas such
Any additional class examples in this book will only include the actual
as database table locks; however, you should never manually create
code, not the form-based view configuration. You should be familiar
new function modules. Any situation that calls for a function module
enough with classes by this point to use either the form-based view
to be created can use a global class instead. In fact, function modules
or the source code view interchangeably. We recommend using
were actually SAP’s first attempt at making ABAP object oriented.
Eclipse or the source code view exclusively.
With that said, it’s good to understand how function modules work,
because they’re prevalent in many customer systems and standard

248 249
 Making Programs Modular Obsolete Modularization
6 6

SAP code and may be required for technical reasons, such as creating In the New ABAP Function Group wizard, enter the package “$TMP” ABAP function group
a remote function call (RFC). to save it as a local object and enter “ZFG_FUNCTION_GROUP” for wizard
the function group name. The function group name will have to start
Function groups Similar to how methods are contained inside of a class, function mod-
with a Z as noted previously for programs and classes to indicate a
ules are contained inside of a function group. The function group is
custom function group. You can also prefix the name with “ZFG” to
created with two include files, one for global data (attributes in
indicate that it is a function group. Remember that the function
classes) and one that contains all of the function modules (methods in
groups are like classes, so the name should indicate the type of object
classes) in the group.
that the function group will be working with. Finally, enter a descrip-
Any global data or function group attributes will hold the same value tion, which may be used by other developers trying to find your func-
until the end of the program, but variables defined in the function tion group. An example of the correct values is shown in Figure 6.23.
module itself will only hold the same value until the end of the func-
tion call.

In your code, you call the function module itself instead of the group,
and there’s only one instance of the function group. This is unlike
class objects, which can have multiple instances, as was illustrated by
the car example in Figure 6.4.

Creating Function Groups and Modules in Eclipse

In Eclipse, you can create a new function group by selecting File 폷
New 폷 Other...; then expand the ABAP folder and select the option
for ABAP Function Group in the popup as highlighted in Figure
6.22, and click Next.
Figure 6.23 New ABAP Function Group Popup

The function group code displayed in Figure 6.24 shows the two INCLUDE
include files that make up the function group. The INCLUDE file ending
in “TOP” will contain any global data variables that will be accessible
by any of the function modules in the function group just like attri-
butes of a class are available for all of the class methods. The INCLUDE
ending in UXX will contain INCLUDEs for all of the function modules
created, which are just like class methods.

To create the function module, select File 폷 New 폷 Other..., expand Function module
the ABAP folder, and select ABAP Function Module. You can also
right-click the function group you just created from the Eclipse proj-
ect explorer and select New 폷 ABAP Function Module. This action
will open the New ABAP Function Module popup (Figure 6.25).
Figure 6.22 Creating a New ABAP Function Group

250 251
 Making Programs Modular Obsolete Modularization
6 6

the new function module should be contained in the Function

Group textbox, and click Next and then the Finish button.

The new function module should open, and you can enter any code
in between the FUNCTION and ENDFUNCTION keywords.

Figure 6.24 Code of a New Function Group

Figure 6.26 Newly Created Function Module in Eclipse

Just like class methods, function modules have IMPORTING, EXPORTING, Function module
and CHANGING parameters. These are defined in the function module parameters
by entering the type of parameter followed by a declaration of the
data type, as shown in Listing 6.21.

FUNCTION ZFM_NEW_FUNCTION_MODULE.
IMPORTING
ip_param TYPE i.
EXPORTING
ep_param TYPE i.
CHANGING
cp_param TYPE i.

Figure 6.25 New ABAP Function Module Popup ENDFUNCTION.

Listing 6.21 Adding Parameters to a Function Module

From the popup, enter “Z_NEW_FUNCTION_MODULE” for the func-

tion module name. Because the code does not call the function group You can also pass table parameters using the TABLES keyword, but this
but instead calls the function module directly, the function module is obsolete and unnecessary, because you can pass a parameter of a
name is global, and each name can only be used once. A good practice table type instead.
is to prefix the function module name with something indicating the
Creating Function Groups in Transaction SE80
function group name after the required “Z_” prefix.
If you are using Transaction SE80 as your ABAP IDE, select Function
Next, enter a description that describes what the function module Group from the dropdown in the center of left side of the screen,
does to benefit other developers trying to find your function module. type “ZFG_FUNCTION_GROUP” in the textbox below the dropdown
Finally, make sure that you enter the correct function group in which in the center left side of the screen, and press (Enter).

252 253
 Making Programs Modular Obsolete Modularization
6 6

You will be prompted with a popup asking if you want to create ZFG_ Figure 6.29). The INCLUDE files ending in TOP will contain any global
FUNCTION_GROUP because it doesn’t exist (Figure 6.27). Click the data variables that will be accessible by any of the function modules
Yes Button. in the function group. The INCLUDE ending in UXX will contain
INCLUDEs for all of the function modules created.

Figure 6.27 Create Function Group Popup

Creating a You’ll then be prompted with the Create Function Group popup Figure 6.29 New Function Group Files in SE80
function group pictured in Figure 6.28. Leave the function group name as ZFG_
FUNCTION_GROUP, and enter “New function group” in the Short
To create the function module, you can either select Function Mod- Creating a function
text textbox. The Short text and Function group values are used by module
ule from the dropdown, type “ZFM_NEW_FUNCTIONMODULE” in
other developers trying to find your function group, so they should
the textbox, and press (Enter), or you can right-click the zfg_func-
typically describe the type of data or objects that you’re working
tion_group folder and select Create 폷 Function Group.
with.
You will then see the Create Function Module popup pictured in
The Person Responsible field will default to your username. You can
Figure 6.30. From the popup, enter “Z_NEW_FUNCTION_MODULE”
leave this as is or change it, depending on your company’s standards.
for the function module name; unlike a global class method, it must
Next, click the Save button to continue.
be prefixed with Z. Because the code doesn’t call the function group
but instead calls the function module directly, the function module
name is global, and each name can only be used once. A good practice
is to prefix the function module name with something indicating the
function group name.

Next, ensure that Function group is set to the correct value; it should
be ZFG_FUNCTION_GROUP for this example. Finally, to benefit
other developers trying to find your function module, enter a descrip-
Figure 6.28 Create Function Group Popup tion of what the function module does in the Short text field; for this
example, enter “Creating a new function module”. Then, click Save.
In the Create Object Directory Entry popup, click the Local Object
button or enter “$TMP” for the package name, and click the Save but-
ton. For production function groups, you should use a package cre-
ated for your project.

Include files Your function group has now been created containing two include
files, which you should see listed on the left side of the screen (see Figure 6.30 Create Function Module Popup

254 255
 Making Programs Modular Obsolete Modularization
6 6

Function module You will now see a screen similar to the global class form-based view. Now, you can select the Source Code tab, where you will be able to
parameters Just like class methods, function modules have IMPORTING, EXPORTING, make changes to the function module, just as you made changes ear-
and CHANGING parameters. These are defined in the Import, Export, lier to the method of a global class.
and Changing tabs. Function modules also have a Tables tab used to
define parameters that are passed as tables, which is obsolete and Calling Function Modules
should be avoided. Instead of using the tables parameters, you should You can call a function module using the CALL FUNCTION keyword fol-
pass a table type in one of the other parameters. lowed by the function module name in single quotes ('). The param-
eters are passed by indicating the type of parameter and then the
To add the IMPORTING parameter, select the Import tab and enter “IP_
parameter name, equals sign, and the value that you want to pass to
PARAM” for the parameter name, “TYPE” for Typing and “I” for Asso-
the parameter. Like we saw with class methods, a parameter import-
ciated Type as shown in Figure 6.31. This will create an importing
ing into the function module is exporting from your code. The param-
parameter of IP_PARAM.
eters importing into your program are always optional when calling
a function module. An example calling Z_NEW_FUNCTION_MODULE is
shown in Listing 6.22.

DATA: d_i TYPE i.

CALL FUNCTION 'Z_NEW_FUNCTION_MODULE'
EXPORTING
Figure 6.31 Adding an Import Parameter to a Function Module ip_param = 1
IMPORTING
ep_param = d_i
Next, click on the Export tab and enter parameter “EP_PARAM” with CHANGING
Typing “TYPE” and Associated Type “I” as shown in Figure 6.32. cp_param = d_i.
Listing 6.22 Calling a Function Module

Some function modules will return a parameter or table indicating the

results of executing the function and any errors. Some function mod-
ules use exceptions to indicate whether or not the function call was
successful. We will cover these types of exceptions in Chapter 10.
Figure 6.32 Adding an Export Parameter to a Function Module
Form Subroutines
Finally, select the Changing tab and enter parameter “CP_PARAM” Form subroutines are probably the most commonly used way to mod-
with Typing “TYPE” and Associated Type “I”. ularize programs, even though they’ve been marked as obsolete in
ABAP documentation.

Subroutines are easy to create. They use the FORM keyword followed Perform
by the subroutine name to define the beginning of the subroutine
and ENDFORM to define the end of the subroutine. A subroutine can
be called using the PERFORM keyword followed by the subroutine
Figure 6.33 Adding a Changing Parameter to a Function Module name and will execute any code within that subroutine, as shown in

256 257
 Making Programs Modular Summary
6 6

Listing 6.23. No additional code can be entered after ENDFORM, just We then covered global classes, which can be called by any program
additional subroutines. in the system, and how to create them both in Eclipse and using
Transaction SE80 in SAP GUI.
PERFORM my_subroutine.
FORM my_subroutine. The chapter concluded by looking at some obsolete code modulariza-
WRITE: ‘Hello World’.
ENDFORM. tion techniques using function modules and subroutines. Even
Listing 6.23 Using a Subroutine though you shouldn’t be writing new subroutines and function mod-
ules, these are important to understand in order to maintain old
Declaring data in As with methods, local data can be declared within the subroutine ABAP systems.
a subroutine and will only be accessible within that subroutine. Subroutines can In the next chapter, you will take everything you’ve learned so far in
also import parameters with the USING keyword and change parame- the book and apply it to create a new custom application that will run
ters with the CHANGING parameter. These parameters work just like inside your ABAP system.
their function module and class-based counterparts. An example of a
subroutine with parameters is shown in Listing 6.24.

DATA: d_i TYPE i.

PERFORM my_subroutine USING d_i
CHANGING d_i.
FORM my_subroutine
USING up_param TYPE i
CHANGING cp_param TYPE i.

ENDFORM.
Listing 6.24 Subroutine with USING and CHANGING Parameters

Summary
This chapter covered some modularization concepts, such as using
separation of concerns to divide code into units that each complete
only one function, and introduced object-oriented programming as a
way to modularize code to meet the separation of concerns principle.

Remember that separation of concerns and object-oriented program-

ming make your code easier to read and understand for the next
developer who will have to look at it and fix any issues.

Next, you learned how to create classes and objects in ABAP. You dis-
covered how methods can be used not only to modularize your code
but also to make it compact through options such as recursive method
calls.

258 259
Contents

Introduction ................................................................................. 15

PART I The Foundation

1 The History of SAP Technologies ............................. 21

From R/1 to S/4 HANA ......................................................... 21
Navigating an ABAP System .................................................. 23
Overview of the ABAP Screen in SAP GUI ...................... 23
Overview of ABAP Screen in SAP NWBC ........................ 27
Overview of ABAP Screen in SAP Fiori ............................ 27
ABAP System Landscapes ..................................................... 28
Client/Server Architecture .............................................. 28
Background Jobs ............................................................ 29
Sandbox, Dev, QA, PRD ................................................. 31
Finding the Version of a System in SAP GUI .................... 33
The Limitations of Backward Compatibility ........................... 34
Summary .............................................................................. 36

2 Creating Your First Program .................................... 37

Hello, World! ........................................................................ 37
Creating a New Program with Eclipse ............................. 37
Creating a New Program in Transaction SE80 ................. 40
Writing a “Hello, World!” Program ................................. 44
Data Types ........................................................................... 46
The Data Keyword .......................................................... 46
Numeric Data Types ....................................................... 47
Character Data Types ...................................................... 49
Inline Data Declarations ................................................. 51
Arithmetic and Basic Math Functions .................................... 52
Arithmetic Operations .................................................... 52
Math Functions .............................................................. 54
Flow Control ......................................................................... 56
IF Statements ................................................................. 56
CASE Statements ............................................................ 59

7
Contents Contents

DO Loops ....................................................................... 60 Viewing the Flight Data .................................................. 116

WHILE Loops ................................................................. 60 Setting Up the Flights Example ....................................... 118
Formatting Code ................................................................... 61 Creating an Append Structure ........................................ 119
Comments ............................................................................ 63 Creating a Custom Transparent Table ............................. 122
Common Commenting Mistakes ..................................... 64 Data Elements ...................................................................... 130
Using Comments while Programming ............................. 64 Viewing the S_BOOK_ID Data Element .......................... 130
Classic Selection Screen Programming ................................... 65 Creating a New Data Element ......................................... 133
SELECTION-SCREEN ....................................................... 66 Domains ............................................................................... 135
BLOCK ........................................................................... 67 Viewing the BOOLEAN Domain ..................................... 136
PARAMETER .................................................................. 69 Creating a New Domain ................................................. 138
SELECT-OPTIONS ........................................................... 72 Documentation .................................................................... 140
Selection Texts ............................................................... 74 Maintenance Dialogs ............................................................ 141
Program Lifecycle ................................................................. 75 Structures and Table Types ................................................... 143
AT SELECTION-SCREEN ................................................. 75 Creating Structures ......................................................... 143
START-OF-SELECTION ................................................... 76 Creating Table Types ...................................................... 145
Debugging Basics .................................................................. 76 Summary .............................................................................. 146
Program to Debug .......................................................... 77
Breakpoints in Eclipse ..................................................... 79 4 Accessing the Database ........................................... 149
Breakpoints in the SAP GUI ............................................ 83
SQL Console in Eclipse .......................................................... 149
Watchpoints in Eclipse ................................................... 88
SELECT Statements ............................................................... 151
Watchpoints in SAP GUI ................................................. 91
Basic SELECT Statements ................................................ 151
Tying It All Together ............................................................. 92
SELECT SINGLE .............................................................. 153
The Problem ................................................................... 93
SELECT…UP TO n ROWS ............................................... 155
The Solution ................................................................... 94
SELECT…WHERE ............................................................ 155
Summary .............................................................................. 95
INSERT ................................................................................. 156
MODIFY/UPDATE ................................................................ 158
3 Creating Data Dictionary Objects ............................ 97
DELETE ................................................................................. 159
What Is a Data Dictionary? ................................................... 97 INNER JOIN ......................................................................... 160
What Is a Database? ....................................................... 97 LEFT OUTER JOIN ................................................................ 163
Data Elements ................................................................ 99 FOR ALL ENTRIES IN ............................................................ 165
Entity Relationship Diagrams ................................................ 100 With SELECT Options ........................................................... 167
Database Normalization ................................................. 101 New Open SQL .................................................................... 169
Relationships in ERDs ..................................................... 103 Table Locks ........................................................................... 170
The Flight Data Model .......................................................... 105 Viewing Table Locks ....................................................... 172
Flight Example ERD ........................................................ 105 Creating Table Locks ....................................................... 174
Creating and Editing Tables .................................................. 108 Setting Table Locks ......................................................... 175
Viewing the Flight Table Configuration ........................... 109 Performance Topics .............................................................. 179

8 9
Contents Contents

Obsolete Database Access Keywords .................................... 180 6 Making Programs Modular ...................................... 217
SELECT…ENDSELECT ..................................................... 181
Separation of Concerns ......................................................... 217
Short Form Open SQL .................................................... 181
Introduction to Object-Oriented Programming ..................... 220
Summary .............................................................................. 181
What Is an Object? ......................................................... 221
Modularizing with Object-Oriented Programming .......... 222
5 Storing Data in Working Memory ........................... 183 Structuring Classes ................................................................ 223
Using ABAP Data Dictionary Data Types ............................... 183 Implementation vs. Definition ........................................ 223
Data Types ..................................................................... 183 Creating Objects ............................................................. 224
Creating Your Own Structures ........................................ 185 Public and Private Sections ............................................. 225
Field Symbols ................................................................. 186 Class Methods ................................................................ 226
Standard Table ...................................................................... 188 Importing, Returning, Exporting, and Changing .............. 230
Defining Standard Tables ................................................ 188 Constructors ................................................................... 236
READ TABLE .................................................................. 190 Recursion ....................................................................... 237
LOOP AT ........................................................................ 193 Inheritance ..................................................................... 239
Inserting Rows in a Standard Table ................................. 195 Global Classes ....................................................................... 241
Changing Rows of a Standard Table ................................ 196 How to Create Global Classes in Eclipse .......................... 242
Deleting Rows of a Standard Table ................................. 197 How to Create Global Classes in Transaction SE80 .......... 243
Sorted Table ......................................................................... 199 Using the Form-Based View in Transaction SE80 ............ 245
Defining Sorted Tables ................................................... 199 Obsolete Modularization ...................................................... 249
Inserting, Changing, and Deleting Sorted Rows .............. 200 Function Modules .......................................................... 249
BINARY SEARCH ............................................................ 202 Form Subroutines ........................................................... 257
DELETE ADJACENT DUPLICATES FROM ........................ 204 Summary .............................................................................. 258
Hashed Table ........................................................................ 205
Defining Hashed Tables .................................................. 205 7 Creating a Shopping Cart Example .......................... 261
Reading Hashed Tables ................................................... 206
The Design ........................................................................... 262
Inserting, Changing, and Deleting Hashed Table Rows .... 207
The Database ................................................................. 263
Which Table Should Be Used? .............................................. 208
The Global Class ............................................................. 263
Updating ABAP Data Dictionary Table Type .......................... 210
The Access Programs ...................................................... 264
Copying Table Data .............................................................. 212
Database Solution ................................................................. 266
Displaying Data from Working Memory ................................ 213
Data Elements ................................................................ 266
Obsolete Working Memory Syntax ....................................... 214
Transparent Tables ......................................................... 271
WITH HEADER LINE ...................................................... 215
Accessing the Database Solution ........................................... 280
OCCURS ......................................................................... 215
Creating Classic Screens for the Solution ............................... 286
Square Brackets ([]) ........................................................ 215
Product Maintenance Program ....................................... 286
Short Form Table Access ................................................. 215
Shopping Cart Maintenance Program ............................. 290
Summary .............................................................................. 216
Summary .............................................................................. 295

10 11
Contents Contents

PART II Finishing Touches Updating the Global Class .............................................. 356

Updating the ABAP Programs ......................................... 358
8 Working with Strings and Texts .............................. 299 Summary .............................................................................. 361
String Manipulation .............................................................. 299
String Templates ............................................................. 299 10 Error Handling .......................................................... 363
String Functions ............................................................. 302
SY-SUBRC ............................................................................. 363
Text Symbols ........................................................................ 304
Message Classes ................................................................... 364
Creating Text Symbols .................................................... 304
Displaying a Message Class ............................................. 364
Translating Text Symbols ................................................ 309
Creating a Message Class ................................................ 367
Translating Data in Tables ..................................................... 311
Using the MESSAGE Keyword ........................................ 368
Obsolete Strings and Text ..................................................... 316
Exception Classes .................................................................. 372
Updating the Shopping Cart Example .................................... 316
Unhandled Exceptions .................................................... 373
Applying Text Symbols ................................................... 316
TRY/CATCH Statements .................................................. 378
Updating the Database ................................................... 319
Custom Exception Classes ............................................... 381
Using the Translation Table ............................................ 324
Obsolete Exceptions ............................................................. 386
Summary .............................................................................. 327
Non-Class-Based Exceptions ........................................... 386
Updating the Shopping Cart Example .................................... 389
9 Working with Dates, Times, Quantities, Summary .............................................................................. 392
and Currencies .......................................................... 329
Dates .................................................................................... 329 Appendices .................................................................... 393
Date Type Basics ............................................................ 330
A Preparing your Development Environment ........................... 395
Factory Calendars ........................................................... 331
B Modern UI Technologies ...................................................... 431
Datum Date Type ........................................................... 335
C Other Resources ................................................................... 439
System Date Fields ......................................................... 336
D The Author ........................................................................... 443
Date-Limited Records ..................................................... 336
Times .................................................................................... 337
Index ........................................................................................... 445
Calculating Time ............................................................. 338
Timestamps .................................................................... 338
SY-UZEIT (System Time vs. Local Time) ........................... 341
Quantities ............................................................................. 341
Data Dictionary .............................................................. 342
Converting Quantities .................................................... 344
Currencies ............................................................................ 345
Data Dictionary .............................................................. 346
Converting Currencies .................................................... 347
Updating the Shopping Cart Example .................................... 348
Updating the Database ................................................... 349

12 13
Index

$TMP, 43 Binary floating point, 49

Binary logic, 56
A BLOCK, 65–67
NO INTERVALS, 67
ABAP WITH FRAME, 67
backward compatibility, 34 WITH FRAME TITLE, 67, 287
code updates, 34 Boolean, 61
modern syntax, 36 yes/no user response, 72
obsolete code support, 35 Breakpoint, 77, 80
system implementation, 35 create, 84
ABAP and screen stack, 86 remote, 85
ABAP clients, 23 remove, 80
SAP Fiori, 23 Buffering, 179
SAP GUI, 23 options, 116
SAP NetWeaver Business Client, 23
ABAP Perspective C
select, 38
ABAP systems CALL SELECTION-SCREEN, 66
client/server architecture, 29 Cardinalities, 104, 125
program status, 30 CASE statements
abap_false, 61 WHEN, 59
abap_true, 61 WHEN OTHERS, 59
Activation log Chained statements, 45–46
warnings, 122 Character-based data types, 49
Aliases, 161 Check Table, 112
ALV, 213 Class
cl_salv_table, 214 definition, 280
SALV_OM_OBJECTS, 214 implementation, 283
ALV Grid Display, 117 Classic selection screen
Append Structure programming, 65
create, 119 Client, 29
Application table, 110 Cloud application library, 395
Arithmetic operations, 52 Clustered Tables, 108
AS, 161, 169 Comments, 63
AT SELECTION-SCREEN, 75 ", 63
event, 75 *, 63
Attributes, 131 mistakes, 64
Authorization group, 141 use in programming, 64
Constructor, 281, 284
B Crow’s foot notation, 103
Currencies, 345
b, 47–48 CONVERT_TO_LOCAL_
BEGIN OF SCREEN, 66 CURRENCY, 347
BETWEEN .. AND, 57 CUKY, 346

445
Index Index

Currencies (Cont.) Date (Cont.) E Flight data

CURR, 346 FACTORYDATE_CONVERT_TO_ model, 105
exchange rates, 345 DATE, 334 Eclipse view, 116
Currency/quantity, 114 GET TIME STAMP FIELD, 338 ABAP perspective, 38 Flight model
Custom Exception classes public holiday, 331 Create program, 37 load data, 118
CX_DYNAMIC_CHECK, 383 RP_CALC_DATE_IN_ create project, 40 FLUSH_ENQUEUE, 177
CX_NO_CHECK, 383 INTERNAL, 330 format code, 61 FOR ALL ENTRIES IN, 165
CX_STATIC_CHECK, 381–382 sy-datum, 336 open project, 38 Foreign key, 103, 112, 273
CX_SY_ILLEGAL_HANDLER, 383 sy-fdayw, 336 SQL console, 149, 152 cardinality, 125
CX_SY_NO_HANDLER, 382 sy-timlo, 341 E-commerce, 22 create, 125
Customizing table, 110 sy-tzone, 341 ELSE, 58 set, 124
sy-uzeit, 341 ELSEIF, 58 Format your code, 61
D sy-zonlo, 341 ENDDO, 60 Fully Buffered, 180
timestamp, 338 Enhancement category, 120, 127 Function
DATA, 46, 53–54, 57–61, 63, 72, 77 timestampl, 338 ENQUEUE, 175 ceil, 55
Data class, 127 type, 50 Entity, 101 floor, 55
types, 115 valid_from/valid_to, 336 Entity Relationship Diagrams R ERD frac, 55
Data Dictionary, 97, 99 Deadlock, 170 Entry help/check, 127 ipow, 55–56
Activation Log, 121 Debugging, 76 ERD, 101, 263, 319, 348 sign, 55
Data Element, 183 execution stack, 229 crow’s foot notation, relationship trunc, 55
Data elements, 99 decfloat, 47–49, 53–54, 77 indication, 103 Function group, 141, 250, 254
documentation, 140 Decimal floating point numbers, 48 normalized, 102 Function modules, 249, 255
domain, 99, 183 Decimal places, 48 Exception, 372 CALL FUNCTION, 257
table field, 183 DELETE, 159, 284, 289 500 SAP internal server error, 373 parameters, 253
translation, 312 FROM...WHERE, 285 CATCH BEFORE UNWIND, 381
transparent table, 98, 184 DELETE ADJACENT DUPLICATES CATCH...INTO, 379 G
Data element, 97, 99, 112, FROM, 204 categories, 381
130–131, 266 COMPARING, 204 CLEANUP, 380 Generic area buffered, 180
create new, 133 COMPARING ALL FIELDS, 204 custom exception classes, 381 GETWA_NOT_ASSIGNED, 187
predefined type, 131 DELETE TABLE, 197, 210 function modules, 386 Global class, 262
redundant, 102 hashed table, 208 non-class based exceptions, 386
search help, 132 sorted table, 202 RAISE EXCEPTION TYPE, 380 H
Data type, 112, 131 WHERE, 199 resumable exceptions, 381
numeric, 47 WITH TABLE KEY, 198 RESUME, 381 Hash board, 205, 210
structure, 186 Deletion anomaly, 102 short dump, 373 Hello World
Database Delivery and maintenance, 110 ST22, 375 add user input, 71
definition, 98 DEQUEUE, 172, 175, 178 TRY…CATCH, 378 chained statements, 45
normalization, 101–102 DIV, 53 unhandled, 373
Date Documentation, 140 Exclusive lock, 171 I
CL_ABAP_TSTMP, 341 Domain, 97, 135, 268, 270, 274 Execution stack, 81
CONVERT TIME STAMP, 339 BOOLEAN, 136 EXIT, 60 Identifying relationship, 103
DATE_CONVERT_TO_ create new, 138 IF Statement Operators, 56
FACTORYDATE, 333 range, 137 F AND, 57–58
date-limited record, 336 Dynamic breakpoints, 82 OR, 57, 59
datum, 335 Field, 111 Initial value, 46, 111, 156
Factory Calendars, 331 label, 132, 134 INITIALIZATION, 75
symbols, ASSIGN, 187

446 447
Index Index

Inline data declaration, 51, 153, Loop, 60 Object-oriented programming (Cont.) Parameter ID, 132
289, 293 infinite, 60 class definition, 223–224 Pooled tables, 108
INNER JOIN, 160, 163, 285 LOOP AT, 193 class implementation, 223–224 Primary key, 101, 111, 282
INSERT, 156, 195, 210 BINARY SEARCH, 202 CONSTRUCTOR, 236 Procedural programming, 218
hashed table, 207 hashed table, 207 CREATE OBJECT, 224 Program attributes
INDEX, 195 WHERE, 194 CREATE PUBLIC, 243 authorization group, 42
LINES FROM, 195 EXPORTING, 230, 234 editor lock, 42
sorted table, 201 M FINAL, 243 fixed point arithmetic, 42
Insert anomaly, 102 global classes, 241–242, 263 logical database, 42
Integrated development Maintenance dialog, 141 IMPORTING, 230, 233 selection screen, 42
environments, 395 MANDT, 106, 124, 126, 157, 189 INHERITING FROM, 239 start using variant, 42
Internal tables, 183, 208 Many-to-many relationship, 105 method, 221, 226, 228 status, 42
hashed table, 205, 209 Message class, 364, 371, 392 method chaining, 232 unicode checks active, 42
key, 189 &, 371 object, 221 Program lifecycle events, 75
SORT, 200 create, 367 OO-ABAP, 220 Promote optimistic lock, 171
sorted table, 199, 208 long text, 369 OPTIONAL, 233 Pseudocode, 283
standard table, 188, 208 MESSAGE, 368 private section, 225
INTO, 170 WITH, 371 protected section, 225, 240 Q
IS NULL, 156 Method, 300 public section, 225
ITAB_ILLEGAL_SORT_ORDER, 200 MOD, 53 READ-ONLY attributes, 226 Quantities, 341
Modalities, 104 recursion, 237 QUAN, 342
J MODIFY, 158, 210, 284, 289 REDEFINITION, 240 UNIT, 342
hashed table, 207 RETURNING, 230–231 UNIT_CONVERSION_SIMPLE, 344
Joins, 179 sorted table, 201 returning parameters, 236
Junction Table, 105 MODIFY TABLE, 196 subclass, 239 R
INDEX, 197 superclass, 239
K WHERE, 196 TYPE REF TO, 224 RAISE, 387
Modularize ABAP, 217 One-to-many relationship, 104 RAISING, 381–382
Key, 111 MOVE, 52 One-to-one relationship, 104 Ranges, 168
Key fields/candidate, 125 MOVE-CORRESPONDING, 212 Open SQL, 149 READ TABLE, 190, 210
MODIFY, 184 ASSIGNING, 190–191
L N Optimistic lock, 171 BINARY SEARCH, 202
Origin of the input help, 112 hashed table, 206
LEFT OUTER JOIN, 163 New Open SQL, 169 INDEX, 191
LENGTH, 50, 68–69 Nonidentifying relationship, 104 P INTO, 190–191
Lifecycle event, 75 NoSQL, 100 WITH KEY, 207
LIKE, 184, 189 NULL, 111 Package, 109 WITH TABLE KEY, 192
LINE OF, 184 Numeric data types, 47 Packed numbers, 48 Relational Database Management
LOAD-OF-PROGRAM, 75 PARAMETER, 65–66, 69 System (RDBMS), 100
Lock O AS CHECKBOX, 70 REPORT, 40, 44, 75, 77
mode, 172 AS LISTBOX VISIBLE LENGTH, 70
objects, 174 Object, 293 LOWER CASE, 287 S
parameter, 173 Object-oriented programming, 220 OBLIGATORY, 70, 291
Log data options, 116 attributes, 225 RADIOBUTTON GROUP, 70, S/4 HANA, 22
Logical storage parameters, 115 CHANGING, 230, 235 287, 291 SAIRPORT, 106
class, 222–224

448 449
Index Index

SAP BASIS, 28, 34 SFLIGHT, 107, 109 T Transactions (Cont.)

SAP Cloud Application Library, 396 append structure, 119 STMS, transport management
Amazon Web Services, 396 primary key, 111 Table system, 32
Microsoft Azure, 396 view data, 116 custom transparent, 122 Transparent Table, 97–98, 101, 108,
trial system, 395 Shared lock, 171 normalized, 107 122, 156, 188–189, 262–263
SAP ERP, 21 Short form technical settings, 114 create data element, 133
SAP Fiori, 27 [], 215 view single row, 153 Currency/Quanity Fields, 342, 346
SAP GUI, 23 LOOP AT, 215 Table column, 111 data elements, 130
application toolbar, 24 OCCURS, 215 Table configuration, 109 TYPE, 46, 53–54, 57–61, 63, 66,
breakpoints, 83 READ TABLE, 215 Table locks, 170 68–72, 75, 77, 185
developer user menu, 26 WITH HEADER LINE, 215 Table type, 143, 153, 186, 210
favorites menu, 25 Short form open SQL, 181 TABLES, 181 U
system information, 26 Sign, 168 Technical settings, 115, 127, 274, 279
toolbar, 24 Single quotes, 44 Text symbols, 67, 287, 292, 304, 317 UML, 264, 280
SAP HANA, 22, 27 Single records buffered, 179 comparison, 305 UPDATE, 158
SAP NetWeaver, 22 Size category, 127 translation, 309, 318 User Interface (UI), 65
SAP NetWeaver Business Space category, 116 Third normal form, 102
Client, 23, 27 SPFLI, 107 table, 103 V
SAP Transport Management START-OF-SELECTION, 75 Transactions, 24
System, 31 Event, 76 OB08, 345, 347 Value range, 137, 139
SAPBC_DATA_GENERATOR, 118 String, 49–51, 66, 68–72, 75 OY03, 345 Variable, 46
SAPBC_DATAMODEL, 106 ALIGN, 301 SE11, 109, 117, 122, 136, 138, 141, assign value to, 52
SBOOK, 107 chaining strings, 301 143, 145, 172, 174, 210, 266, chain together, 46
SCARR, 107 concat_lines_of, 303 268, 271, 274, 276, 319–320, naming, 47
Scope, 171 CONCATENATE, 316 342, 346, 349
SCUSTOM, 106 CONDENSE, 303 SE16, 116 W
Search help, 113 DECIMALS, 302 SE38, 118
SELECT, 151, 179, 285 SIGN, 301 SE63, 322 Watchpoints, 77, 88
*, 152 string functions, 302 SE63 Translation editor, 312 WHERE, 155, 165
INTO TABLE, 151 string literals, 299, 305 SE80, 280 WHERE IS NULL, 165
SELECT SINGLE, 153 string template, 300 SE80 ABAP Workbench, 40 WHERE..IN, 167
SELECT...UP TO n ROWS, 155 strlen, 302 SE80, create new program, 40 WHILE Loops, 60
SELECT…ENDSELECT, 181 substring, 303, 330 SE80, create program, 40 Whitespace, 53
Selection screen, 167, 291 substring_before, 303 SE80, format code, 62 Wireframe, 264, 286, 290
Selection screen keywords, 65 substring_from, 303 SE80, form-based view, 245 WRITE, 44, 57–61, 72, 76, 78
Selection text, 74, 287, 292 substring_to, 303 SE80, IDE settings, 44 Hello World, 44
SELECTION-SCREEN, 65 timestamp formatting, 340 SE80, source code view, 245
BLOCK…WITH FRAME TITLE, 291 WIDTH, 301 SE91, 364 Z
SELECT-OPTIONS, 65–66, 72, 112, Structure, 143, 156, 188–189 SM30, 141, 143
167 Subroutines, 257 SM37, background job selection, 30 ZBOOK, 107
High, 168 Form, 257 ST22, 375 Zero-to-many Relationship, 104
Low, 168 parameters, 258 Zero-to-one Relationship, 104
Option, 168 PERFORM, 257 ZSBOOK_SFLIGHT, 107
Separation of concerns, 217 sy-subrc, 193, 363, 387
Sessions, 24 sy-tabix, 193–194

450 451
 First-hand knowledge.

Brian O‘Neill is an ABAP developer with experience

working across different SAP ERP modules and custom
applications. He has worked in a variety of IT positions,
from business analyst to ABAP developer. He is cur-
rently writing applications that can connect to an SAP
backend using SAP Gateway. He holds a bachelor’s
degree in Computer Information Systems from Califor-
nia State University.

Brian O‘Neill We hope you have enjoyed this reading sample. You may recommend
Getting Started with ABAP or pass it on to others, but only in its entirety, including all pages. This
reading sample and all its parts are protected by copyright law. All usage
451 Pages, 2016, $49.95/€49.95
and exploitation rights are reserved by the author and the publisher.
ISBN 978-1-4932-1242-2
© 2016 by Rheinwerk Publishing, Inc. This reading sample may be distributed free of charge. In no way must the file be alte-

www.sap-press.com/3869
red, or individual pages be removed. The use for any commercial purpose other than promoting the book is strictly prohibited.