abap objects 1oo

8/10/2019 Abap Objects 1oo

1/149

1

ABAP Objects


2/149

2

Topics to cover

Why Object oriented ABAP?

Class, objects, Methods & Constructor

Inheritance, Polymorphism

Events & Exceptions

Real time usage of ABAP Objects

Limitations


3/149

3

Different approaches of Programming

Unstructured Programming.

Procedural Programming.

Object Oriented Programming.


4/149

4

Unstructured Programming

Consists of only one main program.

The program stands for a sequence of

commands which modify data that isglobal throughout the whole program.

Characteristics

Difficult to manage once the programbecomes large.

Same sequence of statements arerepeated at multiple places, if they areneeded at multiple locations.

Disadvantages

report ysubdel.DATA : sal type p decimals 2,

itax type p decimals 2,net_sal type p decimals 2 .

sal = 12000.IF sal lt 5000 .itax = 0.

ELSE.itax = sal * '0.01'.

ENDIF.net_sal = sal - itax.

write:/5 sal , itax , net_sal.

sal = 3500.IF sal lt 5000 .

itax = 0.ELSE.

itax = sal * '0.01'.ENDIF.

net_sal = sal - itax.write:/5 sal , itax , net_sal.


5/149

5

Procedural Programming

A procedure call is used to invoke theprocedure.

After the sequence is processed, flow

of control proceeds right after theposition where the call was made.

report ysubdel.

DATA : sal type p decimals 2 ,

itax type p decimals 2 ,

net_sal type p decimals 2.

sal = 12000.

PERFORMsub_calc_tax USING

sal itax net_sal.

sal = 3500.

PERFORMsub_calc_tax USING

sal itax net_sal.

FORMsub_calc_tax USINGP_SAL P_ITAX P_NET_SAL.

IF p_sal lt 5000 .

p_itax = 0.

ELSE.

p_itax = sal * '0.01'.

ENDIF.

p_net_sal = p_sal - p_itax.

write:/5 sal , itax , net_sal.ENDFORM.


6/149

6

Evolutions in ABAP as a programming

language

In seventies ABAP stood for General ReportPreparation Processor.

In mid eighties ABAP had developed into an

interpreter languagewhich was a main component of

the R/2 system and which could cope up with

business application programs.

In early nineties, ABAP evolved as a 4thgeneration

programming language.


7/149

7

SAP Approach towards ABAP


8/149

8

Evolutions in ABAP as a programming

language

At the turn of the new century, ABAP completed anew stage in its evolution by ABAP/4 superseded by

ABAP objects.

Questions still unanswered:

What are the implications by introducing ABAP

objects? How did it superseded ABAP which is still

catering customer needs in many ways???? Did ABAP objects madeABAP/4 obsolete?


9/149

9

Implications of introduction of ABAP

Objects

ABAP objects and ABAP are inextricablylinked.

Drift froma structural programming approach towards

Object oriented approach

But to keep you comfortable,ABAP is still supported

and allows you to use object-oriented elements.

Questions Unanswered:

Then why should I learn ABAP objects?

Why dont I use the classical approach?


10/149

10

Are ABAP Objects mandatory?

Continue our Technical consultancy career in SAP without bottlenecks

Should be able to provide solutions to heterogeneous

kinds of client technical requirements related to

Program involving in

multiple functionalrequirements

Reuse available

Standard/Customclasses in ABAP

Business Server Pages GUI Control Framework

Office Integration XML Transformations

BADI, Workflow Email, Shared Objects,Persistent objects

Generic Programming New ABAP Editor,

Code Inspector, CATT


11/149


12/149

12

Object OrientationWhat are Objects?

You interact with objectseveryday

A customer

An order

All objectscontains state and behavior

What they can do and what changes when they do

Software objectsrepresent these as:

Data ( like 4GL variables )

Methods ( like 4GL procedures)

Your car

The telephone


13/149

13

What's an Object and Class?

. Booch's object definition:An object has state, behavior, and identity; the

structure and behavior of similar objects are defined

in their common class; the terms instance and object

are interchangeable.Ex: ICICI S.Acc#1111, ICICI S.Acc#1112, ICICI

S.Acc#9999,

. Booch's class definition:

A class is a set of objects that share a common

structure and a common behavior.

Ex: ICICI S.Acc.


14/149

14

Some Classes & Their ObjectsMaruthi 800 Rajas Maruthi,

Prasads Maruthi,

Ramanis Maruthi

Customer ABC,XYZ

SalesOrder OR2643789, OR2643799

OR2643776, OR9999999

Cricket Team IndianTeam, Australian Team,

SrilankanTeam

Your Desktop PC 12345 etc.


15/149

15

Object-oriented Programming

Object-or iented programm ing is a method of

imp lementation in wh ich p rograms are organized

as cooperat ive col lect ions of objects, each of

which represents an instance of some class...

Grady Booch


16/149


17/149

17

Object-oriented

Application Development

A way to design and build applications

Objectsbundle together data (state) and

methods (behavior)

Objects facilitate separating definition from

implementation

Much more than just syntax

You might have already done object-oriented

programming in the 4GL


18/149

18

Sample Attributes & Methods

Class Attributes MethodsCricketTeam Captain,

VC, WC,

FB1,FB2,FB3

SP1,SP2,SUB

DoSingle,DoDouble

DoBowl,DoCatch

DoRunout,HitSix,

Doplay,HitBowndaryICICI S.A. Account

Number,

Balance,

CreditLimit

CheckBooks

ATM_Transfer,

E_transfer, Withdraw,

Check_Credit_limit,

Issue_check_book,

Track_transactions

Production PO#,SSD,SED,

ASD,AED,Com

p,CoOptn,Oper

,Workcenter

Start_Production,End_pro

duction,Start_opr,Send_t

o_WS Etc


19/149


20/149

20

Abstraction

Abstractionis used to manage complexity

Focus on the essential characteristics

Eliminate the details Find commonalities among objects

Defines the public contract

Public definition for users of the object

The Outside view Independent of implementation

Publ ic View of an Ob ject


21/149

21

Abstraction - Example

Object: Automobile

Start

Stop

