topic oops concepts in Application Development and Automation Discussions

(Advanced Business Application Programming) is a programming language for developing applications for the SAP R/3 system, a widely-installed business application subsystem.

The latest version, ABAP Objects, is object-oriented programming. SAP will run applications written using ABAP/4, the earlier ABAP version, as well as applications using ABAP Objects.

SAP's original business model for R/3 was developed before the idea of an object-oriented model was widespread. The transition to the object-oriented model reflects an increased customer demand for it. ABAP Objects uses a single inheritance model and full support for object features such as encapsulation, polymorphism, and persistence.

ABAP Objects

ABAP Objects is a new concept in R/3 System and you can find its two distinct meanings --- one is for the entire ABAP runtime environment and the other represents the new object-oriented generation of this language.

The Runtime Environment

ABAP Objects, for the entire ABAP runtime environment, are an indication of how SAP has, for sometime, been moving towards object orientation. Object-oriented techniques have been used exclusively in system design. The ABAP language did not support these techniques earlier.

The ABAP Workbench will allow creating R/3 Repository objects in this regard. These objects are programs, authorization objects, lock objects, customizing objects, and so on and so forth. By using function modules, one can also encapsulate functions in separate programs with a defined lnterface. The Business Object Repository (BOR) allows you to create SAP Business Objects for internal and external use.

The Object-Oriented Language Extension

ABAP Objects support object-oriented programming. The ABAP Objects is a complete set of object-oriented statements, which has been introduced into the ABAP language. This object-oriented extension of ABAP builds on the existing language and is fully compatible with it.

The Object Orientation (OO), also known as the object-oriented paradigm, is a programming model that unites data and functions in objects. You can not only use ABAP Objects in existing programs, but also work with and use a conventional ABAP in new ABAP Objects programs. The rest of the ABAP language is primarily intended for structured programming, where data is stored in a structured form in database tables and function-oriented programs access and work with it.

Moreover, we should know that the object-oriented enhancement of ABAP is based on the models of Java and C++. It is compatible with external object interfaces such as DCOM and CORBA. The implementation of object-oriented elements in the kernel of the ABAP language has considerably increased response times when you work with ABAP Objects. Some other objects, such as SAP Business Objects and GUI objects, which are already object-oriented by themselves, are also benefiting from being incorporated into ABAP Objects.

About Classes

The classes are templates for objects. An abstract description of an object is the class. You could say it is a set of instructions for building an object. The attributes of objects are defined by the components of the class, which describe the state and behavior of objects.

Local and Global Classes

In ABAP Objects, classes can be declared either globally or locally. You define global classes and interfaces in the Class Builder (Transaction SE24.} in the ABAP Workbench. In the R/3 Repository, they are stored centrally in class pools in the class library. In an R/3 System, all of the ABAP programs can access the global classes. The local classes are defined within an ABAP program. Local classes and interfaces can only be used in the program in which they are defined. When you use a class in an ABAP program, the system first searches for a local class with the specified name. If it does not find one, then it looks for a global class. Apart from the visibility question, there is no difference between using a global class and using a local class.

However, there is a significant difference in the way that local and global classes are designed. If you are defining a local class that is only used in a single program, then to define the outwardly visible components so that it fits into that program is usually sufficient. On the other hand, global classes must be able to be used anywhere. Since the system must be able to guarantee any program using an object of a global class, it can recognize the data type of each interface parameter and then certain restrictions are applied at the time of defining the interface of a global class.

Defining Local Classes

Local classes consist of ABAP source code, where the ABAP statements CLASS...ENDCLASS are enclosed. A complete class definition consists of the following parts, a declaration part and, if required, an implementation part. It is found that the declaration part of a class . Events have a similar parameter interface to methods, but only have output parameters. These parameters are passed by the trigger (RAISE EVENT statement) to the event handler method, which receives them as input parameters.

Using the SET HANDLER statement, the link between trigger and handler is established dynamically in a program. The trigger and handlers can be objects or classes, depending on whether you have instance or static events and event handler methods. When an event is triggered, the corresponding event handler methods are executed in all registered handling classes.

Features

Encapsulation

The three visibility areas (public section, protected section, private section) are the basis for one of the important features of object orientation, Encapsulation. You should take great care in designing the public components and try to declare as few public components as possible when you define a class. Once you have released the class, the public components of global classes may not be changed.

