INSTANTIATION AND OBJECT-

ORIENTED LANGUAGE
Multiple instances(objects) of the same blue
print (type or class) are a fundamental
attribute of object-oriented languages
The ability to create multiple instances of a
class, such as a vehicle, is one of the
central attributes of object-oriented
languages.
OBJECT ORIENTED
PROGRAMMING MODEL
ABSTRACTION
This refers to the ability to reflect real-world processes as realistically in the
programming language as possible.
ENCAPSULATION
Implementation details are hidden behind well-defined and
documented interfaces. Implementation of the objects are hidden from
other components in the system
INHERITENCE
Classes, are derived from existing ones. They inherit all the attributes
and methods of the higher-level class and can expand and specialize
them.
POLYMORPHISM
Different Objects can present the same interface to the outside. A user
only needs to know the interface, by using this, he can access various
classes without knowing the details. Objects in different classes react
differently to the same messages.


Object Orientation - Advantages
Complex software systems become easier to understand,
since object-oriented structuring provides a closer
representation of reality than other programming
techniques.
In a well-designed 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.
Through polymorphism and inheritance, object-oriented
programming allows you to Re-use individual
components.
The amount of work involved in revising and maintaining
the system is reduced, since many problems can be
detected and corrected in the design phase.

Classes

Classes describe objects.
From a technical point of view, objects are
runtime instances of a class.
In theory, you can create any number of
objects based on a single class.
Each instance (object) of a class has a
unique identity and its own set of values for
its attributes.

Object References

In a program, you identify and address
objects using unique object references.

Object references allow you to access the
attributes and methods of an object.
CLASSES AND OBJECTS
CLASS
General description of
objects(blueprint).

Specifies status
data(attributes) and
behavior(methods).
OBJECT(INSTANCE)
Representation of real
world.

Specific instance of a class.

Two different objects can
have identical attribute
values and still not be
identical.

LOCAL/GLOBAL
CLASSES
LOCAL CLASSES
Local Classes can be defined within any ABAP program and are only visible
there.
GLOBAL CLASSES
Global Classes are created with the Class Builder tool of the ABAP
workbench in the Class Library and are visible to any ABAP program.

Incidentally, it is unimportant whether you use local or global classes to create
objects, except that they differ in their visibility.
Objects of local classes can only be created in the same program, whereas
objects of global classes can be created in any ABAP program.
CLASS DEFINITION
DECLARATION
CLASS C1 DEFINITION.
Public Section.

Protected Section.

Private Section.

ENDCLASS.
IMPLEMENTATION
CLASS C1 IMPLEMENTATION.
METHOD M1.

ENDMETHOD.

METHOD M2.

ENDMETHOD.
ENDCLASS.

The class statement cannot be nested.
VISIBILITY SECTIONS
PUBLIC
All components which are assigned to this section are public and can
be addressed by all users, methods of subclasses and methods of the
class itself.They form the external interface of the class.
PROTECTED
The components of this section are protected and can be addressed by
the methods of subclasses and the methods of the class itself. They
form the interface of the class to its subclasses.
PRIVATE
Components of this section are private and can only be used in the
methods of the class itself.
COMPONENTS OF THE CLASS
ATTRIBUTES
Attributes are the data objects within a class. The reflect an Objects state.
INSTANCE ATTRIBUTES: DATA statement
STATIC ATTRIBUTES: CLASS-DATA statement.
A READ-ONLY addition can be used with both DATA stmt.
METHODS
The way in which objects behave is implemented in the methods of a class.
INSTANCE METHODS: can access all attributes and events of their own class.
STATIC METHODS: can only access static attributes and static events.
CONSTRUCTOR
It is the special method which can be of two types:
INSTANCE CONSTRUCTOR: implicitly called for each instantiation of a new object.
STATIC CONSTRUCTOR: is called the first time the class is accessed.
EVENTS
All methods of the same class can trigger these events. Other methods of the same or
the different class can be declared as special handler methods which react to these
events.


ATTRIBUTES, TYPES AND
CONSTANTS
CLASS <CLASSNAME> DEFINITION.

TYPES: <NORMAL TYPE DEFINITION>
CONSTANTS: CONSTANT TYPE <TYPE> VALUE <VALUE>.
DATA: VAR1 TYPE <TYPE>,
VAR2 TYPE <DDIC_TYPE>,
VAR3 TYPE VAR1,
VAR4 TYPE <TYPE> VALUE <VALUE>,
VAR5 TYPE <TYPE> READ ONLY,
VAR6 TYPE REF TO <CLASSNAME>,
VAR7 TYPE REF TO <INTERFACE>,
CLASS-DATA: ONLY_ONCE TYPE
ENDCLASS

