Ooabap notes with_programs

OOABAP NOTES WITH Programs

1 | P a g e S a n t o s h P

VINAYAKA

Features Of OOPS: -

1) Encapsulation

2) Data Abstraction

3) Inheritance

4) Polymorphism

Application Of OOPS: -

1) BAPI’S

2) BADI’S

3) Enhancement Frame Work

4) Webdynpro

5) HR-ABAP

6) CRM-Technical

7) SRM

8) EP

9) BSP……………

Class: - A class is a user defined data type which is the collection of different type of components.

A class only provides a template it’s doesn’t allocate a memory.

Object: - An instance of a class is called as an object.

Whenever we instance a class memory will be allocated.

Access Specifies (Visibility Section): -

Types Of Class: -

1) Local Class Local class to program (SE38-ABAP Editor).

2) Global Class Class Builder Tool (SE24).

Syntax for creating local classes: -

1) Definition of class Declaration of components.

2) Implementation of class Implementation of method.


Definition of class

Class <class name> definition.

Declaration of components.

Endclass.

Implementation class

Class <class name> implementation.

Implementation of methods.

Endclass.

Object Creation: -

1) Create reference for the class

Syntax: -

Data <ref.name> type ref to <class name>

Note: - Whenever an Object is created memory will be allocated for the attributes of the class and

attribute gets initialized to default values.

Access specifiers in ABAP: -

1) Public Section

2) Protected Section

3) Private Section

Components of ABAP classes: -

Attributes Methods Events Interface aliases

Types Constants Data Special Normal Instance Static

Instance Instance

Constructor

Instance Static

Static Static

Constructor


1) OOPS Concepts

2) ALV Reporting Using Class

3) ALV Reporting Using Function Modules

Procedure for creating global classes: -

1) Define and implement the class in class builder tool (SE24).

2) Access the components of the global class in the repository objects (Executable Programs,

Include Program, and Subroutine Pool). By instantiating the class.

Z915AM_OOPS1: (LOCAL CLASS)

REPORT Z915AM_OOPS1.

CLASS EMP DEFINITION.

PUBLIC SECTION.

DATA EMPNO TYPE I. "instance attribute

DATA ENAME(20) TYPE C. "instance attribute

ENDCLASS. "emp DEFINITION

DATA K TYPE REF TO EMP.

CREATE OBJECT K.

WRITE :/ K->EMPNO,

K->ENAME.

K->EMPNO = 1.

K->ENAME = 'abc'.

WRITE:/ K->EMPNO,

K->ENAME.

OUTPUT:

At any point of time they object store one set of values.

Note: - Only public component can be accessed outside of the class.


Z915AM_CLASS1: (GLOBAL CLASS) SE24:

Z915AM_OOPS2:


data m type ref to z915am_class1.

CREATE OBJECT m.

write :/ m->empno,

m->ename.

OUTPUT:


Interacting with methods in local classes: -

1) Declare the method prototype in the class definition.

Syntax: -

Method/Class-Method <method name> [parameters].

2) Implement the method in the class implementation.

Syntax: -

Method <method name>.

Statements.

Endmethod.

3) Call the method.

Syntax: -

Call method <method name> [parameters]

Instance method methods

Static method class-methods

It is recommend to use in the SAP attributes/data members/Instance variables protected/private.

Method’s/member function public.

Note: - Whenever a report program contains class implementation and explicitly we need handle

the event start-of-selection to indicate the starting point of program.

Z915AM_OOPS3:


class abc definition.

public section.

methods : m1,

m2.

protected section.

data : empno type i,

ename(20) type c.

endclass.

class abc implementation.

method m1.

empno = 1.

ename = 'xyz'.

endmethod.

method m2.

write :/ empno,

ename.

endmethod.

endclass.

start-of-selection.

data k type ref to abc.

create object k.

call method k->m2.


k->m1( ).

k->m2( ). OUTPUT:

Method with parameters: -

Methods: m1 importing X type i,

Y(20) type c.

Methods returning values: -

Returning Keyword: -

In case of other object oriented language a method can return exactly one value which

done by using return keyword.

In case of ABAP a method can return any number of values by declaring those many

number o exporting (or) importing (or) changing parameters.

To receive a method a return exactly one value we use returning parameters.

It the method contains returning parameters it cannot contains exporting (or) changing

parameters.

A method can contains only one returning parameter.

Returning parameter are always passed by value.

Z915AM_OOPS4:



public section.

methods : m1 importing x type i optional

y type c optional,

m2.


protected section.


ename(20) type c.

endclass.


method m1.

empno = x.

ename = y.

endmethod.

method m2.

write :/ empno,

ename.

endmethod.

endclass.

start-of-selection.


create object k.

parameters : p_x type i,

p_y(20) type c.

call method k->m1

exporting

x = p_x

y = p_y.

call method k->m2.

OUTPUT:


Z915AM_CLASS2:

method M1.

empno = x.

ename = y.

call method m2.

endmethod.

method M2.

write :/ empno,

ename.

endmethod.


Z915AM_OOPS5:


data k type ref to z915am_class2.

CREATE OBJECT k.


p_y(20) type c.

CALL METHOD k->m1

EXPORTING

X = p_x

Y = p_y.

OUTPUT:

Z915AM_OOPS6: REPORT Z915AM_OOPS6.


public section.

methods m1 importing x type i

y type i

exporting m type i

n type i.

endclass.


method m1.

m = x + y.

n = x - y.

endmethod.


endclass.

start-of-selection.


create object k.

data : lv_r1 type i,

lv_r2 type i.

call method k->m1

exporting

x = 200

y = 100

importing

m = lv_r1

n = lv_r2.

write :/ lv_r1,lv_r2.

OUTPUT:



public section.


y type i

returning value(z) type i.

endclass.


method m1.

z = x + y.

endmethod.

endclass.

start-of-selection.

data ob type ref to abc.

create object ob.



p_y type i.

data lv_z type i.

lv_z = ob->m1( x = p_x y = p_y ).

write :/ lv_z.

OUTPUT:

Exception handling in methods: -

An exception is runtime error which is raised during the program execution if the

exception is not handling the program will be terminated.

Exception handling is process of handling in runtime error and containing program

execution.

The exceptions are provided by SAP as part of standard exceptions class these exceptions

are triggered by SAP itself as a developer we need to handle these exceptions by using try

and catch block.

Inside try block we need to declare this statement where the possible exception occurs.

It the exception is raised in try blocked SAP creates the appropriate exception class object

and the control is transfer to catch block.

Inside the catch block we need to handle the exception by writing the appropriate

exception handling statements.

All the exception classes provided by SAP start with the naming standard

‘CX_SY_...........’


Note: - As part of catch block declaration we need to specify the exception class which is

reasonable for rising exception if the developer is not sure of the exception class we can use the

exception class ‘CX_ROOT’.

CX_ROOT is a super class for all the exception classes and it can handle any kind of

exception.



public section.


y type i

exporting z type i.

endclass.


method m1.

try.

z = x / y.

* catch cx_sy_zerodivide.

catch cx_root.

write :/ 'Cannot divide by zero'.

endtry.

endmethod.

endclass.

start-of-selection.


create object ob.

data lv_z type i.

call method ob->m1

exporting

x = 10

y = 0

importing

z = lv_z.

write :/ 'Diviison is ',lv_z.

write :/ 'end of program'.


OUTPUT:


DATA K TYPE REF TO CX_SY_ZERODIVIDE.