Drive

PumpFuel

What should an

Automobile

object do?


22/149

22

Encapsulation

Encapsulat ionhides implementation

Promotes modular software designdata and

methods together

Data access always done through methods Often called information hiding

Provides two kinds of protection:

State cannot be changed directly from outside Implementation can change without

affecting users of the object

Hide Implementat ion Details


23/149

23

Encapsulation- Example

Public

methods of

Splendor class

Implementation OutsideView

Start(),Stop()

PumpFuel(),

Change_gear()

Object: Splendor

EngineNum,

Gear#,

Fuel_MrtRd,

SpeedometrRd

StartEngine(),StopEngine(),Cosu

mePetrol(),

Move_Wheel()

Start(),Stop()

PumpFuel(),

Change_gear()


24/149

24

Encapsulation - Example continued

Object: Splendor

EngineNum,

Gear#,

Fuel_MrtRd,

SpeedometrRdStartEngine(),StopE

ngine(),Consume_P

etrol(),

Move_Wheel()

Start(),Stop()

Pump_Fuel(),

Change_gear()

Hmm...

Id like to change

Consume_petrol to

Consume_diesel

Consume_fuel() calls

Consume_Petrol( )


25/149

25

Encapsulation - Example continued

This change was easybecause users of the

object will not beaffected.

Object: Splendor

EngineNum,

Gear#,

Fuel_MrtRd,

SpeedometrRdStartEngine(),

StopEngine(),Consu

me_Diesel(),

Move_Wheel())

Start(),

Stop()

Pump_Fuel(),

Change_gear()

Consume_fuel() callsConsume_Diesel( )


26/149

26

Hierarchies

Define relationships between objects

Objects defined in terms of other objects

Allows state and behavior to be shared and

specialized as necessary Encourages code reuse

Two important hierarchy types:

Inheritance

Aggregation

Object Relat ionships


27/149

27

Hierarchies - Example

Automobile

2-Wheerler,3-Wheeler and

4-Wheerler

inherit from

Automobile

(Inheritance)

2-Wheeler 3-Wheeler

is a is a

4-Wheeler

is a


28/149

28

Hierarchies - Example

Automobile

Engine

references

Automobile

uses Engine(Aggregation)


29/149

29

Summary : Object-oriented Principles

Abstraction

Break up complex problem

Focus on public view, commonalities

Encapsulation Hide implementation details

Package data and methods together

Hierarchies

Build new objects by combining or extending

other objects


30/149

30

ABAP Object Oriented Programming

Class defined andimplemented

Classes and objects areused to model real worldentity.

Methods inside the classesperform the functions.

Data used by the classesare protected between them.


31/149

31

ABAP Object Oriented Programming

Method implementationCalling a Method

Creating an Object

Defining a Referrence


32/149

32

Comparison between Procedural and Object Oriented

Programming

Features Procedure Oriented

approach

Object Oriented approach

Emphasis Emphasis on tasks Emphasis on data

Modularization Programs are divided

into smaller programsknown as functions

Programs are organized

into classes and objectsand the functionalities are

embedded into methods

of a class.

Data security Most of the functions

shareglobal data

Data can be hiddenand

cannot be accessed byexternal sources.

Extensibility Relatively more time

consuming to modify

for extending existing

functionality.

New data and functions

can be easily added

whenever necessary


33/149

33

Object Oriented Approach - key features

1. Better Programming Structure

2. Real world entity can be modeled very well

3.Stress on data security and access

4. Data encapsulation and abstraction

5. Reduction in code redundancy


34/149


35/149

35

Object Oriented Design(OOD)

Five Major Steps

1. Identify the objects and their attributes

2. Identify the operations suffered by and required of each

object

3. Establish the visibility of each object in relation to other

objects

4. Establish the interface of each object

5. Implement each object


36/149

36

Lets Design


37/149

37

DAY 2


38/149

38

Classes

Classes are templates for objects. Conversely,you can say that the type of an object is the sameas its class.

componentsof the class describe the state andbehavior of objects.

Local and Global Classes: Classes in ABAPObjects can be declared either globally or locally.You define global classes and interfaces in theClass Builder (Transaction SE24) in the ABAP

Workbench. They are stored centrally in classpoolsin the class library in the R/3 Repository.


39/149

39

Classes

Local classes are defined within an ABAP program. Local

classes and interfaces can only be used in the program inwhich 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, it then looks for a global class. Apart from the visibility question, there is no difference

between usinga global class and using a local class.

Certain restrictionsapply when you define the interface of

a global class, since the system must be able to guarantee

that any program using an object of a global class can

recognize the data type of each interface parameter.


40/149

40

Classes

Defining Local Classes:

A complete class definition consists of adeclaration part and, if required, animplementation part.

The declaration partof a class

CLASS DEFINITION....ENDCLASS.

It contains the declaration for all components

(attributes, methods, events) of the class. The declaration part belongs to the global

program data.


41/149

41

Classes

If you declare methods in the declaration part of a

class, you must also write an implementation part

for it. This consists of a further statement block:

CLASS IMPLEMENTATION.

...ENDCLASS

The implementation part of a local class is a

processing block. Subsequent coding that is not

itself part of a processing block is therefore notaccessible.


42/149

42

Defining Local Classes

REPORT YSUBOOPS17 .

CLASSc1 DEFINITION.

PUBLIC SECTION.

data : w_num type i value 5.

methods : m1.

ENDCLASS.

CLASS c1 IMPLEMENTATION.

METHOD M1.

WRITE:/5 'I am M1 in C1'.

ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA : oref1 TYPE REF TO c1 .

CREATE OBJECT : oref1.

write:/5 oref1->w_num.

CALL METHOD : oref1->m1 .

Defined in the global areaof a local program :-

CLASS DEFINITION.

..

ENDCLASS.

All the attributes ,methods, events andinterfaces are declared here.

Cannot be declared inside asubroutine/function module.

Class definition cannot benested.


43/149

43

Implementing Local Classes

Local class in a program is implemented asfollows:-

CLASS IMPLEMENTATION.

..

ENDCLASS.

Methods used by the class are described here.

A class can be implemented