Attributes
Instance Attributes:
The contents of instance attributes define the instance
specific state of an object. You declare them using the
DATA statement.

Static Attributes:
The contents of static attributes define the state of the class
that is valid for all instances of the class.
Static attributes exist once for each class.
You declare them using the CLASS-DATA 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, the change is
visible in all other objects in the class.

Methods
Instance Methods
You declare instance methods using the METHODS
statement.
They can access all of the attributes of a class, and can
trigger all of the events of the class.
Static Methods
You declare static methods using the CLASS-METHODS
statement.
They can only access static attributes and trigger static
events.
Special Methods
As well as normal methods, which you call using CALL
METHOD, there are two special methods called
CONSTRUCTOR and CLASS_CONSTRUCTOR, which
are automatically called when you create an object
(CONSTRUCTOR) or when you first access the
components of a class (CLASS_CONSTRUCTOR).

METHODS
PARAMETER INTERFACE
The parameter interface of a method is defined by the additions to the
METHODS statement in the declaration part of the class.
The implementation part does not require any more details for the parameter
interface.
the complete syntax for defining the parameter interface is:

METHODS meth
[ IMPORTING <im_var> TYPE <type>
EXPORTING <ex_var> TYPE <type>

CHANGING <ch_var> TYPE <type>
RETURNING VALUE <re_var> TYPE <type>
RAISING <class_exception> ].

All input parameters(IMPORTING, CHANGING parameters) can be
defined as OPTIOAL or DEFAULT.

INSTANCE AND STATIC
METHODS
STATIC METHODS
Can only use Static
components in their
implementation part.

Can be called using the
Class.


INSTANCE METHODS
Can use both static and
instance components in
their implementation part

Can be called using an
instance



Class Example (1 of 3)
(Defining the class)
CLASS c_airplane DEFINITION.
* defining the access specifiers.
PUBLIC SECTION.
CONSTANTS: pos_1 TYPE i VALUE 30.
* parameterized method
METHODS: set_attributes IMPORTING im_name TYPE string
im_planetype TYPE string.
* method
METHODS: display_attributes.
* static method.
CLASS-METHODS: display_n_o_airplanes.
PRIVATE SECTION.
DATA: name TYPE string,
planetype TYPE string.
* static variable.
CLASS-DATA: n_o_airplanes TYPE i.
ENDCLASS. "c_airplane DEFINITION


Class Example (2 of 3)
(Implementing the class)
Type-pools icon.
CLASS c_airplane IMPLEMENTATION.
* presenting the logic the methods.
METHOD set_attributes.
name = im_name.
planetype = im_planetype.
n_o_airplanes = n_o_airplanes + 1.
ENDMETHOD. "set_attributes
METHOD display_attributes.
WRITE: / icon_ws_plane AS ICON,
/ 'Name of Airline: '(001), AT pos_1 name,
/ 'Airplane Type'(002), AT pos_1 planetype.
ENDMETHOD. "display_attributes
METHOD display_n_o_airplanes.
WRITE: / 'Total Number of planes ',
AT pos_1 n_o_airplanes LEFT-JUSTIFIED.
ENDMETHOD. "display_n_o_airplanes
ENDCLASS. "c_airplane IMPLEMENTATION

Class Example (3 of 3)
(Using the class)
data: plane_name type string,
plane_type type string.
data: obj_air_plane type ref to c_airplane. defining the object.

start-of-selection.
create object obj_air_plane. creating the object.

plane_name = 'JET AIRWAYS'.
plane_type = 'BOEING 747'.
* calling the methods using the instance object.
obj_air_plane->set_attributes( im_name = plane_name
im_planetype = plane_type ) .
* calling the methods using the instance object.
obj_air_plane->display_attributes( ) .
* calling the class name --> static method..
c_airplane=>display_n_o_airplanes( ) .


CONSTRUCTOR
A Constructor is a special method which is automatically
executed by the runtime environment.
Constructors are used to set an object dynamically to a
defined initial state.
A constructor cannot be called with the CALL METHOD
statement , nor can the developer influence the call point.
Like other methods constructors can be instance
dependent or instance-independent.
It must be declared in the PUBLIC section of the class
declaration.