DATA STR TYPE STRING.

DATA : PRGNAME TYPE SY-REPID,

INCNAME TYPE SY-REPID,

POS TYPE I.

CLASS ABC DEFINITION.

PUBLIC SECTION.

METHODS M1 IMPORTING X TYPE I

Y TYPE I

EXPORTING Z TYPE I.

ENDCLASS. "abc DEFINITION

CLASS ABC IMPLEMENTATION.

METHOD M1.

TRY.

Z = X / Y.

CATCH CX_SY_ZERODIVIDE INTO K.

CALL METHOD K->IF_MESSAGE~GET_TEXT

RECEIVING

RESULT = STR.

WRITE :/ 'short text is ',STR.

CLEAR STR.

CALL METHOD K->IF_MESSAGE~GET_LONGTEXT

RECEIVING

RESULT = STR.

WRITE :/ 'Long text is ',STR.

CALL METHOD K->GET_SOURCE_POSITION

IMPORTING


PROGRAM_NAME = PRGNAME

INCLUDE_NAME = INCNAME

SOURCE_LINE = POS.

WRITE :/ 'Program name :',PRGNAME,

/ 'Include name :',INCNAME,

/ 'line no :',POS.

ENDTRY.

ENDMETHOD. "m1

ENDCLASS. "abc IMPLEMENTATION

START-OF-SELECTION.

DATA OB TYPE REF TO ABC.

CREATE OBJECT OB.

DATA LV_Z TYPE I.

CALL METHOD OB->M1

EXPORTING

X = 10

Y = 0

IMPORTING

Z = LV_Z.

WRITE :/ 'Diviison is ',LV_Z.

WRITE :/ 'end of program'.

OUTPUT:

CX_SY_ZERODIVIDE:


Capturing system defined exception message: -

Procedure for handling standing exception: -

These exception are declared and raised SAP as a developer we need to handle try and catch.

User defines exception: -

These exceptions are declaring and handle are raised developers itself.

Procedure for handling user-define exception in local classes: -

1) Declare the user define exception as part of method declaration.

Syntax: -

Exception <exception name>

2) Raise the exception at appropriate place in the method implementation

Raise <exception name>

3) Handle the exception while calling the method by checking sy-subrc status.



public section.


y type i

exporting z type i

exceptions divideerror.

endclass.


method m1.

if y eq 0.

raise divideerror.

else.

z = x / y.

endif.

endmethod.

endclass.

start-of-selection.


create object ob.

data lv_z type i.

call method ob->m1

exporting


x = 10

y = 0

importing

z = lv_z

exceptions

divideerror = 1

others = 2.

if sy-subrc eq 0.

write :/ 'division is ',lv_z.

elseif sy-subrc eq 1.



write :/ 'Unknown error'.

endif.

OUTPUT:

Z915AM_CLASS3:

method M1.

if y eq 0.

raise divideerror.


else.

z = x / y.

endif.

endmethod.


data lv_z type i.

data ob type ref to z915am_class3.

create object ob.

CALL METHOD ob->m1

EXPORTING

x = 10

y = 0

IMPORTING

Z = lv_z

EXCEPTIONS

DIVIDEERROR = 11

others = 22.

if sy-subrc eq 0.

write :/ lv_z.


message 'Cannot divide by zero' type 'I'.


message 'Unknown error' type 'I'.

endif.

OUTPUT:


Instance attribute: -

These attribute are specific to an object and they are declared by using the keyword data

in local classes.

For each instance attribute separate memory will be allocated they can be an accessed

only by using the object of the class.

Static attribute: -

They are not specific to any object and they are declared by using the keyword

‘CLASS_DATA’ in local classes.

For the static attribute memory will be allocated only when the first object is created the

remaining objects points to be same memory location they are also called as class

variables.

They can be accessed either by using the object are by using the class name.

Instance methods: -

In local classes they are declared by using the keyword methods they can be accessed only by

using the object. They can access both instance and static attributes.

Static methods: -

In local class they are declaring the keyword ‘CLASS-METHOD’ in the local classes they

can be accessed either by using object are by using class name. They access only static attributes.



public section.

data x type i. "instance attribute

class-data y type i. "static attribute

endclass.

start-of-selection.

data ob1 type ref to abc.

create object ob1.

write :/ 'Values of object ob1'.

write :/ ob1->x,

ob1->y,

abc=>y.

ob1->x = 10.

ob1->y = 20.


write :/ ob1->x,


ob1->y.


create object ob2.


write :/ ob2->x,

ob2->y.

OUTPUT:

Z915AM_OOPS13:



public section.

methods m1.

class-methods m2.

protected section.

data x type i.

class-data y type i.

endclass.


method m1.

x = 10.

y = 20.

WRITE : x.

endmethod.

method m2.

y = 20.

* x = 10.

write: y.

endmethod.

endclass.


start-of-selection.

call method abc=>m2.

abc=>m2( ).

*abc=>m1( ).

OUTPUT:

Constructors: -

A constructor is a special method used for initialized for attributes of class it special because

it cannot be called explicitly it will be called implicitly.

It is always declare in public section.

It never returns any values.

1) Instance

2) Static

Instance Constructors: - It is declared by using keyword constructor it is executed automatically

whenever we create new instance of a class. It is specific to object.

It can contain only importing parameters and exceptions.

Static Constructors: - It is declared by using the keyword ‘CLASS_CONSTRUCTORS’ it is

executed automatically whenever a class is loaded a class will be loaded in cases.

1) When we accesses the static components of the class using the class name before creating any

objects.

2) When we create the first object of the class.

3) It is not specific to any object it cannot contains any parameters and exception.

Note: -

Instance constructor is executed only once in the life time of object.

Static constructor is executed only once in a life time of class.




public section.

methods : constructor,

m2.

protected section.

data : empno type i, "INATANCE ATTRI"

ename(20) type c.

endclass.


method constructor.

empno = 1.

ename = 'abc'.

endmethod.

method m2.

write :/ empno,ename.

endmethod.

endclass.

start-of-selection.

* data ob type ref to abc.

* create object ob.

*

*call method ob->constructor. " u cannot specify constructor directly.

*call method ob->m2.

*call method ob->m2.


create object ob1.

call method ob1->m2.

OUTPUT:


Z915AM_OOPS15:



public section.

methods : constructor importing x type i optional

y type c optional,

display.

protected section.


ename(20) type c.

endclass.


method constructor.

empno = x.

ename = y.

endmethod.

method display.


endmethod.

endclass.

start-of-selection.


p_y(20) type c.


create object ob

exporting

x = p_x

y = p_y.

call method ob->display.

OUTPUT:




public section.

methods constructor.

class-methods class_constructor.

endclass.


method constructor.

write :/ 'inside instance const'.

endmethod.

method class_constructor.

write :/ 'inside static const'.

endmethod.

endclass.

start-of-selection.


create object ob1.

write :/ 'Second object.........'.


create object ob2.

OUTPUT:

Note: - If a class contains both instance and static constructor and when we create the first object.

1st the static constructor is executed and next instance constructor for rest of the objects only

instance constructor get executed.




public section.

methods : constructor importing x type i optional

y type c optional,

display.

protected section.


ename(20) type c.

endclass.


method constructor.

empno = x.

ename = y.

endmethod.

method display.


endmethod.

endclass.

start-of-selection.


p_y(20) type c.


create object ob

exporting

x = p_x

y = p_y.

call method ob->display.

OUTPUT:




public section.



endclass.


