Understanding ABAP Object
Views (Total / Last 10 Days):
The object orientation can be defined as a problem-solving
method in which the software solution reflects objects in the real world.
Therefore, a comprehensive introduction to object orientation would go far
beyond the limits of this introduction to ABAP Objects as a whole.
An object can be defined as a section of source code that
contains data and provides services. The attributes of the object are formed by
the data. The services are known as methods (also known as operations or
functions). Typically, it is seen that the methods operate on private data (the
attributes, or state of the object), which is only visible to the methods of
the object. Thus, the attributes of an object cannot be changed directly by the
user, but by the methods of the object only. This guarantees the internal
consistency of the object.
The classes are very important, as they describe the
objects. From a technical point of view, the objects are runtime instances of a
class. One can create any number of objects based on a single class in theory.
Each instance (object) of a class has a unique identity and its own set of
values for its attributes.
|Features of Object Orientation|
According to this property, objects restrict the visibility
of their resources (attributes and methods) to other users. Every object has an
interface which plays a very important role. It determines how other objects
can interact with it. It is found that the implementation of the object is
encapsulated, which means that it is invisible outside the object itself.
According to this property, identical (identically-named)
methods behave differently in different classes. Object-oriented programming
contains constructions, which are called interfaces. They enable you to address
methods with the same name in different objects. The implementation of the
method is specific to a particular class, though the form of address is always
According to this property, one can use an existing class to
derive a new class. The data and methods of the super class are inherited by
the derived classes. However, they can overwrite existing methods and add new
|Uses of Object Orientation|
The object-oriented programming is quite useful in many
ways. It has various advantages, some of which are mentioned below.
Since object-oriented structuring provides a closer representation
of reality than other programming techniques, complex software systems become
easier to understand.
In object-oriented system, it should be possible to
implement changes at class level, without having to make alterations at other
points in the system. This reduces the overall amount of maintenance required.
The object-oriented programming allows reusing individual components
through polymorphism and inheritance.
In this system, the amount of work involved in revising and
maintaining the system is reduced as many problems can be detected and
corrected in the design phase.
To achieve these goals, the followings are required:
Object-oriented programming languages: The efficiency of
object-oriented programming depends directly on how object-oriented language
techniques are implemented in the system kernel.
Object-oriented tools: Object-oriented tools allow you to
create object-oriented programs in object Oriented languages. They also allow
you to model and store development objects and the Relationships between them.
Object-oriented modeling: The object-orientation modeling of
a software system is the most important, most time-consuming, and most
difficult requirement for attaining the above goals. These designs involve more
than just object-oriented programming and logical advantages that are
independent of the actual implementation are provided by it.
ABAP Objects is a new concept in R/3 System and you can find
its two distinct meanings --- one is for the entire ABAP runtime environment and
the other represents the new object-oriented generation of this language.
The Runtime Environment
ABAP Objects, for the entire ABAP runtime environment, are
an indication of how SAP has, for sometime, been moving towards object
orientation. Object-oriented techniques have been used exclusively in system
design. The ABAP language did not support these techniques earlier.
The ABAP Workbench will allow creating R/3 Repository
objects in this regard. These objects are programs, authorization objects, lock
objects, customizing objects, and so on and so forth. By using function
modules, one can also encapsulate functions in separate programs with a defined
lnterface. The Business Object Repository (BOR) allows you to create SAP
Business Objects for internal and external use.
The Object-Oriented Language Extension
ABAP Objects support object-oriented programming. The ABAP
Objects is a complete set of object-oriented statements, which has been
introduced into the ABAP language. This object-oriented extension of ABAP builds
on the existing language and is fully compatible with it.
The Object Orientation (OO), also known as the object-oriented
paradigm, is a programming model that unites data and functions in objects. You
can not only use ABAP Objects in existing programs, but also work with and use
a conventional ABAP in new ABAP Objects programs. The rest of the ABAP language
is primarily intended for structured programming, where data is stored in a
structured form in database tables and function-oriented programs access and
work with it.
Moreover, we should know that the object-oriented
enhancement of ABAP is based on the models of Java and C++. It is compatible
with external object interfaces such as DCOM and CORBA. The implementation of
object-oriented elements in the kernel of the ABAP language has considerably
increased response times when you work with ABAP Objects. Some other objects,
such as SAP Business Objects and GUI objects, which are already object-oriented
by themselves, are also benefiting from being incorporated into ABAP Objects.
The classes are templates for objects. An abstract
description of an object is the class. You could say it is a set of
instructions for building an object. The attributes of objects are defined by
the components of the class, which describe the state and behavior of objects.
Local and Global Classes
In ABAP Objects, classes can be declared either globally or
locally. You define global classes and interfaces in the Class Builder
(Transaction SE24.} in the ABAP Workbench. In the R/3 Repository, they are
stored centrally in class pools in the class library. In an R/3 System, all of
the ABAP programs can access the global classes. The local classes are defined
within an ABAP program. Local classes and interfaces can only be used in the
program in which they are defined. When you use a class in an ABAP program, the
system first searches for a local class with the specified name. If it does not
find one, then it looks for a global class. Apart from the visibility question,
there is no difference between using a global class and using a local class.
However, there is a significant difference in the way that
local and global classes are designed. If you are defining a local class that
is only used in a single program, then to define the outwardly visible
components so that it fits into that program is usually sufficient. On the
other hand, global classes must be able to be used anywhere. Since the system
must be able to guarantee any program using an object of a global class, it can
recognize the data type of each interface parameter and then certain
restrictions are applied at the time of defining the interface of a global
Defining Local Classes
Local classes consist of ABAP source code, where the ABAP
statements CLASS...ENDCLASS are enclosed. A complete class definition consists
of the following parts, a declaration part and, if required, an implementation
part. It is found that the declaration part of a class <class> is a
It contains the declaration for all components (attributes,
methods, events) of the class. When you define local classes, the declaration
part belongs to the global program data. Therefore, it should be placed at the
beginning of the program. If you declare methods in the declaration part of a
class, then you must write an implementation part for it. This consists of a
CLASS <class> IMPLEMENTATION
The implementation part of a class actually contains the
implementation of all methods of the class because it is observed that the
implementation part of a local class is a processing block. Therefore,
subsequent coding itself is not a part of a processing block and is not
A class contains components where each component is assigned
to a visibility section. Moreover, the classes implement methods. Let us define
these components one by one.
This is the first component and is declared in the
declaration part of the class. The components define the attributes of the
objects in a class. When you define a class, each component is assigned to one
of the three visibility sections. This defines the external interface of the
class and all of the components of a class are visible within the class. All
components are in the same namespace. This means that all components of the
class must have names that are unique within the class. There are two kinds of
components in a class:
One that exists separately for each object in the class.
The other consists of those that exist only once for the
whole class, regardless of the number of instances.
It is the instance-specific components, which are known as
instance components. The static components are those components that are not
instance-specific. The classes can define the following components in ABAP
The attributes are internal data fields that can have any
ABAP data type within a class. The state of an object is determined by the
contents of its attributes. One kind of attribute is the reference variable.
The reference variables are also very important as they allow you to create and
address objects. Reference variables can be defined in classes, which allow you
to access objects from within a class.
The instance-specific state of an object is defined by the
contents of instance attributes. They can be declared by using the DATA
The contents of static attributes define the state of the
class that is valid for all instances of the class. The static attributes exist
once for each class. It is declared using the CLASSDATA statement. They are
accessible for the entire runtime of the class. All of the objects in a class
can access its static attributes. If you change a static attribute in an
object, then the change is visible in all other objects of the class.
The methods are internal procedures that define the behavior
of an object in a class. They can access all the attributes of a class. This
allows them to change the data content of an object. They also have a "parameter
interface," whose role is to help the users by supplying them with values
when calling them and receiving values back from them. The private attributes
of a class can only be changed by methods in the same class. The definition and
parameter interface of a method is similar to that of function modules. Using
the following processing block, you define a method <meth> in the
definition part of a class and implement it in the implementation part:
In the same way as in other ABAP procedures (subroutines and
function modules), you can declare local data types and objects in methods. You
call the following methods by using the CALL METHOD statement.
You can declare instance methods by using the METHODS
statement. They play a very important role as they can access all of the
attributes of a class and can trigger all of the events of the class.
You can declare static methods by using the
CLASS-METHODS statement. They are important and can only access static
attributes and trigger static events.
Apart from normal methods, there are two special methods
which you call using CALL METHOD. These are called CONSTRUCTOR and CLASS
_CONSTRUCTOR. They are automatically called when you create an object
(Constructor) or when you first access the components of a class (CLASS
Objects or classes can use events to trigger event handler
methods in other objects or classes. One method can be called by any number of
users in a normal method call. When an event is triggered, any number of event
handler methods can be called. Until runtime, the link between the trigger and
the handler is not established. The calling program determines the methods that
it wants to call in a normal Method call and it must exist. With events, the
handler determines the events to which it wants to react. It is not necessary
that for every event there has to be a handler method registered.
With the help of RAISE EVENT statement, the events of a
class can be triggered in the methods of the same class. You can declare a
method of the same or a different class as an event handler method for the
event <evt> of class <class> by using the addition FOR EVENT
<evt> OF <class>. Events have a similar parameter interface to
methods, but only have output parameters. These parameters are passed by the
trigger (RAISE EVENT statement) to the event handler method, which receives
them as input parameters.
Using the SET HANDLER statement, the link between trigger
and handler is established dynamically in a program. The trigger and handlers
can be objects or classes, depending on whether you have instance or static
events and event handler methods. When an event is triggered, the corresponding
event handler methods are executed in all registered handling classes.
The three visibility areas (public section, protected
section, private section) are the basis for one of the important features of
object orientation, Encapsulation. You should take great care in designing the
public components and try to declare as few public components as possible when
you define a class. Once you have released the class, the public components of
global classes may not be changed.
Public attributes are visible externally and form a part of
the interface between an object and its users. If you want to encapsulate the
state of an object fully, then you cannot declare any public attributes. Apart
from defining the visibility of an attribute, you can also protect it from
changes using the READ-ONLY addition.
Inheritance allows you to derive a new class from an
existing class. It is done by using the INHERITING FROM addition in the
CLASS <subclass> DEFINITION INHERITING FROM <superclass>
All of the components of the existing class
<superclass> are inherited by the new class <subclass>. The new
class is called the subclass of the class from which it is derived. The
original class is called the superclass of the new class. It contains the same
components as the superclass if you do not add any new declarations to the
subclass. However, in the subclass only the public and protected components of
the superclass are visible. The private components of the superclass are not
visible though they exist in the subclass. You can declare private components
in a subclass that have the same names as private components of the superclass.
It is seen that each class works with its own private components. The another
point that we note is that methods which a subclass inherits from a superclass
use the private attributes of the superclass and not any private components of
the subclass with the same names.
The subclass is an exact replica of the superclass if the
superclass does not have any private visibility section. However, you can add a
new component to the subclass because it allows you to turn the subclass into a
specialized version of the superclass. If a subclass is itself the superclass
of further classes, then you can introduce a new level of specialization.
Reference variables are defined with reference to a
superclass or an interface defined with reference to it can also contain
references to any of its subclasses. A reference variable defined with
reference to a superclass or an interface implemented by a superclass can
contain references to instances of any of its subclasses, since subclasses
contain all of the components of all of their superclasses and also convey that
the interfaces of methods cannot be changed. In particular, you can define the
target variable with reference to the generic class OBJECT.
Using the CREATE OBJECT statement, when you create an object
and a reference variable typed with reference to a subclass then you can use
the TY PE addition to which the reference in the reference variable will point.
A reference variable can be used by a static user to address
the components visible to it in the superclass to which the reference variable
refers. However, any specialization implemented in the subclass cannot be
addressed by it.
Depending on the position in the inheritance tree at which
the referenced object occurs, you can use a single reference variable to call
different implementations of the method. This is possible only if you redefine
an instance method in one or more subclasses. This concept is called
polymorphism, in which different classes can have the same interface and,
therefore, be addressed using reference variables with a single type.
I have explained object orientation which is such an
important aspect in SAP. The discussion began with the features of Object
Orientation and includes the runtime environment, the language extension, the
classes and the class components. Apart from that I have also discussed for new
first time readers event handling, inheritance encapsulation and polymorphism.