At the end of the program( like subroutines).

After the class definition.

If the latter is adopted, one must then assignsubsequent non-declarative statements explicitlyto a processing block, such asSTART-OF-SELECTION, so that they can be accessed.

REPORT YSUBOOPS17 .

CLASSc1 DEFINITION.

PUBLIC SECTION.

data : w_num type i value 5.

methods : m1.

ENDCLASS.

CLASSc1 IMPLEMENTATION.

METHOD M1.

WRITE:/5 'I am M1 in C1'.

ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA : oref1 TYPE REF TO c1 .


write:/5 oref1->w_num.

CALL METHOD : oref1->m1 .


44/149

44

Different places of implementing class

Class implemented at the end of

the programClass implemented after Definition


45/149

45

Classes

Structure of a Class

The following statements define the structure of a

class:

A class contains components

Each component is assigned to a visibilitysection

Classes implement methods


46/149

46

Classes : Class Components

All components are declared in the declaration part of the

class.

When you define the class, each component is assigned to

one of the three visibility sections, which define the

external interfaceof the class.

All of the components of a class are visible within theclass.

Instance components exist separately for each objectin

the class

static components exist only once for the whole class,

regardless of the number of instances.

Allcomponents that you can declare in classes can also

be declared in interfaces


47/149

47


Attributes:

Attributes are internal data fieldswithin a class that can

have anyABAP data type.

The stateof an object is determined by the contents of its

attributes.

One kind of attribute is the reference variable. Referencevariables allow you to create and address objects.

Instance Attributes:DATA

Static Attributes: CLASS-DATA

Static Attributes are accessible for the entire runtime of theclass.


48/149

48


Methods

Methods are internal procedures in a class that define the behaviorof anobject.

They can access all of the attributes of a class. This allows them to changethe data content of an object.

They are similar to function modules or procedures.

The private attributes of a class can only be changed by methods in thesame class.

In Definition Part Instance Methods: METHODS .

Instance Methods can access all the attributes of a class and can trigger allthe events of a class.

Static Methods : CLASS-METHODS . Theycan onlyaccess static attributesand trigger static events.

Inimplementation Part.

METHOD ....

ENDMETHOD.


49/149

49


Special Methods:

CONSTRUCTOR: Cannot call with CALL METHOD statement.

Called automatically when you create an object

CLASS_CONSTRUCTOR:

Called when you first access the components of a class

Events: Objects or classes can use events to trigger event

handler methodsin other objects or classes.

When an event is triggered, any number of event handlermethods can be called.

the handler determinesthe events to which it wants toreact. There does not have to be a handler methodregistered for every event.


50/149

50


The events of a class can be triggered in the methods of

the same classusing the RAISE EVENT statement.

The event handler methods can be of the same or a

different class.

FOR EVENT OF . Addition

Eventshave a similar parameter interface to methods, butonly have outputparameters.

These parameters are passed by the trigger (RAISE

EVENT statement) to the event handler method, which

receives them as input parameters.

The link between trigger and handler is established

dynamically in a program using the SET HANDLER

statement.


51/149

51


The trigger and handlers can be objects or classes,

depending on whether you have instance or static eventsand event handler methods.

When an event is triggered, the corresponding eventhandler methods are executed in allregistered handlingclasses.

Instance Events:EVENTS keyword. An instance event can onlybe triggered in an instance

method.

Static Events: CLASS-EVENTS

All methods (instance and static methods) can triggerstatic events.

Static events are the only type of event that can betriggered in a static method.


52/149

52


Types:

You can define your own ABAP data types within

a class using the TYPES statement.

Types are not instance-specific, and exist once

only for all of the objects in a class.Constants:

Constants are special static attributes.

You declare them using the CONSTANTS

statement.

Constants are notinstance-specific


53/149

Sections of a There is no default visibility section in a class.


54/149

54

Class

CLASS C1

DEFINITION.PUBLICSECTION.

DATA:

METHODS:

EVENTS:

PROTECTEDSECTION.

DATA:

METHODS:

EVENTS:

PRIVATESECTION.

DATA:

METHODS:

EVENTS:

ENDCLASS.

A Class puts its components

under three distinct sections:-

Public Section:-Componentsplaced here form the external

interface of the classthey are

visible to all users of the class as

well as to methods within the

class and to methods of

subclasses*

Protected Section:- Components

placed in protected section arevisible to the children of the

class(subclass) as well as within

the class

Private Section:-Componentsplaced here are accessible by the

y

This sequence of visibility must be maintainedin a class


55/149

55

Who can use a class?

class c2 definition inheritingfrom c1.

public section .methods : m2.

endclass.

class c2 implementation.

method m2.

write:/5 From subclass' ,w_num.

endmethod.

endclass.

REPORT YSUBOOPS17 .

CLASS c1 DEFINITION.

PUBLIC SECTION.

data : w_numtype i value 5.

methods m1.

ENDCLASS.


method m1.

write:/5 From class : ' , w_num.

endmethod.

ENDCLASS.

START-OF-SELECTION.

DATA :

oref1 TYPE REF TO c1 ,

oref2 type ref to c2 .


write:/5 As an user ' ,

oref1->w_num.

Call method oref1->m1.

Call method oref2->m2.

Classitself

Subclass

of the

class

External user


56/149

56

Classes


57/149

57

ClassesREPORT demo_class_counter .

CLASS counter DEFINITION.

PUBLIC SECTION.METHODS: set IMPORTING value(set_value) TYPE i,

increment,

get EXPORTING value(get_value) TYPE i.PRIVATE SECTION.

DATA count TYPE i.

ENDCLASS.

CLASS counter IMPLEMENTATION.

METHOD set.

count = set_value.

ENDMETHOD.

METHOD increment.

ADD 1 TO count.

ENDMETHOD.METHOD get.

get_value = count.

ENDMETHOD.

ENDCLASS.

DATA number TYPE i VALUE 5.

DATA cnt TYPE REF TO counter.

START-OF-SELECTION.CREATE OBJECT cnt.

CALL METHOD cnt->set EXPORTING set_value = number.

DO 3 TIMES.

CALL METHOD cnt->increment.

ENDDO.