method constructor.


endmethod.



endmethod.

endclass.

start-of-selection.


create object ob1.

write :/ 'Second object.........'.


create object ob2.

OUTPUT:


Z915AM_OOPS17:



public section.



class-data x type i.

endclass.


method constructor.


endmethod.



endmethod.

endclass.

start-of-selection.

*abc=>x = 10.


create object ob1.

OUTPUT:


NORMAL METHOD

SPECIAL METHOD CONSTRUCTOR

It can be declared in any of the sections. Only in public section.

It has to be called explicitly. It called implicitly.

A method can have any type o parameters. Instance constructor can have importing

parameters and static constructor cannot have

any parameters.

Methods can return values. It cannot return values.

It can be called any know of times in the

lifetime of an object.

Instance constructor will be called only once

in the lifetime of every object where as static

constructor will be called only once in the

lifetime of class.

CREATING T-CODE FOR METHOD:




PUBLIC SECTION.

METHODS M1.

PROTECTED SECTION.

DATA X TYPE I.



METHOD M1.

BREAK-POINT.

LEAVE TO LIST-PROCESSING.

WRITE :/ 'inside method m1'.

LEAVE SCREEN.

ENDMETHOD. "m1


CLASS PQR DEFINITION.

PROTECTED SECTION.

DATA : X TYPE I,

Y TYPE I.

ENDCLASS. "pqr DEFINITION

(SETTING BREAK POINT IN PORGRAM FOR OUR UNDERSTANDING)

EXECUTING T-CODE: ZT35


OUTPUT:

User defined exception: -

Raising: - It a method is a capable of raising the exception that enable to handle the exception then

we need to use the keyword raising as part of method declaration in this case the caller of the

method as to take the responsibility of handling the exception.



public section.


y type i

exporting z type i

raising cx_sy_zerodivide.

endclass.


method m1.

z = x / y.

endmethod.

endclass.

start-of-selection.


create object ob.

data r type i.

try.

call method ob->m1

exporting

x = 10

y = 0

importing

z = r.

catch cx_sy_zerodivide.

message 'Cannot divide by zero' type 'I'.

endtry.

write :/ 'diviison is ',r.


OUTPUT:

PRESS ENTER:



p_y type i.

data z type i.

try.

perform abc using p_x p_y changing z.

catch cx_sy_zerodivide.


endtry.

write :/ 'Diviison is ',z.

form abc using m n changing r

raising cx_sy_zerodivide.

r = m / n.

endform.

OUTPUT:


Friend classes: - By default outside the class a object can access only public components of the

class directly.

By using friend classes to enable the object to access any components of the class directly

irresponsibility of the visibility for this consider the following session.

Consider two independent classes A and B.

If class A considers class B as friend by inside class B methods we can instantiate class A

and use the instance we can access all the component of class A directly irrespective of

the visibility.

Z915AM_OOPS21:


class pqr definition deferred.

class abc definition friends pqr.

public section.

methods m1.

protected section.

methods m2.

private section.

methods m3.

endclass.


method m1.

write :/ 'inside public method m1'.

endmethod.

method m2.

write :/ 'inside protected method m2'.

endmethod.

method m3.

write :/ 'inside private method m3'.

endmethod.

endclass.

class pqr definition.

public section.

methods m4.


endclass.

class pqr implementation.

method m4.

write :/ 'inside m4'.


create object ob.

call method : ob->m1.



endmethod.

endclass.

start-of-selection.

data k type ref to pqr.

create object k.

call method k->m4.

OUTPUT:

In the above case the class B should be forward declared by using the keyword ‘deferred’.

Deferred keyword indicates to SAP that the class definition has been delayed and it has been

declared same where else in the program.

Z915AM_CLASS4: (GLOBAL FRIEND CLASS)


method M1.

write :/ 'inside method m1'.

endmethod.

method M2.


endmethod.

method M3.


endmethod.

Z915AM_CLASS5:


method M4.



create object ob.

call method : ob->m1,

ob->m2,

ob->m3.

endmethod.

Z915AM_OOPS22:



create object ob.

call method ob->m4.

OUTPUT:

Inheritance: -

It is the process o acquiring the properties of other entity (class). The advantage of

inheritance is reusability. They are three types of inheritance.

1) Single

2) Multiple

3) Multilevel

The class which gives the properties is called as super class are base class and the class

which takes the properties is called as subclass (or) derived class.


Only public and protected components can be inherited.

In local classes we need to use the keyword inheriting from for achieving inheritance.

1) Single inheritance: -

A class derived from single super class.

2) Multiple inheritance: -

A class derived from more than one super class.

Note: - In ABAP we cannot implement multiple inheritance directly we can implemented indirectly

through the concept of interface.

3) Multilevel inheritance: -

A class derived from another derived class.

Single inheritance

Multilevel inheritance Multiple inheritance


class cycle definition.

public section.

methods : setcycle,

display.

protected section.

data : wheels type i,

brakes type i,

colour(20) type c.

endclass.

class cycle implementation.

method setcycle.

wheels = 2.

brakes = 2.

CLASS A

CLASS B

CLASS A

CLASS C

CLASS A CLASS B

CLASS C

CLASS B


colour = 'green'.

endmethod.

method display.

write :/ wheels,brakes,colour.

endmethod.

endclass.

class scooter definition inheriting from cycle.

public section.

methods setscooter.

data enginemodel type i.

endclass.

class scooter implementation.

method setscooter.

wheels = 2.

brakes = 4.

colour = 'red'.

endmethod.

endclass.

class car definition inheriting from scooter.

public section.

methods setcar.

endclass.

class car implementation.

method setcar.

wheels = 4.

brakes = 5.

colour = 'blue'.

endmethod.

endclass.

start-of-selection.

data ob1 type ref to cycle.

create object ob1.

write :/ 'CYCLE class..........'.

call method : ob1->setcycle,

ob1->display.

data ob2 type ref to scooter.

create object ob2.

write :/ 'SCOOTER class.........'.

call method : ob2->setscooter,

ob2->display.

data ob3 type ref to car.


create object ob3.

write :/ 'CAR class.........'.

call method : ob3->setcar,

ob3->display.

OUTPUT:

Z915AMCYCLE:

method SETCYCLE.

wheels = 2.

brakes = 2.

colour = 'blue'.

endmethod.

method DISPLAY.


endmethod.


Z915AMSCOOTER:

method SETSCOOTER.

wheels = 2.

brakes = 4.

colour = 'red'.

endmethod.


Z915AMCAR:

method SETCAR.

wheels = 4.

brakes = 5.

colour = 'cyan'.

endmethod.


Z915AM_OOPS25:


data ob1 type ref to z915amcycle.

create object ob1.

data ob2 type ref to z915amscooter.

create object ob2.

data ob3 type ref to z915amcar.

create object ob3.

call method : ob1->setcycle,

ob1->display,

ob2->setscooter,

ob2->display,

ob3->setcar,

ob3->display.

OUTPUT:


Z915AM_OOPS26:


class abc definition final.

public section.

data x type i.

endclass.

class pqr definition inheriting from abc.

endclass.

OUTPUT:

Polymorphism: -

Poly Many

Morph Forms

Ism behavior

Examples: - Method overloading

Method overriding

Method overloading: -

If a class contains two method with the same name but different signature it is called as

method overloading.

ABAP doesn’t support method overloading.

Z915AM_OOPS27:



public section.

* methods m1.

methods m1 importing x type i.

endclass.


