Академический Документы
Профессиональный Документы
Культура Документы
Article level:
Intermediate
Technology areas discussed:
Custom Development
ABAP Objects, the object-oriented (OO) extension to the ABAP language, is available with
releases 4.5 and 4.6. Release 4.6 adds inheritance, nested interfaces, and dynamic method
invocation. In this article, as two of the developers of this new extension, we’ll take you through
an introduction to ABAP Objects and give you a comprehensive example (The code for the
example can be tested and debugged in DEMO_ABAP_OBJECTS in R/3 release 4.6 or higher).
ABAP Objects is a nearly 100 percent upward-compatible extension of ABAP that includes a full
set of OO features. We left out some obsolete language elements in the OO context within
classes (so it is not truly 100 percent compatible), but you can use objects in all contexts without
any restrictions.
We created ABAP Objects because:
• The business object repository (BOR) already presented an OO view of the system to the
outside, and we wanted a common programming model for both outside and inside.
• We wanted the potential benefits of objects within R/3, including better control of complexity, a
better means for encapsulation, extensibility, and reuse, and a language basis for patterns and
frameworks.
• We wanted seamless integration with external object models (DCOM and CORBA).
• We needed objects to be the foundation for a new GUI programming model (to be completed in
release 5.0).
At the beginning of the ABAP Objects project, we faced a fundamental question: Should we add
OO features to the existing ABAP language, invent a completely new language, or integrate an
existing OO language into R/3? We opted to integrate OO features into the existing ABAP
language to create ABAP Objects for several reasons:
• It meant we would immediately inherit all the other features of the R/3 infrastructure such as
software logistics, portable database access, TP monitor capabilities, and all database buffering
and scalability.
• Certain features, such as persistence, transactions, events, and GUI frameworks, are hard to add
on top of a language. This results in lots of generated code. To support these concepts, you must
have your own compiler or interpreter and runtime, ruling out most off-the-shelf languages.
• Our target was a language for business applications. We wanted it to be simpler than Java and
C++ and to leave out complex concepts lacking in benefits.
• By integrating the concepts of OO languages—as opposed to using a specific OO language—
into ABAP, we were able to combine the best concepts from these languages and adapt them,
when needed, to our specific needs.
Our main design goals were:
•To make ABAP Objects as simple as possible
•To use only proven OO concepts
•To comply with external standards whenever possible (for example, to allow mapping to COM,
CORBA, and UML)
•To require much stronger typing (type checking) than traditional ABAP, where type
specification is almost always optional.
The Design Environment
When designing ABAP Objects, we faced some special R/3-specific challenges:
•Extreme variability—R/3 is a meta-application that is massively configurable and extendable by
five layers.
•R/3 is an interpretive system, so there is never a shutdown-change-recompile-restart cycle.
•Software development logistics allow hundreds of developers to work on the same system parts,
and logistics must not be hindered by the language. The change process must be considered and
supported by certain language features (mostly resulting in some deliberate deviations from the
general strong typing policy). You cannot assume that developers can always perform
synchronous global changes in the system.
Some of ABAP Objects’ key design elements include:
•Classes are not structures with methods (as in C++) but a new kind of type.
•Reference semantics for objects. ABAP is completely value-based. There are no references in
the language, and a MOVE always copies its values (even with field-symbols). Objects, on the
other hand, can only be accessed by references (there are no embedded objects). This results in a
clear separation of values and references. An object reference always has reference semantics.
This is the only place in ABAP where objects are shared and never copied. Values (the traditional
data) are always copied.
•Single inheritance with a separate concept of interfaces. Here we follow a path similar to Java.
Most multiple inheritance applications are actually interface cases, and the few extra capabilities
of multiple inheritance definitely don’t warrant the complexity this introduces into the language.
•ABAP Objects integrates complex concepts, most notably events and dynamic method
invocation. Events are introduced similarly to how they exist in Visual Basic. They are outbound
methods that can have parameters. This is a natural model for GUI applications. We also
separated the event registration into a separate statement (SET HANDLER), which gives you the
flexibility to define all kinds of topologies of sender-to-handler connections (1:1, 1:n, n:1, n:m).
•Of course, ABAP Objects has its own storage management (garbage collection) and a suite of
tools such as the Class Builder, Class Browser, and debugger support.
With release 4.6, the ABAP language is pretty much complete with all object components,
inheritance, and nested interfaces. Two main areas of ABAP Objects are still under development:
A new GUI programming model and GUI design tool, and the Object Services framework that
covers persistence, transaction control, and locking. These should be completed by release 5.0.
ABAP Objects Basics
ABAP Objects is based on classes. Classes are pieces of program code that describe objects by
defining their components. Typical object components are attributes (data), which describe an
object’s state, and methods (functions), which describe an object’s behavior. Objects are
instances of classes. Many objects can be created from one class, but each object has its own
attributes.
ABAP Objects provides a set of new statements that defines classes and handles objects. These
statements can be used in any kind of ABAP program.
Classes, and therefore objects, consist of at least two layers—an inner and an outer layer. The
externally visible layer of an object is made up of public components. Public components can be
accessed directly by all users and form an object’s external point of contact. Private components
are only visible within objects of the same class. The public section usually contains few
attributes. The state of an object is generally kept in private attributes and manipulated by public
methods. This way an object can ensure its own consistency.
Outside ABAP Objects, the only instances in ABAP are instances of whole ABAP programs such
as reports, module pools, or function groups. Each time a program is executed, a program
instance is implicitly created, which then runs in a separate ABAP process. Calling an external
procedure (a subroutine or a function module) also creates an ABAP program instance, which
contains the procedure. However, repeated calls always use the same one instance. Such program
instances live as long as the application program is running and cannot be handled explicitly.
With ABAP Objects, it is now possible to explicitly handle instances. The instances of classes,
namely objects, are created explicitly with ABAP statements. They have a unique identity
(independent of their attribute values) and are addressed by references. They live only as long as
they are needed.
Classes. Classes are templates for objects. You can either define a class locally in an ABAP
program, or globally in the class library using the Class Builder tool in the ABAP Workbench.
The class library is part of the R/3 repository. Class library classes are stored in special programs
called class pools. A class pool is automatically generated for each global class that you create
with the Class Builder. The Class Builder also generates the coding frame that defines the classes
in the class pool. Global classes are visible to all ABAP programs of the R/3 System.
To define local classes in an ABAP program, such as a report or a function group, you must type
the corresponding statements manually into the program. A local class is visible only inside the
program in which it is defined.
Classes are defined between the CLASS and ENDCLASS statements. A class definition consists
of a declaration part, in which the components are defined, and an implementation part, in which
the methods are implemented.
Component visibility. Each component must be declared in one of three possible visibility
sections. All components declared in the PUBLIC SECTION can be accessed by all clients of
the class. All components declared in the PROTECTED SECTION can be accessed in the
methods of the class and its subclasses (see inheritance). All components declared in the
PRIVATE SECTION can only be accessed in the methods of the class. The public section forms
the outer layer, or external interface, of the class. The protected and the private sections form the
inner layer. Their components cannot be accessed by external users.
Class components. Possible class components are attributes, methods and events. Events will be
explained later in this article.
•Attributes: are the internal data variables within a class. They can have any ABAP data type.
We distinguish between instance attributes and static attributes. Instance attributes are declared
by DATA and determine the state of an instance. You cannot work with instance attributes
without creating an object first. Static attributes are declared by CLASS-DATA and determine
the state of a class, which in a way applies to all instances. Static attributes form a data set that is
shared by the whole class and all of its objects. You do not need to create an object to work with
static attributes.
•Methods: are the class’ procedures. They can access all class attributes and can therefore
change the state of an object. They have a parameter interface similar to the interface of function
modules. They can have named IMPORTING, EXPORTING, and CHANGING parameters, which
can be optional or required and can be passed either by reference or by value. As with attributes,
we distinguish between instance methods and static methods. Instance methods are declared by
METHODS and can access all the attributes of a class. Static methods are declared by CLASS-
METHODS and can only access the static attributes of a class.
Listing 1, defines a class vessel. The components of class vessel are the attributes speed,
max_speed, object_count, and id, and the methods constructor, drive, and get_id.
CLASS vessel DEFINITION.
PUBLIC SECTION.
METHODS:
constructor,
drive IMPORTING speed_up TYPE i,
get_id RETURNING value(id) TYPE i.
PROTECTED SECTION.
DATA: speed TYPE i,
max_speed TYPE i VALUE 100.
PRIVATE SECTION.
CLASS-DATA object_count TYPE i.
DATA id TYPE i.
ENDCLASS.