CALL METHOD cnt->get IMPORTING get_value = number.

WRITE number.


58/149

58

Two Additions in Local Class Definition

Addition 1 : CLASS class DEFINITION DEFERRED.

Used to refer to a class at some point in a code and the class is notdefined before the line.

CLASS C2 DEFINITION DEFERRED.

CLASS C1 DEFINITION.

PUBLIC SECTION.

DATA O2 TYPE REF TO C2.

ENDCLASS.

CLASS C2 DEFINITION.

public section.

data : num type i value 5.

ENDCLASS.

start-of-selection.data : obj1 type ref to C1.

CREATE OBJECT obj1.

create object obj1->o2.

write:/5 obj1->o2->num .


59/149

59

Two Additions in Local Class Definition

Addition 2 : CLASS class DEFINITION LOAD

The compiler normally loads the description of a globalclass fromthe class librarythe first time you use the class in your program .However, if the first access to a global class in a program is to its

static componentsor in the definition of an event handler method,you must load it explicitly using the statement CLASS classDEFINITION LOAD. This variant has no corresponding ENDCLASSstatement.

PUBLIC|PROTECTED|PRIVATE
http://sapevent/http://sapevent/


60/149

60

PUBLIC|PROTECTED|PRIVATE

ADDITIONS

Syntax :CLASS DEFINITION [CREATE

PUBLIC|PROTECTED|PRIVATE]

CREATE PUBLICaddition is implicit in every class definition if the other CREATEadditions are not used. It defines the default state, that is, that every user can create

instances of the class.

Addition ofCREATE PROTECTEDmeans the class can only be instantiated byitself or its subclass.

Addition ofCREATE PRIVATEmeans the class can only instantiate itself or thefriends of the class can instantiate it.


61/149

61

Object Handling

Each object has a unique identity and its own attributes.

Object References To access an object from an ABAP

program, you use object references. Object references are

pointers to objects. In ABAP, they are always contained in

reference variables.

A reference variable that points to an object knows theidentity of that object. Users cannot access the identity of

the object directly.

Reference variable can occur as a component of a

structure or internal table as well as on its own.

There are two principal types of references: Class

referencesand interface references


62/149

62

Object Handling

... TYPE REF TO

Creating Objects CREATE OBJECT .

Addressing the Components of Objects:

You can access the instance components of an object

using references in reference variablesonly. To access an attribute : ->

To call a method : CALL METHOD ->

You can access staticcomponents using the class nameas well as the reference variable.

It is also possible to address the static components of aclass beforean object has been created.


63/149

63

Object Handling

Addressing a static attribute : =>

Calling a static method : CALL METHOD

=>

Within a class, you can use the self-reference MEto

access the individual components:

To access an attribute in the same class: ME->

To call a method in the same class: CALL

METHOD ME->

Self references allow an object to give other objects areference to it.You can also access attributes in methods

from within an object even if they are obscured by local

attributes of the method.


64/149

64

Object Handling

Assigning References

When you assign a reference to a different

reference variable, their types must be either

compatible or convertible.

= and refer to same class.

type ref to root class OBJECT.

Inheritance & Interface situations.

Class OBJECT is just a container. You cannot

access components of class with OBJECT

reference


65/149


66/149

66

Object Handling


67/149

67

Declaring and Calling Methods

Declaring Methods :

You can declare methods in the declaration part of a classor in aninterface.

To declare instance methods, use the following statement:

METHODS

IMPORTING.. [VALUE(][)] TYPE type

[OPTIONAL]..EXPORTING.. [VALUE(][)] TYPE type[OPTIONAL]..

CHANGING.. [VALUE(][)] TYPE type[OPTIONAL]..

RETURNING VALUE()

EXCEPTIONS.. ..and the appropriate additions.

To declare static methods, use the following statement:

CLASS-METHODS ...

Both statements have the same syntax.


68/149

68


The default way of passing a parameter in a

method is by reference. To pass a parameter by value, you must do so

explicitly using the VALUE addition.

The return value (RETURNING parameter) must

always be passed explicitly as a value.If you useit, you cannot use EXPORTING or CHANGINGparameters.

You can use exception parameters

(EXCEPTIONS) to allow the user to react to errorsituations when the method is executed.


69/149

69


Implementing Methods :

METHOD .

...

ENDMETHOD.

Static methods can work with only the static attributes of a

class.Calling Methods :

CALL METHOD EXPORTING... =....

IMPORTING... =....

CHANGING ... =....

RECEIVING r = h

EXCEPTIONS... = rc i...


70/149


71/149

71

Static Method

oLike any other class components , methods canbe static or instance.

oTo declare static methods, use the following

statement:

CLASS-METHODS ...

oStatic methods can have import and ( export/changing parameters ) or returning parameters . It

can also raise exceptions.

oStatic methods can only work with the static

attributes of your class. Instance methods can

work with both static and instance attributes.

oOne can call a static method using an object ofthe class or directly using the class by class

component selector.


72/149

72


Within the implementation part of a class,use

CALL METHOD ...

Visible instance & static methods can be called from

outside the class using

CALL METHOD ->...

Visible static methods can be called from outside the classusing

CALL METHOD =>...

where is the name of the relevant class.

You need not import the output parameters into yourprogram using the IMPORTING or RECEIVING addition.C


73/149

73


If the interface of a method consists only of a

single IMPORTING parameter, you can use

CALL METHOD ( f).

The actual parameter is passed to the input

parameters of the method. If the interface of a method consists only of

IMPORTING parameters, you can use

CALL METHOD (.... =....).


74/149

74

Dynamic Method Calls

Instance, self-referenced, andstatic methods can all be calleddynamically; the class name forstatic methods can also be

determined dynamically: oref->(method)

me->(method)

class=>(method)

(class)=>method

(class)=>(method)

D l i d C lli M h d


75/149

75


Event Handler Methods :

Event handler methods cannot be called using the CALLMETHOD statement.Instead, they are triggered usingevents.

You define a method as an event handler method usingthe addition

... FOR EVENT OF ...in the METHODS or CLASS-METHODS statement.

The interface may only consist of IMPORTINGparameters.

