Category: ABAP

Preface – This post is part of the Object Oriented ABAP series.

Introduction

To understand an exception class, we need to understand what is an exception and when it is raised.

When we execute any program, some discrepancies can occur due to which a normal flow of execution gets interrupted and the behavior will not be the same as it was expected. That discrepancy is like an event which is occurring due to some reason, which is known as an ‘Exception’.

It is required to handle such discrepancies in order to prevent the execution flow of any program. In order to achieve that, SAP ABAP has a special class known as an ‘Exception Class’.

Exception Classes can be defined in a global class as well as in a local class. There are three exception classes exists, which are the subclasses of one root class ‘CX_ROOT’. Those three exception classes are:

1. CX_STATIC_CHECK – which is being checked by both compiler and runtime system.
2. CX_DYNAMIC_CHECK – Checked only at runtime system. All System exceptions will come under this exception.
3. CX_NO_CHECK – This type will be chosen if exceptions are frequent.

Definition

An Exception class is used to handle the discrepancies(exception) occurs during the execution a of program.

Whenever an exception occurs, an object is created (known as an exception object). The attributes of this object would contain information about the error. This exception can be caught by using TRY….CATCH…..ENDTRY block.

TRY….ENDTRY block contains a protected area, where an exception can be caught using the CATCH statement. One TRY….ENDTRY block can catch more than one exception, but it should get caught in a sequence in which it occurs.

There are two types of exception handling cases:

1. One where the exception was raised, deleted before or after handling it.
2. The other, where an exception which was raised is retained and the program is resumed after the statement that raised an exception.

Program

Let’s take an example of a simple arithmetic operation of two numbers. An exception should be raised if one of the two operands is missing.

NOTE: A local class is used in below sample program.

REPORT ztest_exception.

CLASS lcx_missing_operand DEFINITION

INHERITING FROM CX_STATIC_CHECK.

ENDCLASS.                                                 “lcx_missing_operand  DEFINITION

 

CLASS lcl_test_exception DEFINITION.

PUBLIC SECTION.

METHODS: add_numbers IMPORTING iv_num1 TYPE i OPTIONAL

iv_num2 TYPE i OPTIONAL

RETURNING VALUE(rv_calc) TYPE i

RAISING   lcx_missing_operand

PRIVATE SECTION.

METHODS: do_check RAISING  lcx_missing_operand.

DATA: lv_num1 TYPE i,

lv_num2 TYPE i,

lv_result TYPE i.

ENDCLASS.                                                      “lcl_test_exception DEFINITION

 

CLASS lcl_test_exception IMPLEMENTATION.

METHOD add_numbers.

v_num1 = iv_num1.

v_num2 = iv_num2.

me->do_check( ).

rv_calc = v_result.

ENDMETHOD.

 

METHOD do_check.

IF v_num1 IS INITIAL.

RAISE EXCEPTION TYPE lcx_missing_operand.

ENDIF.

ENDMETHOD.

 

ENDCLASS.                                                      “lcl_test_exception IMPLEMENTATION

 

START-OF-SELECTION.

DATA: lo_obj TYPE REF TO lcl_test_exception.

DATA: lo_exc_root TYPE REF TO CX_ROOT.

DATA: lv_msg TYPE STRING.

CREATE OBJECT lo_obj.

TRY .

lo_obj->add_numbers( iv_num1 = 10 ).

CATCH lcx_missing_operand.

WRITE: /  ‘Operand is missing’.

CATCH CX_ROOT INTO lo_exc_root.

lv_msg = lo_exc_root->get_text( ).

WRITE: / lv_msg.

ENDTRY.

Advantages

1. With exception classes, you can track the sequence of called methods. Since in exception class, we have try-end-try block, so we can put the called methods in it, to know if one of them get failed.
2. An exception class has an advantage that non-OO programmers won’t understand your code, increasing your job security a little.

Preface – This post is part of the Object Oriented ABAP series.

Introduction

One of the flavors of ABAP classes (Global Classes) we have already discussed in the last article. Another flavor of ABAP class are Local Classes. The only difference between a local class & global class is visibility & accessibility. A local class can be accessed within that program only in which it is being defined & implemented, whereas a global class can be accessed in any other program.

NOTE: In some of the previous articles, where different types of classes have been described, there the sample programs were the examples of local class only.

Definition

A class which is defined and implemented in a program is known as Local Class. Local classes in SAP ABAP can be created through Transaction code SE-38(tool to create a report).

Program

Let’s take an example of this class ‘ZCL_MARA’. This class is having one method ‘GET_MATERIAL_TYPE’  to get the material type of a given material.

NOTE: ‘MARA’ is a table in SAP ABAP for general material data. So, in this sample program, material (iv_matnr – importing parameter of a method) is given by the user, and this method will fetch the material type ( like finished, semi-finished, raw, etc. )

TYPES: BEGIN OF ty_mara,                                       “USER-DEFINED TYPES

Matnr TYPE mara-matnr,