METHOD M1.


ENDMETHOD.

ENDCLASS.

method overloading

Z915AM_OOPS28:



PUBLIC SECTION.

METHODS M1.



METHOD M1.

WRITE :/ 'inside m1 of super class'.

ENDMETHOD. "m1


CLASS PQR DEFINITION INHERITING FROM ABC.

PUBLIC SECTION.

METHODS M1 REDEFINITION.


CLASS PQR IMPLEMENTATION.

METHOD M1.

WRITE :/ 'inside m1 of sub class'.

CALL METHOD SUPER->M1.

ENDMETHOD. "m1

ENDCLASS. "pqr IMPLEMENTATION

START-OF-SELECTION.

DATA OB TYPE REF TO PQR.

CREATE OBJECT OB.

CALL METHOD OB->m1.

OUTPUT:


Method overriding: -

If a sub class overwrites a super class method is called as method overriding.

Whenever a sub class wants to override the super class method a sub class wants to

declare the super class method in the subclass by using REDEFINITION keyword.

While redefined the methods we cannot change the visibility of the method.

Whenever a subclass overrides the super class method it is always recommended to call

the super class method version in the subclass by using super keyword.

Super keyword is used for referring to super class components from the sub class.

To redefine a global method put cursor on the method click on redefine.

Z915AM_CLASS6:

method M1.

write :/ 'inside method m1 of super class'.

endmethod.

Z915AM_CLASS7:


method M1.

write :/ 'inside m1 of subclass'.

CALL METHOD SUPER->M1.

endmethod.

Z915AM_OOPS29:



create object ob.

call method ob->m1.

OUTPUT:

Final keyword: -

Final keyword can be used at two levels.

1) Class level

2) Method level

The class created as final cannot be inherited.

A method created as final can be inherited but cannot redefine.

Z915AM_OOPS30:



PUBLIC SECTION.

METHODS M1 FINAL.




METHOD M1.

WRITE :/ 'inside m1 of super class'.

ENDMETHOD. "m1


CLASS PQR DEFINITION INHERITING FROM ABC.

PUBLIC SECTION.

METHODS M2.



METHOD M2.

WRITE :/ 'inside m2 of sub class'.

CALL METHOD M1.

ENDMETHOD. "m2


START-OF-SELECTION.

DATA OB TYPE REF TO PQR.

CREATE OBJECT OB.

CALL METHOD OB->M2.

OUTPUT:

Z915AM_OOPS31:



public section.

methods m1 final.

endclass.


method m1.

write :/ 'inside m1 of super class'.

endmethod.

endclass.



public section.

methods m2.

methods m1 redefinition.

endclass.


method m2.


call method m1.

endmethod.

endclass.

start-of-selection.

data ob type ref to pqr.

create object ob.

call method ob->m2.

OUTPUT:

Z915AM_OOPS32:



public section.



endclass.


method constructor.

write :/ 'inside instance const. of super class'.

endmethod.


write :/ 'inside static const. of super class'.

endmethod.

endclass.


public section.


* methods constructor.


endclass.


* method constructor.

* write :/ 'inside instance const. of super class'.

* endmethod.


write :/ 'inside static const. of sub class'.

endmethod.

endclass.

start-of-selection.

data ob1 type ref to pqr.

create object ob1.

OUTPUT:

Hierarchy of constructor execution: -

When a super class contains static and instance constructor and id sub class contains only the static

constructor and if sub class contains only the static constructor in this case if we instantiate the sub

class then the static constructor are executed from super class to sub class and then the instantiate

constructor of the super class will be executed.

Z915AM_OOPS33:



public section.



endclass.


method constructor.

write :/ 'inside instance const. of super class'.


endmethod.


write :/ 'inside static const. of super class'.

endmethod.

endclass.


public section.



endclass.


method constructor.

write :/ 'inside instance const. of sub class'.

call method super->constructor.

endmethod.


write :/ 'inside static const. of sub class'.

endmethod.

endclass.

start-of-selection.


create object ob1.

OUTPUT:

Note: - If the super class and sub class contains respective instance constructor it must for subclass

instance constructor to call the super class instance constructor this is done by using super keyword.

This is the only place where the constructor can be are must be called explicitly.

Note: - If the super class and sub class contains respective static and instance constructor and if

instantiate the sub class first the static constructor are executed to super class to subclass and when

the instantiate constructor will executed subclass to super class.


Me keyword: - Me keyword refer to current object execution it is used to differentiate both

attribute and method parameters whenever attribute and parameter names are same.

Z915AM_OOPS34:



public section.


n type i

exporting z type i.

protected section.

data : x type i,

y type i.

endclass.


method m1.

me->x = x.

y = n.

z = x + y.

endmethod.

endclass.

start-of-selection.


create object ob.

data r type i.

call method ob->m1

exporting

x = 10

n = 20

importing

z = r.

write :/ 'sum is ',r.

OUTPUT:


Visibility of component level: -

1) Public section

2) Protected section

3) Private section

Visibility of class level: -

1) Public

2) Protected

3) Private

4) Abstract

Public: - The default visibility of a class is public.

Public classes can be instantiated.

Public classes can be inherited.

The sub classes inherited the public class is also created as public by default.

Protected classes: - Protected classes can be inherited but cannot be instantiated outside the class

but it can be instantiated within the sub class method.

The sub class inheriting the protected class is also created as protected by default to create

the sub class as explicit public class we need to use extension create public as part of sub

class definition.

Z915AM_OOPS36:


class abc definition create protected.

endclass.

*class pqr definition inheriting from abc.

class pqr definition create public

inheriting from abc.

public section.

methods m1.

endclass.


method m1.


create object ob.

endmethod.

endclass.

start-of-selection.

data k type ref to pqr.

create object k.

call method k->m1.


OUTPUT:

protected classes.

Private classes: -

Private classes cannot be instantiated.

Private classes can be inherited.

The sub class inherited the private class is also created as private class by default.

This sub class cannot be created as explicitly public class this can be mode possible if the

super class considers the subclass as friend.

Z915AM_OOPS37:


class abc definition create private.

endclass.

*class pqr definition inheriting from abc.



public section.

methods m1.

endclass.


method m1.


create object ob.

endmethod.

endclass.

OUTPUT:


Z915AM_OOPS38:


class pqr definition deferred.

class abc definition create private

friends pqr.

endclass.



endclass.

data ob type ref to pqr.

create object ob.

OUTPUT:

second usage of friend keyword

Abstract class: -

It is a class which contains at least one abstract method. Abstract method is a method

which is just declared but not implemented in local class they are declared by using the

keyword abstract.

It a class contains at least one abstract method then the entity class should be declared as

abstract.

Abstract methods are always declared in public (or) protected section.

We cannot instantiate the abstract classes because they are not fully implemented.

The class which ever inheritance the abstract class can implement the abstract method of

the abstract class otherwise the subclass will declared as abstract.

Abstract methods are also called as non-concerted methods.

We declared method as abstract when we are not sure about the implementation but we

are sure that the other classes as to use the same methods.

Z915AM_OOPS39:


CLASS RESTAURANT DEFINITION ABSTRACT.

PUBLIC SECTION.

METHODS : SET,

DISPLAY,

PAYMENT ABSTRACT.

PROTECTED SECTION.

DATA : TABLENO TYPE I,

STEWARD(20) TYPE C.

ENDCLASS. "restaurant DEFINITION


CLASS RESTAURANT IMPLEMENTATION.

METHOD SET.