Each IMPORTING parameter must be an EXPORTINGparameter of the event

The attributes of the parameters are defined in thedeclaration of the event (EVENTS statement) andare adopted by the event handler method.

D l i d C lli M th d


76/149

76


Constructors:

Constructors are special methods that cannotbe calledusing CALL METHOD.

They are called automaticallyby the system to set thestarting stateof a new object or class.

Constructors are methods with a predefined name.

To use them, you must declare them explicitlyin theclass.

Instance constructor : You declare it in the public section asfollows:

METHODS CONSTRUCTORIMPORTING.. [VALUE(][)] TYPE type

[OPTIONAL]..EXCEPTIONS.. .

and implement it in the implementation section like anyother method.

D l i d C lli M th d


77/149

77


The system calls the instance constructoronce for each

instance of the class, directly afterthe object has beencreated in the CREATE OBJECT statement.

You pass the parameters to the constructor and handle the

exceptions in CREATE OBJECT stmt.

static constructor : CLASS-METHODS CLASS_CONSTRUCTOR.

The static constructor has noparameters.

The system calls the static constructor once for each class,

beforethe class is accessed for the first time.

The static constructor cannottherefore access the

components of its own class.

I t C t t


78/149

78

Instance Constructor

Executed once for each instance.

Called automatically, immediately after theCREATE OBJECT statement.

Can contain an interface with

IMPORTINGparameters andEXCEPTIONS, but cannot haveanyEXPORTING/CHANGING/RETURNINGparameters .

The interfaces are defined using the same

syntax as for normal methods in theMETHODS statement. To transferparameters and handle exceptions, use theEXPORTINGandEXCEPTIONSadditionsto the CREATE OBJECTstatement.

Static Constructor


79/149

79

Static Constructor

Static methods, declared as CLASS-METHODS:

CLASS_CONSTRUCTOR in the public section of the class

definition and are also implemented in the

implementation part.

Has no interface parameters and cannot trigger

exceptions.

Executed once in each program.It is calledautomatically for the class before it is accessed for

the first time- that is, before one of the following

actions:

CREATE OBJECT obj from the class.

Call a static method : [CALL METHOD] class=>meth.

Registering a static event handler method using SET

HANDLER class=>meth for obj.

Registering an event handler method for a static event

of the class class.

Addressing a static attributewith class=>a.

REPORT YSUBOOPS2.CLASS c1 DEFINITION .

PUBLIC SECTION.CLASS-DATA : NUM TYPE I VALUE 5.

CLASS-METHODS:CLASS_CONSTRUCTOR.

ENDCLASS.


METHOD CLASS_CONSTRUCTOR.WRITE:/5 'I am class

constructor'.

ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

WRITE:/5 C1=>NUM.

S lf R f
http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/http://sapevent/


80/149

80

Self-Reference

Internally, each method has an implicit self-

reference variable, the reserved word me

A method can access the components of its

class simply by their name; however,

It may use mesimply for clarity

If a method declares a local variable with

the same name as one of the class

components, to avoid ambiguity it must

use meto address the variable originally

belonging to the class.

A method must use me to export a

reference to itself (that is, its object)


81/149

81

DAY 3

I h it


82/149

82

Inheritance

Inheritance allows you to derive a new class from an

existing class. CLASS DEFINITION INHERITING FROM

.

The new class inherits allof the components

of the existing class . However, only the publicand protectedcomponents of

the super class are visiblein the subclass.

You can declare privatecomponents in a subclass that

have the same namesas privatecomponents of the

super class.Each class works with its own privatecomponents.


83/149

83

Creating Subclass

Subclasses can be created from its

superclass using the syntax:-

CLASS DEFINITIONINHERITING FROM .

Subclass inherits all the public and protected

components of the superclass.

Superclass should not be declared as a

FINAL class.

Inheritance


84/149

84

Inheritance

You can add new components to the subclass.

This allows you to turn the subclass into aspecialized versionof the super class.

A class can have more than one direct subclass,

but it may only have one direct super class. This

is called single inheritance.

The root node of all inheritance trees in ABAP

Objects is the predefined empty classOBJECT.

Inheritance


85/149

85

Inheritance

Redefining Methods: you can use the REDEFINITION

addition in the METHODS statement to redefine aninherited public or protected instancemethod in a

subclass and make its function more specialized.

The implementation of the redefinition in the subclass

obscures the original implementation in the super class.

Any reference that points to an object of the subclass uses

the redefined method, even if the reference was defined

with reference to the superclass.

This particularly applies to the self-reference ME->.

Within a redefined method, you can use the pseudoreference SUPER-> to access the obscured method.

M dif i h d i b l


86/149

86

Modifying methods in subclass

To redefine a public/protected method of a

superclass in one of its subclasses, use the syntax

in the subclass definition:-

METHOD REDEFINITION

The interface and visibility of a method

cannot be changed while redefining it.

The method declaration and implementation in

the superclass is not affected when you redefine

the method in a subclass.

Inheritance


87/149

87

Inheritance

Abstract and Final Methods and Classes :

An abstract method is defined in an abstract class andcannot be implemented in that class.

A final method cannot be redefined in a subclass.

References to Subclasses and Polymorphism:

Reference variables defined with reference to a superclass can also contain references to any of its subclasses.

A reference variable defined with reference to a superclass or an interface implemented by a super class cancontain references to instances of any of its subclasses.

Reference variable defined with reference to OBJECT cancontain reference to any reference variable.

CREATE OBJECT statement with type addition

Abstract Methods and Classes


88/149

88

Abstract Methods and Classes

One cannot create an object from an abstract

class.Only subclasses can be derived from them.

CLASS DEFINITION ABSTRACT.

Abstract methods cannot be implemented in

the same class. Only the subclasses of that

class can implement it.

METHODS .ABSTRACT

Any class containing an abstract method has

to be an abstract class. All subsequent

subclasses that do not implement the method

must also be abstract. To implement an abstract

method in a subclass, one need to redefine this

subclass using the REDEFINITIONaddition.

Final Methods and Classes


89/149

89

Final Methods and Classes

Final classes cannot have subclasses. Only the