Mtart TYPE mara-mtart,

END OF ty_mara.

CLASS zcl_mara DEFINITION.

PUBLIC SECTION.

METHODS: get_material_type

IMPORTING iv_matnr TYPE mara-matnr

EXPORTING ls_mara type ty_mara.

ENDCLASS.                                                                    “CLASS DEFINITION

 

CLASS zcl_mara IMPLEMENTATION.

METHOD get_material_type.

SELECT SINGLE matnr, mtart FROM mara INTO ls_mara

WHERE matnr = iv_matnr

ENDMETHOD.

ENDCLASS.                                                                   “CLASS IMPLEMENTATION

 

Advantages

1. To restrict the usage of any functionality, we can use it in a local class of any program.
2. A Local class is very useful while creating an ABAP Unit Test Class, as a local test class has been generated within a global class.
3. These classes are useful for the enhancements of class methods.

Preface – This post is part of the Object Oriented ABAP series.

Introduction

One of the three pillars of OOABAP uses this concept of Super class to achieve ‘Inheritance’. Super class allows us to extend that class by creating a subclass of it. This subclass will have all the properties of a super class, plus it can have additional properties as well.

Definition

A class which is having a derived class from it, is known as a ‘Super Class’.

To make a class Super Class, the first step is to uncheck the box indicating Final Class while creating a Class through T-Code SE24 (Class Builder). Because if a class is creating as a Final cannot be extended further, and inheritance cannot be achieved in that case.

If the developer is using this concept of the super class & subclass, then he/she can have all the advantages of ‘Inheritance’.

Program of Super Class in SAP ABAP:

Let’s take an example of this employer class ‘ZCL_EMPLOYER’. This employer class is having one method ‘GET_INCOME’ to get income.

CLASS zcl_employer DEFINITION.

PUBLIC SECTION.

METHODS: get_income RETURNING VALUE(income) TYPE F.

PRIVATE SECTION.

DATA: income TYPE F VALUE 100.

ENDCLASS.                                                                    “CLASS DEFINITION

CLASS zcl_employer IMPLEMENTATION.

METHOD get_income.

income = me->income * 80.

ENDMETHOD.

ENDCLASS.                                                                   “CLASS IMPLEMENTATION

 

Now, I want to create a subclass of it, where I want to redefine this method ‘GET_INCOME’.

CLASS zcl_manager DEFINITION INHERITING FROM zcl_employer.

PUBLIC SECTION.

METHODS: get_income REDEFINITION.

PRIVATE SECTION.

DATA: income TYPE F VALUE 100.

ENDCLASS.                                                                    “CLASS DEFINITION

CLASS zcl_manager IMPLEMENTATION.

METHOD get_income.

income = me->income * 100.

ENDMETHOD.

ENDCLASS.                                                                   “CLASS IMPLEMENTATION

 

Once you derived a class from another class, the new class will be known as ‘SUBCLASS’ or ‘CHILD CLASS’. And the class from which a new class is deriving will be known as ‘SUPER CLASS’ or ‘PARENT CLASS’.

As discussed earlier, the subclass can have all the properties, & methods of a super class. The developer can redefine the existing methods of the super class and he/she can also add some new functionality into it.

Advantages:

Provides reusability of code functionality & fast implementation time. It can have all the advantages of ‘Inheritance’.

Preface – This post is part of the Object Oriented ABAP series.

Introduction

From the reference of an article: SAP ABAP Classes we have discussed the flavors of ABAP Classes & we came to know that ABAP classes are available in two flavors, one of which is Global Class.

The visibility section of the global class is always public, meaning all the ABAP programs in an R/3 system can access the global class. However, instantiation of that class could be set as either public, protected or private.

Definition

A class which is defined in the class builder (Transaction Code – SE24) is known as Global Class.

While creating a class from Class Builder (T-code: SE24), we get many options that indicate which type of global class we want to create, for example, usual ABAP class, exception class, persistent class or a test class. It also gives an option of whether we want to make it final or not.

After selecting the type of class and properties ( description & instantiation ), a screen will come where we can see the components of a global class like:

1. Interfaces – Independent structures which are used in a class to extend the functionality of a class.
2. Friends – If there is any class, which you want to make a friend of your class, you can define it here.
3. Attributes – variables or constant declared within the class and can be accessed by all the methods of that class.
4. Methods – Determines the behavior of an object, it provides some functionality. A method is allowed to access all the attributes of their class.
5. Events – A mechanism through which one method can raise method of another class.
6. Types – Table Types can be defined here, that can further be used anywhere in the whole class.
7. Alias – A concept of providing an alternate method name for an interface method in an implemented class.

While defining an attribute and method, there are two mandatory fields, which we need to provide:

1. Level: We have 2 level options:

• Instance – Components declared as instance can only be addressed by the instance(object) of that class only.
• Static – Components declared as static can be used independently of a class instance.

2. Visibility: We have 3 Visibility options:

• Public – Components with this visibility will be available to all.
• Protected – Components will be visible to that class, where they are defined and to the inherited class.
• Private – Components will be visible to that class only, where they are defined.

Advantages:

Provides reusability of code functionality & fast implementation time.

Preface – This post is part of the Object Oriented ABAP series.

Introduction

Sometimes there is a need to instantiate an object at a time, that means only one instance is required at one point of time. This is a very common requirement while designing an application. To achieve such a scenario, there is one concept of ‘Singleton Pattern’ or ‘Singleton Class’ in OOABAP.

This was the theoretical part. Now, a question comes, that how to achieve it in real? So, here the answer is: By declaring the constructor as a ‘Private’ one.  This private constructor can be created after changing the instantiation type to private. This helps us to restrict the further creation of an object of a class.

Definition of Singleton Class in ABAP

A class is said to be a singleton class if it can have the utmost one instance only.

Following is a procedure to create a singleton class :

1. Visibility of class should be private.
2. Declare a private attribute with reference to the same class, in which it is being declared.
3. Create a public static method with returning parameter, having a reference of the same class.
4. Create an implementation and an object inside the implementation of a public static method.
5. To create an instance for the singleton class, call this public static method in any program.

Program:

For the better understanding of this Singleton Concept, let’s consider this below sample program and here as you can see that object creation of a singleton class is not possible outside the class. So, this is how a singleton pattern works.

Program Explanation:

In the above program, we have implemented a local class lcl_singleton_test inside an ABAP Report. In the class definition, we have kept the class as private and have declared a Public section. Under the public section, we have  declared a static attribute lo_singleton which refers to the program itself. Also, we have defined a local variable v of type integer. Then, we have defined the class constructor and a method set_name for the class.

Later, we have implemented the class where we are creating an object under class constructor. Also, we have assigned a value i.e. “GEETANSHU” to the local variable v.
Now, in the report code, we are doing a static call to our class via its object r1.

Advantages of Singleton Class in ABAP:

1. With the use of Singleton class, testability improves.
2. Singleton pattern supports the main moto of Object Oriented Design principle by allowing it to open for enhancements and closed for modifications.
3. The advantage of using a private constructor in Singleton class (as no one create an object of your class).

Preface – This post is part of the Object Oriented ABAP series.

Introduction

In simpler words, a class can be called as an abstract class, if it would contain at least one abstract method. Now, the question comes, what is an abstract method? An abstract method is a method which does not have an implementation. Now, a question will come to your mind, if a method is not having any implementation, then what is the use of this abstract method or class.

So, the answer to your question is: We can implement that abstract method, but not like any other simple class. There is a particular way to implement it.

To implement an abstract method, a subclass of an abstract class is required. There is no need to instantiate an object of an abstract class. Instantiation is possible only for the subclass. An abstract class can have non-abstract methods as well and It is not necessary to redefine non-abstract methods in each and every inherited class.

Following points, we need to remember while creating an abstract method:

1. Abstract methods can never be private.
2. Only instance methods are allowed to be an abstract method.

Definition:

Class with at least one abstract method (which does have implementation) is known as ‘Abstract class’.

Example: Let’s take a simple real time scenario, where ‘TELEPHONE’ is your class. This class is having four Methods (each method depicts one functionality):

1. PICKUP_CALL
2. DROP_CALL
3. REJECT_CALL
4. DIAL_NUMBER

For the first three methods, the functionality would be the same (meaning, you just need to click on one button). But in the fourth method, there could be many possibilities of dialing a number, say in case of an emergency, the dial number would be of three digits. Similarly, there will be different cases like dialing a landline number or a mobile number or some service number or some toll-free number etc.

So, here ‘DIAL_NUMBER’ method will be declared as an abstract method. Here, the functionality of this method is same, that is dialing a number. But the implementation could be different in different scenarios.

Program:

CLASS ZCL_TELEPHONE DEFINITION ABSTRACT.                                            “Abstract Class”

PUBLIC SECTION.

METHODS: DIAL_NUMBER ABSTRACT.                                                       “Abstract Method”

METHODS: PICKUP_CALL.

METHODS: DROP_CALL.                                                                                “Non-Abstract Methods”

METHODS: REJECT_CALL

ENDCLASS.

CLASS ZCL_SUBCLASS_TELEPHONE DEFINITION INHERITING FROM ZCL_TELEPHONE.        ‘
PUBLIC SECTION.
METHODS DIAL_NUMBER REDEFINITION.
ENDCLASS.

CLASS ZCL_SUBCLASS_TELEPHONE IMPLEMENTATION.
METHOD DIAL_NUMBER.
…
ENDMETHOD.
ENDCLASS.

Advantages:

1. Provide flexibility to add default operations with multiple flavors.
2. Abstract classes allow us to partially implement the class.
3. We can achieve Polymorphism by using an abstract class.
4. We can achieve Dynamic Binding also. The object of an abstract class can be used as a reference, which further could be replaced by the concrete object at runtime, this is known as dynamic binding.