TABLENO = 123.

STEWARD = 'abc'.

ENDMETHOD. "set

METHOD DISPLAY.

WRITE :/ TABLENO,STEWARD.

ENDMETHOD. "display

ENDCLASS. "restaurant IMPLEMENTATION

CLASS CHEQUE DEFINITION

INHERITING FROM RESTAURANT.

PUBLIC SECTION.

METHODS PAYMENT REDEFINITION.

PROTECTED SECTION.

DATA : CQNO TYPE I,

BANK(20) TYPE C,

AMT TYPE I.

ENDCLASS. "cheque DEFINITIO

CLASS CHEQUE IMPLEMENTATION.

METHOD PAYMENT.

CQNO = 3444.

BANK = 'xyz'.

AMT = 333.

WRITE :/ CQNO,BANK,AMT.

ENDMETHOD. "payment

ENDCLASS. "cheque IMPLEMENTATION

CLASS CREDITCARD DEFINITION

INHERITING FROM RESTAURANT.

PUBLIC SECTION.

METHODS PAYMENT REDEFINITION.

PROTECTED SECTION.

DATA : CCNO TYPE I,

AMOUNT TYPE I,

BANKNAME(20) TYPE C.

ENDCLASS. "creditcard DEFINITIO

CLASS CREDITCARD IMPLEMENTATION.

METHOD PAYMENT.

CCNO = 455.

AMOUNT = 432.

BANKNAME = 'abc'.

WRITE :/ CCNO,AMOUNT,BANKNAME.

ENDMETHOD. "payment

ENDCLASS. "creditcard IMPLEMENTATION

START-OF-SELECTION.


DATA R TYPE REF TO RESTAURANT.

DATA CQ TYPE REF TO CHEQUE.

CREATE OBJECT CQ.

WRITE :/ 'CHEQUE class'.

CALL METHOD : CQ->SET,

CQ->DISPLAY,

CQ->PAYMENT.

DATA CC TYPE REF TO CREDITCARD.

CREATE OBJECT CC.

WRITE :/ 'CREDIT CARD class'.

CALL METHOD : CC->SET,

CC->DISPLAY,

CC->PAYMENT.

WRITE :/ 'CHEQUE ----> RESTAURANT'.

R = CQ.

CALL METHOD : R->SET,

R->DISPLAY,

R->PAYMENT.

WRITE :/ 'CREDITCARD ----> RESTAURANT'.

R = CC.

CALL METHOD : R->SET,

R->DISPLAY,

R->PAYMENT.

OUTPUT:


Z915AM_REST:

method SET.

tableno = 1.

steward = 'abc'.

endmethod.

method DISPLAY.

write :/ tableno,steward.

endmethod.

Z915AM_CHEQUE:


method PAYMENT.

cqno = 123.

bank = 'yes'.

amount = 455.

write :/ cqno,bank,amount.

endmethod.

Z915AM_OOPS40:


data ob type ref to z915am_cheque.

create object ob.

CALL METHOD OB->SET.

CALL METHOD OB->DISPLAY.

CALL METHOD OB->PAYMENT.

OUTPUT:


Interfaces: - It is pure abstract class i.e. by default all methods of interface are abstract. By using

interfaces we can implement multiple inheritances.

By default the visibility of the interface components are public.

Interface methods contain only declaration but not implementation the implementation

must be provided in the corresponding class. The class whichever implements the

interface is called as implementation class and this class should implement all the

methods of the interface otherwise this class should be declaration as abstract.

A local class whichever wants to implement the interface must declared the interface in

the class definition by using interface keyword.

Syntax: - interface <interface name>.

A class can implement any number of interfaces which is nothing but multiple inheritance

whenever the interface component are referred the outside of the interface they must be prefixed

with the name of the interface.

Interface is always implemented in public section.

We cannot the instantiate the interfaces because it is not implemented.

Syntax for local interfaces: -

Interface <interface name>.

Declaration of components

End interface.

Z915AM_OOPS41:


INTERFACE RECTANGLE.

CONSTANTS : LENGTH TYPE I VALUE 10,

BREADTH TYPE I VALUE 5.

METHODS : AREA,

PERIMETER.

ENDINTERFACE. "rectangle

INTERFACE SQUARE.

CONSTANTS SIDE TYPE I VALUE 5.

METHODS : AREA,

PERIMETER.

ENDINTERFACE. "square


PUBLIC SECTION.

DATA RES TYPE I.

INTERFACES RECTANGLE.

INTERFACES SQUARE.




METHOD RECTANGLE~AREA.

RES = RECTANGLE~LENGTH * RECTANGLE~BREADTH.

WRITE :/ 'Area of rectangle is :',RES.

ENDMETHOD. "rectangle~area

METHOD RECTANGLE~PERIMETER.

RES = 2 * ( RECTANGLE~LENGTH + RECTANGLE~BREADTH ).

WRITE :/ 'perimeter of rectangle is :',RES.

ENDMETHOD. "rectangle~perimeter

METHOD SQUARE~AREA.

RES = SQUARE~SIDE * SQUARE~SIDE.

WRITE :/ 'Area of square is :',RES.

ENDMETHOD. "square~area

METHOD SQUARE~PERIMETER.

RES = 4 * SQUARE~SIDE.

WRITE :/ 'perimeter of square is :',RES.

ENDMETHOD. "square~perimeter


START-OF-SELECTION.

DATA R TYPE REF TO RECTANGLE.

DATA S TYPE REF TO SQUARE.

DATA K TYPE REF TO ABC.

CREATE OBJECT K.

CALL METHOD : K->RECTANGLE~AREA,

K->RECTANGLE~PERIMETER,

K->SQUARE~AREA,

K->SQUARE~PERIMETER.

WRITE :/ 'RECTANGLE ---> ABC'.

R = K.

CALL METHOD : R->AREA,

R->PERIMETER.

WRITE :/ 'SQUARE ---> ABC'.

S = K.

CALL METHOD : S->AREA,

S->PERIMETER.


OUTPUT:

Aliases: - aliases are the alternative names provided to the interface components i.e. whenever the

interface components is referred outside the interface declaration it must be prefixed with the name

of interface we can avoid the lengthy naming standard by declaring the aliases by the interface

components these aliases must be declared in the definition of a class whichever the implementing

the interface. By using aliases we can also change the visibility of the interface components.

ABSTRACT CLASSES

INTERFACES

Can contain both abstract and non-abstract

methods.

Can contain only abstract methods.

Explicitly we need to use abstract keyword. By default all methods are abstract.

Abstract methods can be declared in public or

protected section.

All components of interface by default are

public.

A class can inherit only one abstract class. A class can implement any know of interfaces.

Abstract class components are directly referred

in subclass.

Interface components must be prefixed with the

name of the interface.


Z915AM_OOPS42:


INTERFACE ABC.

METHODS : M1,

M2.

ENDINTERFACE. "abc

CLASS PQR DEFINITION.

PUBLIC SECTION.

INTERFACES ABC.

ALIASES : A1 FOR ABC~M1.

PROTECTED SECTION.

ALIASES A2 FOR ABC~M2.



METHOD A1.

WRITE :/ 'inside m1'.

CALL METHOD A2.

ENDMETHOD. "a1

METHOD A2.


ENDMETHOD. "a2


START-OF-SELECTION.

DATA K TYPE REF TO PQR.

CREATE OBJECT K.

CALL METHOD : K->A1.

OUTPUT:


Z915AM_INT1:

Z915AM_IMPL:

method Z915AM_INT1~M1.


call method a2.

endmethod.

method Z915AM_INT1~M2.


endmethod.


Z915AM_OOPS43:


data ob type ref to z915am_impl.

create object ob.

call method ob->a1.

OUTPUT:

Z915AM_OOPS44:


INTERFACE ABC.

METHODS : M1,

M2,

M3.

ENDINTERFACE. "abc

CLASS PQR DEFINITION ABSTRACT.

PUBLIC SECTION.

INTERFACES ABC ABSTRACT METHODS M2 M3.




METHOD ABC~M1.


ENDMETHOD. "abc~m1


CLASS XYZ DEFINITION INHERITING FROM PQR.

PUBLIC SECTION.

METHODS : ABC~M2 REDEFINITION,

ABC~M3 REDEFINITION.

ENDCLASS. "xyz DEFINITION

CLASS XYZ IMPLEMENTATION.

METHOD ABC~M2.


ENDMETHOD. "abc~m2

METHOD ABC~M3.


ENDMETHOD. "abc~m3

ENDCLASS. "xyz IMPLEMENTATION

START-OF-SELECTION.

DATA K TYPE REF TO XYZ.

CREATE OBJECT K.

CALL METHOD : K->ABC~M1,

K->ABC~M2,

K->ABC~M3.

OUTPUT:


Z915AM_OOPS45:


interface pqr.

methods : m1,

m3.

endinterface.

class abc definition abstract.

public section.

methods : m1 abstract,

m2.

endclass.


method m2.


endmethod.

endclass.

class xyz definition inheriting from abc.

public section.

interfaces pqr.

methods m1 redefinition.

endclass.

class xyz implementation.

method pqr~m1.

write :/ 'inside m1 of pqr'.

endmethod.

method m1.


endmethod.

method pqr~m3.


endmethod.

endclass.

start-of-selection.

data ob type ref to xyz.

create object ob.

call method : ob->m1,

ob->pqr~m1,

ob->pqr~m3,

ob->m2.


OUTPUT:

Persistence service: - It is used for storing the state of an object formality it is similarly to

serialization java and .net. This service is implemented by using persistence classes. This service is

implemented in two ways.

1) By using business key identity.

2) By using GUID (global unique identifier)

Storing the state of object permanently in the database is called as persistence.

By default the lifetime of the scope of an object is within the program where it is created.

Persistence class is always global and the naming standard is ‘ZCL_ (or) YCL’.

Persistence class is always created as protected class.

Whenever a persistence class is created SAP automatically create to class.

1) Base agent class naming standard is ‘ZCB_ (or) YCB_’.

2) Agent class or actor class ‘ZCA_ (or) YCA_’.

Base agent class is always created as abstract the class and it is the friend of persistence

class.

Actor class is always created as private class and it is a sub class of base agent class.

Once the persistence class is created it needs to mapped with the corresponding database

table.

Persistence class using business key identity: -

In this we consider the primary key fields of the database table as business key identity

which is used for identity the object uniquely.

In this case when the persistence class is mapped with the database tables SAP adds the

fields of the database as the attributes of the persistence class.

Also it creates the following methods as part of the base agent class.

1) Create_persistence.

2) Delete_persistence.

3) Get_persistence.

The above three method are public instance methods which gets inherited to actor class.

We need to use the above methods to interact with the persistence service.

A part from this SAP also generates getter and setter methods as part of persistence class.

Getter method is generated for all the fields of the database and setter methods are

generated for non-primary key fields of the table.


To access the above three methods we require the object of base agent class. But the base

agent class is always created as abstract class and therefore cannot be instated.

Since the above three method are inherited to actor class we need to instantiate the actor

class and access these methods. But actor class is created as private class and therefore

cannot be instated.

We use the following mechanize to access these methods.

Actor class is created as singleton class.

As part of the actor class SAP as provided a public static attribute agent.

We need to access this public static attribute agent using the actor class name. When

accessed internal it execute the static constructor of actor class it is reasonable for

creating the object. This object is return back using which we access the above three

methods.

Singleton class: -

Creating a class in such way so that we can create exactly one object is called as

singleton.

Z915AM_OOPS47:


class abc definition create private.

public section.


class-methods m1 returning value(m)

type ref to abc.

methods m2.

protected section.

class-data k type ref to abc.

endclass.



write :/ 'inside static constructor,about to create object'.

create object k.

endmethod.

method m1.

write :/ 'inside static method m1,about to return object'.

m = k.

endmethod.

method m2.

write :/ 'inside instance method m2'.

endmethod.

endclass.

start-of-selection.

data r type ref to abc.


*r = abc=>m1( ).

call method abc=>m1

receiving

m = r.

call method r->m2.

OUTPUT:

Z915AM_OOPS48:


PARAMETERS : P_DEPTNO TYPE Z730CDEPT-DEPTNO,

P_DNAME TYPE Z730CDEPT-DNAME,

P_LOC TYPE Z730CDEPT-LOC.

PARAMETERS : R1 RADIOBUTTON GROUP G1,

R2 RADIOBUTTON GROUP G1,

R3 RADIOBUTTON GROUP G1.

DATA ACTOR TYPE REF TO ZCA_915DEPT.

DATA PERS TYPE REF TO ZCL_915DEPT.

START-OF-SELECTION.

ACTOR = ZCA_915DEPT=>AGENT.

IF R1 = 'X'.

TRY.

CALL METHOD ACTOR->CREATE_PERSISTENT

EXPORTING

I_DEPTNO = P_DEPTNO

I_DNAME = P_DNAME

I_LOC = P_LOC

RECEIVING

RESULT = PERS.

IF PERS IS NOT INITIAL.


COMMIT WORK.

ENDIF.

CATCH CX_OS_OBJECT_EXISTING .

WRITE :/ 'Exception raised while creating'.

ENDTRY.

ELSEIF R2 = 'X'.

TRY.

CALL METHOD ACTOR->DELETE_PERSISTENT

EXPORTING

I_DEPTNO = P_DEPTNO.

COMMIT WORK.

CATCH CX_OS_OBJECT_NOT_EXISTING .

WRITE :/ 'Object not found'.

ENDTRY.

ELSEIF R3 = 'X'.

TRY.

CLEAR PERS.

CALL METHOD ACTOR->GET_PERSISTENT

EXPORTING

I_DEPTNO = P_DEPTNO

RECEIVING

RESULT = PERS.


CLEAR : P_DNAME,

P_LOC.

TRY.

CALL METHOD PERS->GET_DNAME

RECEIVING

RESULT = P_DNAME.

CATCH CX_OS_OBJECT_NOT_FOUND .

WRITE :/ 'Exception in getter of dname'.

ENDTRY.

TRY.

CALL METHOD PERS->GET_LOC

RECEIVING

RESULT = P_LOC.


WRITE :/ 'Exception in getter of loc'.

ENDTRY.

WRITE :/ 'Department name :',P_DNAME,

/ 'Department location :',P_LOC.

ENDIF.



ENDTRY.

ENDIF.


OUTPUT:

Persistence service using GUID: - In this we need to consider database table which contains

GUID as the first field. The data element of this field can be GUID/OS-GUID.

The data type of this field raw data type.

This field is used for unique identification of the object.

The value for this field is generated dynamically by SAP.

Note: - when a persistence class is mapped with the database table containing GUID also the field

expects the GUID are added as attribute of class and also getter and setter method are generated for

the entire field except GUID.