class can be instantiated.

CLASS DEFINITION FINAL .

A final method cannot be redefined in

subclasses

METHODS .FINAL

Inheritance


90/149

90

Inheritance

Inheritance and Static Attributes

In terms of inheritance, static attributes are not

assigned to a single class, but to a part of the

inheritance tree.

When you address a static attribute that belongsto part of an inheritance tree, you always address

the class in which the attribute is declared,

irrespective of the class you specify in the class

selector.

This is particularly important when you call the

static constructors of classes in inheritance.



91/149

91


Static attributes only exist

once in each inheritance tree.

One can change them from

outside the class using the

class component selector

with any class name, or

within any class in which they

are shared.

They are visible in all

classes in the inheritance

tree.

CLASS c1 DEFINITION.

PUBLIC SECTION .

CLASS-DATA : num TYPE I VALUE 5 .

ENDCLASS.


ENDCLASS.

CLASS c2 DEFINITION INHERITING FROMc1.

ENDCLASS.


ENDCLASS.

START-OF-SELECTION.

c2=>num = 7.

write:/5 c1=>num .

Output : 7

Inheritance


92/149

92

Inheritance

Inheritance and Constructors

Every class has an Instance constructorcalledCONSTRUCTOR.

Instance constructors of the various classes in an

inheritance tree are fully independent of one another.

You cannot redefinethe instance constructor of a superclass in a subclass

The instance constructor of a subclass has to ensurethat

the instance constructors of all of its super classes are also

called.

To do this, the instance constructor of each subclass must

contain a CALL METHOD SUPER->CONSTRUCTOR

statement.

Inheritance


93/149

93

Inheritance

Supplying values using CREATE OBJECT in inheritance

Supplying values using

CALL METHOD SUPER->CONSTRUCTOR in inheritance.

The instance constructor of a subclass is divided into two

parts by the CALL METHOD SUPER->CONSTRUCTOR

statement. In the statements before the call, theconstructor behaves like a static method

In a constructor method, the methods of the subclasses of

the class are not visible.( REDEFINITION not effective )

Static Constructors

Inheritance and Instance


94/149

94

Constructors

ase Description Necessity of calling

constructor of

superclass by

subclass

1 None of the superclass and subclass haveexplicit constructor.

Not required

2 Superclass have explicit constructor, butsubclass does not have any explicit constructor.

Not required

3 Superclass does not have an explicitconstructor, but subclass have one.

Required

4 Both the superclass and subclass have explicitconstructor

Required

Superclasses and/or subclasses can have explicit constructors of their own.Constructor of a subclass sometimes have to call the constructor of the superclass

using: CALL METHOD : SUPER->CONSTRUCTORdepending on the following:-

Polymorphism via Inheritance


95/149

95

y p

With inheritance, a reference variable

defined with respect to a class may not only

point to instances of that but also to

instances of subclasses of the same. One

can even create subclass objects using a

reference variable typed with respect to a

super class.

Polymorphism through inheritance can be

achieved by playing with static and dynamic

type of a reference variable.

Instances of a subclass may be used

through the super class's interface. When

this is done, a client can't access all

components defined in the subclass, only

those inherited from the respective super

class.

classc1 definition.

. . . . . . .

endclass.

classc1 implementation.

. . . . . .

endclass.

classc2 definition inheriting fromc1.

. . . . . .

endclass.

classc2 implementation.

. . . . . . .

endclass.

start-of-selection.

data : oref1 type ref to c1,

oref11 type ref to c1,

oref2 type ref to c2.

create object oref1 type c2 .

create object oref2.

oref11 = oref2.

write:/5 oref1->num ,

oref11->num .

Inheritance


96/149

96

Inheritance

Inheritance Overview:

Inheritance


97/149

97

Inheritance

Inheritance and Reference Variables

Interfaces


98/149

98

Interfaces

Interfaces are independent structures that you can implement ina class to extend the scope of that class.

a universal point of contact.

They provide one of the pillars of polymorphism, since they allowa single method within an interface to behave differently indifferent classes.

Global& Local Interfaces

The definition of a local interface is enclosed in thestatements:

INTERFACE .

...

ENDINTERFACE.

The definition contains the declaration for all components

(attributes, methods, events)of the interface. They automatically belong to the public section of the classin

which the interface is implemented.

Defining Interfaces


99/149

99

Defining Interfaces

Can be declared globally or locally within aprogram.

Locally declared in the global portion of a program

using:-

INTERFACE .

...

ENDINTERFACE.

The definition contains the declaration for all

components (attributes, methods, events) of the

interface.

Interfaces are included in the public section of a

class.

Interfaces do not have an implementation part,

since their methods are implemented in the class that

implements the interface.

report ysubdel .

interfacei1.data : num type i .

methods : meth1.

endinterface.

class c1 definition.

public section.

methods : meth1.

interfaces : i1.

endclass.

class c1 implementation.

method : meth1.

write:/5 'I am meth1 in c1'.

endmethod.

method i1~meth1.

write:/5 'I am meth1 from i1'.

endmethod.endclass.

start-of-selection.

data : oref type ref to c1. create object oref.

write:/5 oref->i1~num.

call method oref->meth1.

call method oref->i1~meth1.

Interfaces


100/149

100

Interfaces

Interfaces do not have instances.

To implement an interface in a class, use the statementINTERFACES .

in the declaration part of the class.

A component of an interface can beaddressed as though it were a member of the class underthe name .

Interface References

Addressing Objects Using Interface References

Using the class reference variable:

To access an attribute : ->

To call a method : CALL METHOD ->

Interfaces


101/149

101

Interfaces

Using the interface reference variable:

To access an attribute : < iref>-> To call a method : CALL METHOD ->

Addressing a constant : < intf>=> (Cannot useclass name).

Addressing a static attribute

: < class>=>

Calling a static method : CALL METHOD=>

(Cannot use Interface method ).

casting operator (?= )

?=

For the casting to be successful, the object to which pointsmust be an object of the same class as the type of the classvariable .


102/149

102

DAY 4

Triggering and Handling Events


103/149

103


To trigger an event, a class must

Declare the event in its declaration part