Public attributes are visible externally and form a part of the interface between an object and its users. If you want to encapsulate the state of an object fully, then you cannot declare any public attributes. Apart from defining the visibility of an attribute, you can also protect it from changes using the READ-ONLY addition.

Inheritance

Inheritance allows you to derive a new class from an existing class. It is done by using the INHERITING FROM addition in the statement:

CLASS . The new class is called the subclass of the class from which it is derived. The original class is called the superclass of the new class. It contains the same components as the superclass if you do not add any new declarations to the subclass. However, in the subclass only the public and protected components of the superclass are visible. The private components of the superclass are not visible though they exist in the subclass. You can declare private components in a subclass that have the same names as private components of the superclass. It is seen that each class works with its own private components. The another point that we note is that methods which a subclass inherits from a superclass use the private attributes of the superclass and not any private components of the subclass with the same names.

The subclass is an exact replica of the superclass if the superclass does not have any private visibility section. However, you can add a new component to the subclass because it allows you to turn the subclass into a specialized version of the superclass. If a subclass is itself the superclass of further classes, then you can introduce a new level of specialization.

Polymorphism

Reference variables are defined with reference to a superclass or an interface defined with reference to it can also contain references to any of its subclasses. A reference variable defined with reference to a superclass or an interface implemented by a superclass can contain references to instances of any of its subclasses, since subclasses contain all of the components of all of their superclasses and also convey that the interfaces of methods cannot be changed. In particular, you can define the target variable with reference to the generic class OBJECT.

Using the CREATE OBJECT statement, when you create an object and a reference variable typed with reference to a subclass then you can use the TY PE addition to which the reference in the reference variable will point.

A reference variable can be used by a static user to address the components visible to it in the superclass to which the reference variable refers. However, any specialization implemented in the subclass cannot be addressed by it.

Depending on the position in the inheritance tree at which the referenced object occurs, you can use a single reference variable to call different implementations of the method. This is possible only if you redefine an instance method in one or more subclasses. This concept is called polymorphism, in which different classes can have the same interface and, therefore, be addressed using reference variables with a single type.

Conclusion

I have explained object orientation which is such an important aspect in SAP. The discussion began with the features of Object Orientation and includes the runtime environment, the language extension, the classes and the class components. Apart from that I have also discussed for new first time readers event handling, inheritance encapsulation and polymorphism.

Re: oops concepts

Former Member — Wed, 24 Oct 2007 11:16:33 GMT

programming technique in which solutions reflect real world objects

What are objects ?

An object is an instantiation of a class. E.g. If “Animal” is a class, A cat

can be an object of that class .

With respect to code, Object refers to a set of services ( methods /

attributes ) and can contain data

What are classes ?

A class defines the properties of an object. A class can be instantiated

as many number of times

Advantages of Object Orientated approach

Easier to understand when the system is complex

Easy to make changes

Encapsulation - Can restrict the visibility of the data ( Restrict the access to the data )

Polymorphism - Identically named methods behave differently in different classes

Inheritance - You can use an existing class to define a new class

Polymorphism and inheritance lead to code reuse

Classes in abap

Classes in ABAP are either local or global

Global classes are declared in class builder (SE24 )

Local classes are declared within programs

Components of a class

Attributes : Internal data fields of class

Attributes can be either instance attributes – specific to each instance of the class ( object ) or static attributes which are common to all instances

Methods :

Subroutines / procedures in a class that define the behavior of the object. Methods can also be instance methods or static methods

Encapsulation in ABAP

Encapsulation is obtained through the restriction in visibility of attributes / methods attained through the definition of Public, Private and Protected section of a class

Public Section

All of the components declared in the public section are accessible to all users of the class, and to the methods of the class and any classes that inherit from it. The public components of the class form the interface between the class and its users.

Protected Section

All of the components declared in the protected section are accessible to all methods of the class and of classes that inherit from it.

Private Section

Components that you declare in the private section are only visible in the methods of the same class.

Inheritance in ABAP

Inheritance allows you to derive a class based on an already existing class.

CLASS <subclass> DEFINITION INHERITING FROM <superclass>.

…..

ENDCLASS.