Z915AM_OOPS49:


PARAMETERS : P_DEPTNO TYPE Z915DEPT-DEPTNO,

P_DNAME TYPE Z915DEPT-DNAME,

P_LOC TYPE Z915DEPT-LOC,

P_GUID TYPE Z915DEPT-GUID.

PARAMETERS : R1 RADIOBUTTON GROUP G1,

R2 RADIOBUTTON GROUP G1,

R3 RADIOBUTTON GROUP G1.

DATA ACTOR TYPE REF TO YCA_915DEPT.

DATA PERS TYPE REF TO YCL_915DEPT.

DATA OB TYPE REF TO OBJECT.

START-OF-SELECTION.

ACTOR = YCA_915DEPT=>AGENT.

IF R1 = 'X'.

TRY.


EXPORTING

I_DEPTNO = P_DEPTNO

I_DNAME = P_DNAME


I_LOC = P_LOC

RECEIVING

RESULT = PERS.


COMMIT WORK.

ENDIF.


WRITE :/ 'Exception raised'.

ENDTRY.

ELSEIF R2 = 'X'.

TRY.

CALL METHOD ACTOR->IF_OS_CA_PERSISTENCY~GET_PERSISTENT_BY_OID

EXPORTING

I_OID = P_GUID

RECEIVING

RESULT = OB.

PERS ?= OB.


TRY.

CALL METHOD ACTOR->IF_OS_FACTORY~DELETE_PERSISTENT

EXPORTING

I_OBJECT = PERS.

COMMIT WORK.

CATCH CX_OS_OBJECT_NOT_EXISTING .


ENDTRY.

ENDIF.



CATCH CX_OS_CLASS_NOT_FOUND .

WRITE :/ 'class not found'.

ENDTRY.

ELSEIF R3 = 'X'.

TRY.

CALL METHOD ACTOR->IF_OS_CA_PERSISTENCY~GET_PERSISTENT_BY_OID

EXPORTING

I_OID = P_GUID

RECEIVING

RESULT = OB.

PERS ?= OB.


CLEAR : P_DEPTNO,

P_DNAME,

P_LOC.

TRY.

CALL METHOD PERS->GET_DEPTNO

RECEIVING


RESULT = P_DEPTNO.


WRITE :/ 'Exception in getdeptno'.

ENDTRY.

TRY.

CALL METHOD PERS->GET_DNAME

RECEIVING

RESULT = P_DNAME.


WRITE :/ 'Exception in getdname'.

ENDTRY.

TRY.

CALL METHOD PERS->GET_LOC

RECEIVING

RESULT = P_LOC.


WRITE :/ 'Exception in getloc'.

ENDTRY.

WRITE :/ 'Department no :',P_DEPTNO,

/ 'Department name :',P_DNAME,

/ 'Department loc :',P_LOC.

ENDIF.



CATCH CX_OS_CLASS_NOT_FOUND .

WRITE :/ 'class not found'.

ENDTRY.

ENDIF.

OUTPUT:


Z915_TRANS:

method M1.

data : trans_mng type ref to

if_os_transaction_manager,

trans type ref to

if_os_transaction.

CALL METHOD CL_OS_SYSTEM=>GET_TRANSACTION_MANAGER

RECEIVING

RESULT = trans_mng.

TRY.

CALL METHOD TRANS_MNG->CREATE_TRANSACTION

RECEIVING

RESULT = trans.

ENDTRY.

if trans is not initial.

TRY.

CALL METHOD TRANS->START.

call method m2.

TRY.

CALL METHOD TRANS->END.

CATCH CX_OS_CHECK_AGENT_FAILED .

CATCH CX_OS_TRANSACTION .

write :/ 'Exception in end'.

TRY.

CALL METHOD TRANS->UNDO.

ENDTRY.

ENDTRY.

CATCH CX_OS_TRANSACTION .

message 'Exception in transaction' type 'I'.

ENDTRY.

endif.

endmethod.

method M2.

data : actor type ref to zca_915dept,


pers type ref to zcl_915dept.

actor = zca_915dept=>agent.

if actor is not initial.

TRY.


EXPORTING

I_DEPTNO = '77'

I_DNAME = 'ABAP'

I_LOC = 'Ameerpet'

RECEIVING

RESULT = pers.


write :/ 'Exception in create persistent'.

ENDTRY.

endif.

endmethod.

Transaction service: - It is use for managing the object oriented transaction involving database

operations. As part of this we need to use the following class and interfaces.

1) CL_OS_SYSTEM CLASS

2) IF_OS_TRANSCATION_MANGAER INTERFACE

3) IT_OS_TRANSACTION INTERFACE

Procedure for interacting with transaction service: -

1) Start the object oriented transaction by calling the start method of the interface.

IT_OS_TRANSACTION

Start method is an instance method of interface IT_OS_TRANSACTION so we need to instantiate.

The interface IF_OS_TRANSACTION which cannot be done directly. So we need to access the

instance method Create_Transaction of the interface IF_OS_TRANSACTION_MANAGER to

access this method we required the object of transaction manger interface. To get these object of

transaction manger interface. To get this object we need to access the static method

GET_TRANSCATION_MANAGER of the class CL_OS_SYSTEM.

2) Perform the required operation: -

End the transaction by calling the end method of the interface IF_OS_TRASACTION.

When the transaction is successfully completed SAP issues commit work statement

internally for saving the transaction permanently.

If the transaction fails SAP raise the exception as part of this exception handling we need

to cancel the transaction by calling the undo method of the interface

IF_OS_TRANSCATION.


Z915AM_OOPS50:


data k type ref to z915_trans.

create object k.

CALL METHOD K->M1.

OUTPUT:

IT IS CONSIDERING IT AS TWO DIFFERENT PROGRAMS THAT’S WHY IT IS NOT

EXECUTING.

ZTR10:(TRANSACTION CODE)

Implementing persistence service using transaction service: -

Note: -

Transaction service is always implemented globally.

Since transaction service is implemented in global classes we need to attach a T-code for a

transaction class method so that everything will be executed as single process. If we access the

transaction class method form local program it executed the different process which are assuming

as two different translations.


Casting: - It is the process of converting a variable from one data type to another data types they

are two types.

1) Wide casting

2) Narrow casting

Wide casting: - It is the process of converting an object from a less detailed view to more detailed

view.

Narrow casting: - It is a process of converting an object from a more details view to be less

detailed view.

Procedure for deleting the persistent object using GUID: -

Check the existent persistent object using the method gets persistent OID. If the persistent object is

available it returns the object of object class which needs to be type casted to the corresponding

persistent class object. Pass the persistent class object as an input to the method.

‘DELETE_PERSISTENT.’

Event handling in object oriented: - As part of ABAP objects SAP as provided many events as

part of standard classes. These events are used in ALV reporting work flow customization CRM

technical DSP and webdynpro programming.

As part of custom classes we can declare user defined events. These event are declared are raised

and handle by the developer itself.

Procedure for interactive with user defined events in local class: -

Declare the event in the definition of the class.

Declare the event handler method in the definition of the class.

Implemented the event handler method in the class implementation.

Raise the event in one of method implementation.

Register the handlers.

Step1 Syntax: -

Events/class-events <event name> [exporting parameters list].

Step2 Syntax: -

Methods/class-methods <method name> for event <event name> of <class name> [importing

parameter list].

Step3 Syntax: -

Raise event <event name> [exporting parameter list].


Step4 Syntax: -