Trigger the event in one of its methods

EVENTS EXPORTING... VALUE()

TYPE type [OPTIONAL].. To declare static events, use the following

statement:

CLASS-EVENTS ...

Both statements have the same syntax.



104/149

104


Triggering Events

RAISE EVENT EXPORTING... =

...

The self-reference ME is automatically passed to

the implicit parameter SENDER.

Handling Events

Events are handled using special methods. To

handle an event, a method must

1. be defined as an event handler method forthat event

2. be registered at runtime for the event.



105/149

105


Declaring Event Handler Methods

METHODS FOR EVENT OF IMPORTING.. ..

The event handler method does not have to use all of the

parameters passed in the RAISE EVENT statement.

If you want the implicit parameter SENDER to be used aswell, you must list it in the interface.

Registering Event Handler Methods

SET HANDLER... ... [FOR]...

Handler methods are executed in the order in which they

were registered.



106/149

106


Handler Table:

What is an Exception?


107/149

107

What is an Exception?

An exception is a situation that occurs during the execution of anABAP program, which renders a normal program continuationpointless.

Exceptions can be detected at the time of program compilation or at

runtime.If the exception detected at runtime is not handled properly

by the program itself, we get a short dump and the executionterminates.

Classification of Exceptions


108/149

108

Classification of Exceptions

Exceptions of various kinds can be broadly classified as :-

Exceptions that can be handled.

Exceptions that cannot be handled.

Exceptions that can be handled indicate error situations in the runtime

environment or in the ABAP program, in the case of which the programexecution can be continued - by handling the exception in the ABAP

program - without the system reaching a critical condition. If such a

situation is not handled a runtime error will occur.

Exceptions that cannot be handled indicate critical error situations inthe runtime environment, which cannot be handled with/by ABAP means

and always cause a runtime error. Database space problem can be anexample of such category.

Traditional Ways of Catching RuntimeExceptions


109/149

109

Exceptions

Areas Brief Overview

In ABAP catch system-exceptions = .. . . . . .

Endcatch.

If sy-subrc= .

< exception handling statements>

Endif.

In functionmodule

Creating exceptions for function module, raising them at

appropriate points in the FM , assigning different sy-subrc

values for each exceptions at the time of the FM call and later

dealing with them.

In Methods Creating different exceptions at the time of declaring methods,raising those exceptions within the method, assigning differentsy-subrc values at the time of method call and later dealing

with those values.

What is Class-based exception

h dli ?


110/149

110

handling?

In Class-based exceptions handling approach, exceptions are generally

represented by objects of exception classes. There are pre-defined

exception classes for error situations in the runtime environment .

Users can also define own exception classes globally/locally, if required

and can raise them using RAISE EXCEPTIONstatement.

The runtime environment only causes exceptions that are based on pre-

defined classes, while in ABAP programs one can use raise pre-defined as

well as user-specific exception classes.

Class-based exceptions are handled using the control structure TRY ...

ENDTRY.

Class-based exceptions in procedures can be propagated to the caller inthe definition of the interface using the RAISINGaddition, if the exception is

not to be handled in the procedure.

TRYCATCHENDTRY
http://sapevent/http://sapevent/http://sapevent/http://sapevent/


111/149

111

Class-based exceptions are handled using TRYCATCHENDTRYblock.

TRY.

< code to be checked for

exception>

CATCH cx1 .cxn [ into

ref].

< exception handling code>.

ENDTRY.

REPORT YSUBCLASS_EXCEPTION.

DATA: i TYPE i VALUE 1.

START-OF-SELECTION.

TRY.

i = i / 0.

CATCHcx_sy_zerodivide.

write:/5 'Divide by zero caught'.

ENDTRY.

Class-Based ExceptionsSAPException Classes (2)


112/149

112

Exception Classes (2)

CX_STATIC_CHECK: For exceptions that have to be declared. This type should be chosen if you

want to make sure that this exception is always dealt with and if a localexception handler has a chance to do something useful in an exceptionsituation

Corresponding exceptions must either be handled or forwarded explicitlywith the RAISINGaddition and this is checked at syntax check

CX_DYNAMIC_CHECK: For exceptions that do not have to be declared

Exceptions must be handled or explicitly forwarded with the RAISINGaddition though this is not checked at syntax check. Exceptions of this typeare checked at runtime only

Useful for potential error situations that do not have to be handled, sincethe program logic can more or less exclude them. Example:

cx_sy_zerodivide Most of the CX_SY_exceptions inherit from this class

CX_NO_CHECK:

For exceptions that must not be declared (i.e. resource bottlenecks)

Can be handled but not forwarded with RAISING. Otherwise will bepropagated through call chain automatically

Not checked by syntax checkor runtime processing

SAP Exception Classes


113/149

113

p

SAP provided exception-classes are derived from the specific classCX_ROOT and have the prefix CX_.

Exception classes are normal classes with one limitation:-

Apart from the constructor, no methods can be defined for them. However,

CX_ROOT has some pre-defined methods available, which can then be

inherited by all exception classes.

Component Name (M)ethod/(A)ttrib

ute

Description

GET_TEXT M Returns a text description of theexception

GET_SOURCE_POSITION M Returns the point at which theexception occurred

TEXTID A Used to define different texts forexceptions of a particular exceptionclass. Affects the result of themethod GET_TEXT.

SAP Exception Classes


114/149

114

p

Component Name (M)ethod/(A)ttri

bute

Description

PREVIOUS A If one exception is mapped toanother, this attribute stores theoriginal exception, which allows thesystem to build a chain ofexceptions.

KERNEL_ERRID A Contains the name of theappropriate runtime error if theexception was triggered from thekernel. If the exception was raisedusing a RAISE EXCEPTION, thisattribute is initial.

TEXTID A Used to define different texts forexceptions of a particular exceptionclass. Affects the result of themethod GET_TEXT.

Nested TryCatchEndtry Blocks
http://sapevent/http://sapevent/


115/149

115

y y

Try block

Catch block

Catch block

Cleanup block

TRY.TRY.

CATCH cx_class INTO oref

CATCH cx_class INTO oref

CLEANUP.

ENDTRY.