CLASS <subclass> IMPLEMENTATION.

……

ENDCLASS.

All attributes / methods of super class become the property of the subclass too. Only public and protected attributes / methods are visible in the subclass

Polymorphism in ABAP

When methods with same name perform differently under different

circumstances we call it polymorphism.

Methods redefined in a subclass is an example for Polymorphism

Interfaces

Interfaces are used to define the model of a class.

They also like classes can be either local or global.

Global interfaces are defined through SE24 and local interfaces are defined in program.

Please check this online document (starting page 1291).

http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCABA/BCABA.pdf

Also check this links as well.

http://help.sap.com/saphelp_nw2004s/helpdata/en/ce/b518b6513611d194a50000e8353423/frameset.htm

http://www.sapgenie.com/abap/OO/

http://www.futureobjects.de/content/intro_oo_e.html

http://www.sap-img.com/abap/business-add-in-you-need-to-understand-abap-oo-interface-concept.htm

/people/ravikumar.allampallam/blog/2005/02/11/abap-oo-in-action

check the below links lot of info and examples r there

http://www.sapgenie.com/abap/OO/index.htm

http://www.geocities.com/victorav15/sapr3/abap_ood.html

http://www.brabandt.de/html/abap_oo.html

Check this cool weblog:

/people/thomas.jung3/blog/2004/12/08/abap-persistent-classes-coding-without-sql

http://help.sap.com/saphelp_nw04/helpdata/en/c3/225b5654f411d194a60000e8353423/content.htm

http://www.esnips.com/doc/375fff1b-5a62-444d-8ec1-55508c308b17/prefinalppt.ppt

http://www.sapgenie.com/abap/OO/

http://www.sapgenie.com/abap/OO/index.htm

For funtion module to class

http://help.sap.com/saphelp_47x200/helpdata/en/c3/225b5954f411d194a60000e8353423/content.htm

for classes

http://help.sap.com/saphelp_47x200/helpdata/en/c3/225b5c54f411d194a60000e8353423/content.htm

for methods

http://help.sap.com/saphelp_47x200/helpdata/en/08/d27c03b81011d194f60000e8353423/content.htm

for inheritance

http://help.sap.com/saphelp_47x200/helpdata/en/dd/4049c40f4611d3b9380000e8353423/content.htm

for interfaces

http://help.sap.com/saphelp_47x200/helpdata/en/c3/225b6254f411d194a60000e8353423/content.htm

For Materials:

http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCABA/BCABA.pdf -- Page no: 1291

http://www.amazon.com/gp/explorer/0201750805/2/ref=pd_lpo_ase/102-9378020-8749710?ie=UTF8

http://www.erpgenie.com/sap/abap/OO/index.htm

http://help.sap.com/saphelp_nw04/helpdata/en/ce/b518b6513611d194a50000e8353423/frameset.htm

Here I am giving one example to u check it. It is very helpful to u.

&----

*& Report ZEXAMPLE3

&----

REPORT ZTMW_WRKBNCH_TABS.

DATA:OKCODE LIKE SY-UCOMM. " ok code for screen 101

DATA:SCRNO(4) TYPE N. "FOR 101 SCREEN

DATA:T_NUM(2),SCR(4).

SELECT SINGLE WORK_BENCH_TAB INTO T_NUM FROM ZTMW_WRKBNCH_TAB

WHERE TAB_STATUS = 'X'.

IF STRLEN( T_NUM ) = 1.

CONCATENATE '300' T_NUM INTO SCR.

ELSE.

CONCATENATE '30' T_NUM INTO SCR.

ENDIF.

SCRNO = SCR.

CONTROLS TABS TYPE TABSTRIP. "TAB STRIP IN SCREEN 101

perform ref_texts.

SET SCREEN 0101.

DATA: h LIKE d020s,

f LIKE d021s OCCURS 0 WITH HEADER LINE,

e LIKE d022s OCCURS 0 WITH HEADER LINE,

m LIKE d023s OCCURS 0 WITH HEADER LINE,

f1(100), f2(100), f3(100), dynpro_id(44).

DATA:TAB(5) TYPE C,

tab_num type ztmw_wrkbnch_tab-WORK_BENCH_TAB,

tab_name type ztmw_wrkbnch_tab-TAB_NAME,