INSTANCE CONSTRUCTOR
Instance Constructors are called once for each instance of a class after
the complete creation of the instance with the CREATE OBJECT
statement.
It must be declared in the definition part of the class.
It must have the predefined name CONSTRUCTOR
METHODS CONSTRUCTOR
IMPORTING {VALUE (i
1
)|i
2
} {TYPE type| LIKE dobj}
[OPTIONAL|DEFAULT def
i
]


EXCEPTIONS x
i

The fact that the constructor does not have the output parameters
shows that it is used solely to define an objects status and has no other
purpose.

STATIC CONSTRUCTOR
The Static Constructor is called in a program once for each
class before the class is accessed for the first time.
The name of the Static Constructor with which it is
declared and implemented is class_constructor.
CLASS-METHODS class_constructor
No interface parameters can be defined for a static
constructor.
Like all other static methods, static constructors can only
access static attributes of their class.

CREATING OBJECTS
Objects are created using CREATE OBJECT statement.
Objects can only be created and addressed using reference
variables.

DATA: <obj1> TYPE REF TO <class1>
CREATE OBJECT <obj1>

CREATE BOJECT statement creates an object in the Main
memory.
The attribute values of this of this object are either initial
values or correspond to the VALUE entry.


INHERITANCE


LCL_SUP1 LCL_SUP2
LCL_SUB1 LCL_SUB2 LCL_SUB3
NO MULTIPLE
INHERITANCE
G
e
n
e
r
a
l
i
z
a
t
i
o
n

S
p
e
c
i
a
l
i
z
a
t
i
o
n

Inheritance

You can use an existing class to derive
a new class.
Derived classes inherit the data and
methods of the Super classes.
However, they can redefine existing
methods, and also add new ones.
RELATIONSHIP BETWEEN
SUPERCLASS AND SUBCLASS
Common Components only exist once in the superclass.
New components in the superclass are automatically
available in subclasses.
Amount of new coding is reduced

Subclasses are extremely dependent on superclasses
White Box Reuse:
Subclass must possess detailed knowledge of the
implementation of the superclass.
INHERITANCE
Class lcl_veh Definition
Public Section.

Private Section.

Endclass.
Class lcl_truck Definition
INHERITING FROM lcl_veh
Public Section.

Private Section.

Endclass.

All Components from the superclass are
automatically present in the subclass.
REDEFINING METHODS
Class lcl_vehicle DEFINITION.
PUBLIC SECTION.
METHODS: estimate_fuel
IMPORTING im_dist TYPE s_dist
RETURNING VALUE (re_fuel) ty_fuel
Endclass.

Class lcl_truck DEFINITION INHERITANCE FROM lcl_vehicle
PUBLIC SECTION.
METHODS: estimate_fuel REDEFINITION.
Endclass.

Class lcl_truck IMPLEMANTATION.
METHOD estimate_fuel.

Super -> estimate_fuel()
ENDMETHOD.
Endclass.

REDIFINING METHODS
The REDEFINITION statement for the inherited method
must be in the same SECTION as the definition of the
original method.(It cant be in Private section).
If you redefine a method, you dont need to enter its
interface again in the subclass, but only the name of the
method.
ABAP Objects dont support Overloading.
Overloading is possible with the constructor.
With the redefined method, you can access the components
of the direct Superclass using the SUPER reference.
INHERITANCE AND REDEFINING
THE CONSTRUCTOR
The Constructor of the superclass must be called within the
constructor of the subclass(to ensure that the objects are
initialized correctly).
The Static Constructor in the super class is called
automatically. The runtime system ensures that the static
constructor of all its superclasses have already been
executed before the static constructor in a particular class
is executed.

RULES FOR CALLING THE
CONSTRUCTOR
CASE 1
Class of instance to be
created has constructor.
Fill its parameters

CASE 2
Class of instance to be
created has no constructor.
=> Search for the next
superclass with a
constructor in the
inheritance tree.
=> Fill its parameters.
INTERFACES
In ABAP objects, interfaces are implemented in addition to
and independently of classes.
Interfaces only describe the external point of contact of a
class, they dont contain any implementation.
Features:
Simulation of Multiple inheritance
Black Box Principle: client only knows the
interface, not the implementation.
Interface as a generalization of the implementing
class.
DEFINING AND
IMPLEMENTING INTERFACE
Declaring the interface
INTERFACE lif_partners.
METHODS: display_partner.
ENDINTERFACE.
The Server classes make the interface public.
CLASS lcl_rental DEFINITION.
PUBLIC SECTION.
INTERFACES lif_partners.
ENDCLASS.
Interface are implemented in classes.
Interface dont have visibility sections.
CLASS lcl_rental IMPLEMENTATION.
METHOD lif_partners~display_partner.