CATCH cx_class INTO oref.

CATCH cx_class INTO oref.

CLEANUP.

ENDTRY.

.

Try block

Cleanup block

.

Catch block

Catch block

.

CLEANUP


116/149

116

Used within a TRYENDTRY

BLOCK , after all CATCH statements.

Each TRY block can contain

maximum of one CLEANUP area.

Used to release the external resourceswhen exception detected in a TRY

block is not handled within the block ,

but is caught further up in the call

hierarchy.

Possible only in cases of nested TRYblocks.

Report ysubdel.

data : w_num type i.

try.

try .

w_num = 5 / 0 .

cleanup.

write:/5 In cleanup.

endtry .

catch cx_sy_zerodivide.

write:/5 Div. By zero!.

endtry.

In cleanup

Div. by zero!

Creating Local Exception Class in a

program


117/149

117

program

To create a local exception class in a program and use it, follow the stepsoutlined below.

Step 1:- Create a subclass from global exception class in your program.

REPORT YSUBCLASS_EXCEPTION_3.

CLASS CX_SOME_EXCEPTIONDEFINITION INHERITING FROMCX_STATIC_CHECK.

public section.

methods : meth1.

ENDCLASS.


program


118/149

118

program

Step 2:- Implement methods of the subclass which will raise exception

CLASSCX_SOME_EXCEPTION IMPLEMENTATION.

method : meth1.

write:/5 'I am a method in exception'.

endmethod.

ENDCLASS.

Step 3:- Define another class which will call the exception class.

CLASS SOME_CLASS DEFINITION.

PUBLIC SECTION.

METHODS: m1 raising cx_some_exception .

ENDCLASS.


program


119/149

119

program

Step 4:- Implement the method of the other class which will raiseexception of the locally declared exception class.

CLASS SOME_CLASS IMPLEMENTATION.

METHOD m1.

RAISE EXCEPTION TYPE CX_SOME_EXCEPTION.ENDMETHOD.

ENDCLASS.


program


120/149

120

program

Step 5:- Create an object of the other class and call its method whichwill raise the exception

DATA: c1 TYPE REF TO SOME_CLASS.

START-OF-SELECTION.

TRY.CREATE OBJECT c1.

c1->m1( ).

CATCH CX_some_exception.

write:/5 'Exception caught'.

ENDTRY.

Class-Based ExceptionsDebug Mode


121/149

121

Exception has

occurred and has

been handled

Class-Based ExceptionsDebug Mode


122/149

122

Trigger point of

exception

Display Exception

Object


123/149

Class-Based ExceptionsCreating aGlobal Exception Class (1)


124/149

124

Global Exception Class (1)

Enter class name Click Create

Note Superclass

and class type

SE24



125/149

125

Global Exception Class (2)

Note the 2 attributes inherited from cx_root superclass

textidUsed to define different texts for exceptions of a particular

class. Affects the result of method get_textpreviousIf one exception is mapped to another, this attribute can

store the original exception. If a runtime error occurs, the short dump

contains the texts belonging to all the exceptions in the chain

Go to

MethodsTab



126/149

126

Three methods are inherited from CX_ROOT

get_text, get_longtextReturns the textual representation as a string,

according to the system language of the exception

get_source_positionReturns the program name, include name, and line

number reached where the exception was raised

A constructor method is automatically generated

Double click on

the constructor

method to view

code



127/149

127

p ( )

Call to the constructor of superclasses is automatically

generated

Click on

previous

object button

to return tomethods tab



128/149

128

First add an attribute to

the error class and

activate the class

Then return to the

methods tab and click on

the constructor again



129/149

129

A line has been added to the constructor to initialize the new attribute.

This attribute will be available in the error object at runtime and will contain

the value that is passed to the constructor when the exception is raised

Click on

previous

object

button toreturn to

methods tab



130/149

130

Go to the Texts tab and add a text for theexception ID.

Class-Based ExceptionsCreating a Global

Exception Class(8)


131/149

131

The texts are stored in the Online Text Repository (OTR). The exceptionobject contains only a key that identifies the text (with system language)

The default text has the same name as the name of the exception class, inthis case ZCX_SOME_EXCEPTION.

You might wish to create an alternate text for the exception. That text can beentered on this screen with a new exception ID and can be displayed bypassing this value to the parameter textid of the exception constructor.



132/149

132

After performing a syntax check and

adding the texts to the OTR, return to the

Attributes tab


133/149


134/149

134

DAY 8


135/149

3 ReasonsABAP Objects is BetterABAP


136/149

136

ABAP Objects is more Explicit and Simpler to Use.

ABAP Objects has a Stricter Syntax Check in

Classes.

ABAP Objects Provides Access to New ABAP

Technology.

ABAP Objects is more Explicit andSimpler to Use


137/149

137

ABAP Objects is much simpler and less error-prone

because :

Classes contains attributes and methods.

Objects are instances of Classes.

Objects are addressed via references.

Objects have clearly defined interfaces.

Comparison between Procedural ABAPand Object oriented ABAP


138/149

138

Procedural ABAP

Contains Obsolete

Statements.

Supports Overlapping

and some specializedobjects.

Shows Implicit Behavior.

Appears difficult to

learn.

Object Oriented ABAP

Prohibits obsolete

statements and additions.

Requires implicit syntax

completions to be explicit.Detecting & preventing

incorrect data handling.


139/149


140/149


141/149

Internal Tables definition


142/149

142

Database access


143/149

143

Explicit Typing


144/149

144

Data Handling


145/149

145

Unicode Restrictions


146/149

146


147/149

ABAP Objects Provides Access toNew ABAP Technology


148/149

148

Frameworks for user dialogs such as SAP Control

Framework (CFW), BSP , Desktop Office Integration(DOI) etc.

Framework for persisting data in the database(Object Services) and Shared Objects (area classes).

Service classes such as

CL_GUI_FRONTEND_SERVICES for working withdata at the presentation server.

Language related classes such as Run Time TypeServices (RTTS), or CL_ABAP_EXPIMP subclassesfor extended IMPORT/EXPORT functionality.


149/149

Thank You

abap objects 1oo

Documents