ACT_TAB(5) TYPE C,

TAB_STATUS TYPE ztmw_wrkbnch_tab-TAB_STATUS,NUM(2).

DATA:GT_ZTMW_HEADER_HIS TYPE TABLE OF ZTMW_HEADER_HIS,

GT_ZTMW_HEADER_WIP TYPE TABLE OF ZTMW_HEADER_WIP,

G_CONTAINER TYPE SCRFNAME VALUE 'TABC',

GRID1 TYPE REF TO CL_GUI_ALV_GRID,

G_CUSTOM_CONTAINER TYPE REF TO CL_GUI_CUSTOM_CONTAINER.

DATA:LAYOUT TYPE LVC_S_LAYO.

DATA:FCAT TYPE LVC_T_FCAT.

Field-symbols: <lfs_fieldcat> TYPE lvc_s_fcat.

&----

*& Module STATUS_0101 OUTPUT

MODULE STATUS_0101 OUTPUT.

SET PF-STATUS 'MENU1'.

SET TITLEBAR 'TIT1'.

DO 20 TIMES.

NUM = SY-INDEX.

CONCATENATE 'TAB' NUM INTO ACT_TAB.

SELECT TAB_STATUS INTO TAB_STATUS FROM ZTMW_WRKBNCH_TAB

WHERE WORK_BENCH_TAB = NUM.

IF tab_status = 'X'.

LOOP AT SCREEN.

IF SCREEN-NAME = ACT_TAB.

SCREEN-INVISIBLE = '0'.

MODIFY SCREEN.

ENDIF.

ENDLOOP.

ELSE.

LOOP AT SCREEN.

IF SCREEN-NAME = ACT_TAB.

SCREEN-INVISIBLE = '1'.

MODIFY SCREEN.

ENDIF.

ENDLOOP.

ENDIF.

ENDSELECT.

IF SY-SUBRC <> 0.

LOOP AT SCREEN.

IF SCREEN-NAME = ACT_TAB.

SCREEN-INVISIBLE = '1'.

MODIFY SCREEN.

ENDIF.

ENDLOOP.

ENDIF.

ENDDO.

ENDMODULE. " STATUS_0101 OUTPUT

&----

*& Module USER_COMMAND_0101 INPUT

MODULE USER_COMMAND_0101 INPUT.

CASE OKCODE.

WHEN 'TAB1'.

SCRNO = 3001.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB2'.

SCRNO = 3002.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB3'.

SCRNO = 3003.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB4'.

SCRNO = 3004.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB5'.

SCRNO = 3005.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB6'.

SCRNO = 3006.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB7'.

SCRNO = 3007.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB8'.

SCRNO = 3008.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB9'.

SCRNO = 3009.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB10'.

SCRNO = 3010.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB11'.

SCRNO = 3011.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB12'.

SCRNO = 3012.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB13'.

SCRNO = 3013.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB14'.

SCRNO = 3014.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB15'.

SCRNO = 3015.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB16'.

SCRNO = 3016.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB17'.

SCRNO = 3017.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB18'.

SCRNO = 3018.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB19'.

SCRNO = 3019.

TABS-ACTIVETAB = OKCODE.

WHEN 'TAB20'.

SCRNO = 3020.

TABS-ACTIVETAB = OKCODE.

WHEN 'BACK'.

set screen 0.

WHEN 'REFRESH'.

perform ref_texts.

ENDCASE.

ENDMODULE. " USER_COMMAND_0101 INPUT

FORM ref_texts .

Format Screen ID

dynpro_id = sy-repid.

dynpro_id+40(4) = '0101'.

Import Screen data in tables

IMPORT DYNPRO h f e m ID dynpro_id.

CHECK sy-subrc EQ 0.

Modify Screen Data

SELECT WORK_BENCH_TAB TAB_NAME into (tab_num,tab_name)

FROM ZTMW_WRKBNCH_TAB WHERE TAB_STATUS = 'X'.

CONCATENATE 'TAB' tab_num INTO TAB.

LOOP AT f WHERE fnam EQ TAB.

f-stxt = tab_name.

MODIFY f.

ENDLOOP.

ENDSELECT.

CHECK sy-subrc EQ 0.

Export Screen Data