ENDMETHOD.
ENDCLASS.


ABSTRACT CLASSES
Abstract classes themselves cannot be instantiated.
Although their subclasses can.
Abstract(instance) methods are defined in the class, but not
implemented.
They must be redefined in subclasses.
Classes with at least one abstract method are abstract.

STATIC METHODS AND CONSTRUCTORS CANT
BE ABSTRACT.


FINAL CLASSES
Final Classes cant have subclasses and can therefore protect
themselves from specialization.
Class lcl_truck DEFINITION FINAL
INHERITING FROM lcl_vehicle.

Endclass.
Final Methods cant be redefined in subclasses and can protect itself in
this way against uncontrolled redefinition.
Class lcl_bus DEFINITION FINAL
INHERITING FROM lcl_vehicle.
PUBLIC SECTION.
METHOD estimate_number_of_seats FINAL.
Endclass.
SUMMARY
A final class implicitly only contains final methods. In this
case you cannot enter FINAL explicitly in these methods.
Methods cannot be both FINAL and ABSTRACT.
Classes, on the other hand, that are both ABSTRACT and
FINAL can be useful.


FRIENDS CONCEPT
In rare cases, Classes have to work together closely and make all their
components, including the private and protected ones, available to each
other.
Efficient direct access to the data of a class providing friendship.
Methods that access the same data can therefore be spread over
several classes.
Friendship is ONE-SIDED: A class providing friendship is not
automatically a friend of its friend.
Class lcl_truck DEFINITION FRIENDS lcl_bus.

Endclass.
All the subclasses of class lcl_bus have access to data of lcl_truck, the
other way is not possible.

Reference Variable ME
Within a class, you can use the self-reference
ME to access the individual components:
To access an attribute in the same class
ME -> <attr>
To call a method in the same class
CALL METHOD ME -> <meth>
Self references allow an object to give other
objects a reference to it.


Example (1 of 4)
Class Definition.
CLASS cl_airplane DEFINITION.
PUBLIC SECTION.
CONSTANTS: pos_1 TYPE i VALUE 30.
METHODS: set_attributes IMPORTING " Instance Methods
im_name TYPE string
im_planetype TYPE saplane-planetype,
display_attributes.
CLASS-METHODS: display_n_o_airplanes. " Static Methods

PRIVATE SECTION.
DATA : name TYPE string,
planetype TYPE saplane-planetype. " Instance Attributes

CLASS-DATA: n_o_airplanes TYPE i. " Static Attributes
ENDCLASS. "c_airplane DEFINITION
Example (2 of 4)
Class Implementation
CLASS cl_airplane IMPLEMENTATION.
METHOD set_attributes.
DATA: name TYPE string VALUE 'AIRBUS',
planetype TYPE saplane-planetype VALUE 'A-320'.
IF im_name IS INITIAL AND im_planetype IS INITIAL.
name = name.
me->planetype = planetype.
me->n_o_airplanes = me->n_o_airplanes + 1.
ELSE.
me->name = im_name.
me->planetype = im_planetype.
n_o_airplanes = n_o_airplanes + 1.
ENDIF.
ENDMETHOD. "set_attributes



Example (3 of 4)
METHOD display_attributes.
WRITE : / 'Name of airplane:'(001), AT pos_1 name,
/ 'Airplane type: '(002), AT pos_1 planetype.
ENDMETHOD. "display_attributes


METHOD display_n_o_airplanes.
WRITE: /,/ 'Total number of planes'(cal),
AT pos_1 n_o_airplanes LEFT-JUSTIFIED, /.
ENDMETHOD. "display_n_o_airplanes
ENDCLASS. "c_airplane IMPLEMENTATION


Example (4 of 4)
Creating class reference and accessing the class
attributes & methods
DATA: r_plane TYPE REF TO cl_airplane. " creating the class reference

START-OF-SELECTION.

CREATE OBJECT r_plane.

CALL METHOD r_plane -> set_attributes( im_name = 'BOEING'
im_planetype = '747-200' ).

CALL METHOD r_plane -> display_attributes( ).

CALL METHOD cl_airplane => display_n_o_airplanes( ) .