Set handler <handler> [for <instances>].

They are two types of events

1) Instant

2) Static

Instance events are declared by using keyword ‘events’.

Static events are declared by using keyword ‘class-events’.

Instance event is specific to an object.

They are static event is not specific to an object.

For every event there can be one are more event handler methods within the class are

across the classes.

These event handler methods are executed automatically whenever the event is raised are

triggered.

For executing the event handler methods we need to register the handlers. By using this

register handlers SAP will execute all the event handler methods. One after the other.

Accordingly to sequence of register.

Events can contains only exporting parameters which are imported by event handler

method these parameters are always passed by values. The parameter name in the event

as well as in event handler method must be same.

Note: - if the handler is not register events can be triggered but no actions can be performed

because the event handler methods will not be executed.

Z915AM_OOPS52:



PUBLIC SECTION.

EVENTS E1. "instance event

METHODS : M1 FOR EVENT E1 OF ABC, "instance event handler method

M2. "instance normal method



METHOD M1.

WRITE :/ 'inside event handler method m1'.

ENDMETHOD. "m1

METHOD M2.

WRITE :/ 'Inside m2,About to raise event'.

RAISE EVENT E1.

ENDMETHOD. "m2


START-OF-SELECTION.



CREATE OBJECT OB.

CALL METHOD OB->M2.

OUTPUT:

Z915AM_OOPS53:



public section.

events e1. "instance event

methods : m1 for event e1 of abc, "instance event handler method

m2. "instance normal method

endclass.


method m1.

write :/ 'inside event handler method m1'.

endmethod.

method m2.

write :/ 'Inside m2,About to raise event'.

raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.

call method ob->m2.

set handler ob->m1 for ob.


OUTPUT:

Z915AM_OOPS54:



public section.

events e1. "instance event

methods : m1 for event e1 of abc, "instance event handler method

m2. "instance normal method

endclass.


method m1.

write :/ 'inside event handler method m1'.

endmethod.

method m2.

write :/ 'Inside m2,About to raise event'.

raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.


call method ob->m2.

OUTPUT:


Z915AM_OOPS55:



public section.

events e1.

methods : m1 for event e1 of abc,

m2 for event e1 of abc,

m3.

endclass.


method m2.

write :/ 'inside second event handler method m2'.

endmethod.

method m1.

write :/ 'inside first event handler method m1'.

endmethod.

method m3.

write :/ 'inside m3,about to raise event'.

raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.



call method ob->m3.

OUTPUT:


Z915AM_OOPS56:



public section.

events e1.



m3.

endclass.


method m1.


endmethod.

method m2.


endmethod.

method m3.


raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.


create object ob1.




OUTPUT:


Z915AM_OOPS57:



public section.

events e1.



m3.

endclass.


method m1.


endmethod.

method m2.


endmethod.

method m3.


raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.


create object ob1.

set handler ob->m2 for ob1.

set handler ob->m1 for ob1.


OUTPUT:


Z915AM_OOPS58:



public section.

events e1.


m2.

endclass.


method m1.

write :/ 'inside m1, first event handler'.

endmethod.

method m2.

write :/ 'inside m2, about to raise event'.

raise event e1.

endmethod.

endclass.

class pqr definition.

public section.

methods m3 for event e1 of abc.

endclass.


method m3.

write :/ 'inside m3, second event handler'.

endmethod.

endclass.

start-of-selection.


create object ob1.


create object ob2.

set handler ob1->m1 for ob1.

set handler ob2->m3 for ob1.



OUTPUT:

For all instance: - while register the handler for register events as part of set handler statement we

need to specify the object name after for keyword. This is reasonable for raising the event. This as

to be done for every object separately which is raising the event instead of this we can use ‘FOR

ALL INSTANCE’ keyword.

As part of handler such that the event handler method will executed irrespective of object

used for raising the event.

Z915AM_OOPS59:



public section.

events e1.


m2.

endclass.


method m1.

write :/ 'inside event handler m1'.

endmethod.

method m2.

write :/ 'inside m2, about to raise event'.

raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob1.


create object ob2.

*set handler ob1->m1 for ob1.

*set handler ob1->m1 for ob2.


set handler ob1->m1 for all instances.



OUTPUT:

Static event: - While registering the handlers for static even we should not specify the object which

is reasonable raising the static event. Because static event is not specific to on object i.e. for

keyword is not allowed for the static event part of set handler this similarly for all instances in case

of instance event.

Z915AM_OOPS60:



public section.

class-events e1.


m2.

endclass.


method m1.

write :/ 'inside m1 event handler'.

endmethod.

method m2.

write :/ 'inside m2 about to raise static event'.

raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob1.



create object ob2.

set handler ob1->m1.



OUTPUT:

Static event handler method: -

Instance event can be raised only in instance methods.

Static event can be raised either in instance are static method.

Z915AM_OOPS61:



public section.

class-events e1.

class-methods m1 for event e1 of abc.

methods m2.

endclass.


method m1.

write :/ 'inside m1, static event handler'.

endmethod.

method m2.


raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.

set handler ABC=>m1.

CALL METHOD OB->m2.


OUTPUT:

Z915AM_OOPS62:



public section.

events e1.

class-methods m1 for event e1 of abc.

methods m2.

endclass.


method m1.

write :/ 'inside m1, static event handler'.

endmethod.

method m2.


raise event e1.

endmethod.

endclass.

start-of-selection.


create object ob.

set handler abc=>m1 for ob.

call method ob->m2.


OUTPUT:

Z915AM_OOPS63:



PUBLIC SECTION.

EVENTS E1 EXPORTING VALUE(X) TYPE I OPTIONAL.

METHODS : M1 FOR EVENT E1 OF ABC

IMPORTING X,

M2 IMPORTING Y TYPE I.



METHOD M1.

WRITE :/ 'inside event handler m1'.

WRITE :/ 'parameter received is ',X.

ENDMETHOD. "m1

METHOD M2.

WRITE :/ 'inside m2,about to raise event'.

RAISE EVENT E1

EXPORTING

X = Y.

ENDMETHOD. "m2


START-OF-SELECTION.


CREATE OBJECT OB.

PARAMETERS R TYPE I.

SET HANDLER OB->M1 FOR OB.

CALL METHOD OB->M2

EXPORTING

Y = R.


OUTPUT:

Z915AM_CLASS11:

method M1.

WRITE :/ 'INSIDE EVENT HANDLER'.

WRITE :/ 'PARAMETER RECEIVED IS ',P1.

endmethod.

method M2.

WRITE :/ 'INSIDE M2'.

RAISE EVENT E1

EXPORTING

P1 = 10.

endmethod.


Z915AM_OOPS64:



create object ob.


call method ob->m2.

OUTPUT:


Z915AM_RESTAURANT:

method SET.

TABLENO = 10.

STEWARD = 'ABC'.

endmethod.

method DISPLAY.

WRITE :/ TABLENO,STEWARD.

endmethod.

Z915AMCYCLE:


method SETCYCLE.

wheels = 2.

brakes = 2.

colour = 'blue'.

endmethod.

method DISPLAY.


endmethod.

Z915AMSCOOTER:


method SETSCOOTER.

wheels = 2.

brakes = 4.

colour = 'red'.

endmethod.

Z915AMCAR:


method SETCAR.

wheels = 4.

brakes = 5.

colour = 'cyan'.

endmethod.

Ooabap notes with_programs

Documents

Transcript of Ooabap notes with_programs