EXPORT DYNPRO h f e m ID dynpro_id.

CHECK sy-subrc EQ 0.

Generate Screen for changes to take effect

GENERATE DYNPRO h f e m ID dynpro_id MESSAGE f1 LINE f2 WORD f3.

ENDFORM. " ref_texts

&----

*& Module STATUS_3007 OUTPUT

MODULE GRID OUTPUT.

IF G_CUSTOM_CONTAINER IS INITIAL.

CREATE OBJECT G_CUSTOM_CONTAINER

EXPORTING CONTAINER_NAME = G_CONTAINER.

CREATE OBJECT GRID1

EXPORTING I_PARENT = G_CUSTOM_CONTAINER.

PERFORM LAYOUT.

PERFORM FIELD_CAT.

PERFORM FILL_DATA.

CALL METHOD GRID1->SET_TABLE_FOR_FIRST_DISPLAY

EXPORTING

IS_LAYOUT = LAYOUT

CHANGING

IT_FIELDCATALOG = FCAT[]

IT_OUTTAB = GT_ZTMW_HEADER_HIS.

ENDIF.

ENDMODULE. " STATUS_3007 OUTPUT

&----

*& Form FIELD_CAT

&----

text

----

FORM FIELD_CAT.

CALL FUNCTION 'LVC_FIELDCATALOG_MERGE'

EXPORTING

I_STRUCTURE_NAME = 'ZTMW_HEADER_IO'

CHANGING

CT_FIELDCAT = FCAT[].

LOOP AT FCAT ASSIGNING <lfs_fieldcat>.

CASE <lfs_fieldcat>-fieldname.

WHEN 'TRANSACTION_NUM'.

<lfs_fieldcat>-coltext = 'IDOC no.'.

WHEN 'FEED_CODE'.

<lfs_fieldcat>-coltext = 'Feed Code'.

WHEN 'BOL_NUM'.

<lfs_fieldcat>-coltext = 'EXT. BOL'.

WHEN 'TERMINAL_CODE'.

<lfs_fieldcat>-coltext = 'Unc.Term Cd'.

WHEN 'TRANSCATION_DATE'.

<lfs_fieldcat>-coltext = 'Trans Date'.

WHEN 'TRANSCATION_TIME'.

<lfs_fieldcat>-coltext = 'Trans Time'.

WHEN 'TRANS_STATUS'.

<lfs_fieldcat>-coltext = 'BOL Status'.

WHEN 'VOID_STATUS'.

<lfs_fieldcat>-coltext = 'Void Status'.

WHEN 'HOLD_STATUS'.

<lfs_fieldcat>-coltext = 'Hold Status'.

WHEN 'PLANT'.

<lfs_fieldcat>-coltext = 'Plant'.

ENDCASE.

ENDLOOP.

ENDFORM. "FIELD_CAT

&----

*& Form FILL_DATA

&----

text

----

FORM FILL_DATA.

CLEAR GT_ZTMW_HEADER_HIS.

IF WIP_ONLY = 'X'.

SELECT * FROM ZTMW_HEADER_WIP INTO TABLE GT_ZTMW_HEADER_HIS.

UP TO MAX_HITS ROWS.
ELSEIF HIS_ONLY = 'X'.
SELECT * FROM ZTMW_HEADER_HIS INTO TABLE GT_ZTMW_HEADER_HIS
UP TO MAX_HITS ROWS.
ELSE.
SELECT * FROM ZTMW_HEADER_HIS INTO TABLE GT_ZTMW_HEADER_HIS.
SELECT * FROM ZTMW_HEADER_WIP INTO TABLE GT_ZTMW_HEADER_WIP.
INSERT LINES OF GT_ZTMW_HEADER_HIS INTO TABLE
GT_ZTMW_HEADER_WIP.
SORT GT_ZTMW_HEADER_WIP.
CLEAR GT_ZTMW_HEADER_HIS[].
INSERT LINES OF GT_ZTMW_HEADER_WIP FROM 1 TO MAX_HITS INTO
TABLE GT_ZTMW_HEADER_HIS .

ENDIF.

ENDFORM. "FILL_DATA

FORM LAYOUT.

LAYOUT-EDIT = 'X'.

layout-grid_title = 'List Of Bills Of Lading'