英文原文：SAP-samples · 上游版本 d43eb13c4c7c · 原始 Markdown

ABAP Object Orientation

• ABAP Object Orientation
  • Classes and Objects
    • Creating Classes
      • Creating a Global Class
      • Creating a Local Class
      • Additions in the Class Declaration Part
      • Excursion: Class Pool and Include Programs
    • Visibility of Components
      • Creating the Visibility Sections
    • Defining Components
      • Class Attributes
      • Methods
      • Parameter Interface
      • Formal and Actual Parameters
      • Complete Typing of Formal Parameters
      • Generic Typing of Formal Parameters
      • Defining Parameters as Optional
      • Defining Input Parameters as Preferred
      • Constructors
  • Working with Objects and Components
    • Declaring Object Reference Variables
    • Creating Objects
    • Working with Reference Variables
    • Accessing Attributes
    • Calling Methods
      • Excursion: Inline Declarations, Returning Parameters
      • RETURN
    • Self-Reference me
    • Method Chaining and Chained Attribute Access
    • Excursion: Example Class
  • Inheritance
    • Additions Related to Inheritance and Instantiation
    • Excursion: Inheritance Example
  • Polymorphism and Casting (Upcast/Downcast)
    • Example with Local Classes Demonstrating Upcasts and Downcasts
    • Upcasts and Downcasts Using the RTTS Inheritance Tree
    • Checking the Dynamic Type of Object Reference Variables
  • Interfaces
    • Defining Interfaces
    • Implementing Interfaces
    • Additions Related to Interface Implementations
    • Interface Reference Variables, Accessing Objects and Components
    • Excursion: Example Interface
  • Friendship
    • Friendship between Global and Local Classes
  • Events
  • Excursions
    • ABAP Examples of Design Patterns in Object-Oriented Programming
    • Class-Based and Classic Exceptions
    • ABAP Unit Tests
    • ABAP Doc Comments
      • ABAP Doc Comments for Inline Declarations
    • Escape Character
    • Name Shadowing
    • COND/SWITCH and Type Inference with # for Actual Parameters in Case of Generic Formal Parameters
  • More Information
  • Executable Examples

This ABAP cheat sheet provides an overview on selected syntax options and concepts related to ABAP object orientation.

[!NOTE]

• The cheat sheet is supported by code snippets and an executable example. They are not suitable as role models for object-oriented design. Their primary focus is on the syntax and functionality.
• For more details, refer to the respective topics in the ABAP Keyword Documentation. Find an overview in the topic ABAP Objects - Overview.
• The executable examples reflect several points and code snippets covered in the cheat sheet.

Classes and Objects

Object-oriented programming in ABAP means dealing with classes and objects.

Objects ...

• are instances of a type. In this context, they are instances of a class. The terms object and instance are used synonymously.
• exist in the internal session of an ABAP program.

Classes ...

• are templates for objects, i. e. they determine how all instances of a class are set up. All instances are created (i.e they are instantiated) based on this template and, thus, have the same setup.
  • To give an example: If, for example, a vehicle represents a class, then the instances of the class vehicle have the same setup. That means they all share the same kind of components like a brand, model and color or the same functionality like the acceleration or braking distance. However, the values of these components are different from instance to instance. For example, one instance is a red sedan of brand A having a certain acceleration; another instance is a black SUV of brand B and so on. You can create an object (or instance respectively) that stands for an actual vehicle which you can work with. You might create any number of objects that are based on such a class - if instantiation is allowed.
• contain components:
  • Attributes of the objects (the data object declarations)
  • Methods that determine the behavior of an object
  • Events to trigger the processing of ABAP code

⬆️ back to top

Creating Classes

You can either create local or global classes:

[!NOTE]

• If a class is only used in one ABAP program, creating a local class is enough. However, if you choose to create a global class, you must bear in mind that such a class can be used everywhere. Consider the impact on the users of the global class when you change, for example, the visibility section of a component or you delete it.
• Apart from ADT, global classes can also be created in the ABAP Workbench (SE80) or with transaction SE24 in classic ABAP.

Basic structure of classes:

• Declaration part that includes declarations of the class components.
• Implementation part that includes method implementations.
• Both are introduced by CLASS and ended by ENDCLASS.

Creating a Global Class

The code snippet shows a basic skeleton of a global class. There are further additions possible for the declaration part.

"Declaration part
CLASS global_class DEFINITION
  PUBLIC                       "Makes the class a global class in the class library.
  FINAL                        "Means that no subclasses can be derived from this class.
  CREATE PUBLIC.               "This class can be instantiated anywhere it is visible.

    ... "Here go the declarations for all components and visibility sections.

ENDCLASS.

"Implementation part
CLASS global_class IMPLEMENTATION.

    ... "Here go the method implementations.
        "Only required if you declare methods in the DEFINITION part.

ENDCLASS.

⬆️ back to top

Creating a Local Class

• You can create local classes, for example, in the CCIMP include (Local Types tab in ADT) of a class pool.
• Local classes are used in their own ABAP program. While dynamic access beyond program boundaries is possible, it is not recommended.
• In the cheat sheet, local classes are used in several sections, particularly for self-contained examples that require multiple classes.

The following snippet shows the skeleton of local class declaration.

• The PUBLIC addition makes a class a global class in the class library. This is not possible for local classes.
• It does not specify CREATE .... Note that CREATE PUBLIC is the default, which means that not specifying any CREATE ... addition makes the class implicitly specified with CREATE PUBLIC.
• More additions are possible. They are covered in the following sections.

"Declaration part
CLASS local_class DEFINITION.

    ... "Here go the declarations for all components and visibility sections.
        "You should place the declarations at the beginning of the program.

ENDCLASS.

"Implementation part
CLASS local_class IMPLEMENTATION.

    ...  "Here go the method implementations.
         "Only required if you declare methods in the declaration part.

ENDCLASS.

⬆️ back to top

Additions in the Class Declaration Part

This section covers a selection of additions to declare classes. They are also covered in other sections below, e.g. Additions Related to Inheritance and Instantiation. Find more information on the additions in the ABAP Keyword Documentation. The additions assume dealing with global classes, however, many of the additions are also possible for local classes.

⬆️ back to top

Excursion: Class Pool and Include Programs

• A class pool is an ABAP program containing the definition of one global class (Global Class tab in ADT).
• Global classes are marked as such with the PUBLIC addition to the CLASS statement: CLASS zcl_demo_abap DEFINITION PUBLIC ...
• Additionally, a class pool can also contain local classes that are defined in dedicated include programs (CCDEF and the other include names are internal names the include programs end with):
  • CCDEF include (Class-relevant Local Types tab in ADT): Is included in front of the declaration part of the global class
  • CCIMP include (Local Types tab in ADT): Is included behind the declaration part and in front of the implementation part of the global class
  • CCAU include (Test classes tab in ADT): Test include; contains ABAP Unit test classes

The following simplified example demonstrates include programs.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
    "This method uses types (data type c1 and the local exception class)
    "defined in the CCDEF include
    METHODS calculate IMPORTING num1          TYPE i
                                operator      TYPE c1
                                num2          TYPE i
                      RETURNING VALUE(result) TYPE i
                      RAISING   lcx_wrong_operator.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    "The method called has formal parameters using type declarations from the CCDEF include
    TRY.
        DATA(result1) = calculate( num1 = 10 operator = '+' num2 = 4 ).
        out->write( data = result1 name = `result1` ).
      CATCH lcx_wrong_operator.
        out->write( `Operator not allowed` ).
    ENDTRY.

    TRY.
        DATA(result2) = calculate( num1 = 10 operator = '-' num2 = 4 ).
        out->write( data = result2 name = `result2` ).
      CATCH lcx_wrong_operator.
        out->write( `Operator not allowed` ).
    ENDTRY.

    TRY.
        DATA(result3) = calculate( num1 = 10 operator = '*' num2 = 4 ).
        out->write( data = result3 name = `result3` ).
      CATCH lcx_wrong_operator.
        out->write( `Operator not allowed` ).
    ENDTRY.

    "Using local class implemented in the CCIMP include
    DATA(hi1) = lcl_demo=>say_hello( ).
    out->write( data = hi1 name = `hi1` ).
    DATA(hi2) = lcl_demo=>say_hello( xco_cp=>sy->user( )->name ).
    out->write( data = hi2 name = `hi2` ).

    "Test include (CCAU)
    "For running the ABAP Unit test, choose CTRL+Shift+F10 in ADT.
    "Or you can make a right click in the class code, choose
    "'Run As' and '4 ABAP Unit Test'.
  ENDMETHOD.

  METHOD calculate.
    result = SWITCH #( operator
                       WHEN '+' THEN num1 + num2
                       WHEN '-' THEN num1 - num2
                       ELSE THROW lcx_wrong_operator( ) ).
  ENDMETHOD.

ENDCLASS.

CLASS lcx_wrong_operator DEFINITION INHERITING FROM cx_static_check.
ENDCLASS.

TYPES c1 TYPE c LENGTH 1.

CLASS lcl_demo DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS: say_hello IMPORTING name TYPE string optional
                             RETURNING VALUE(hi) type string.

ENDCLASS.

CLASS lcl_demo IMPLEMENTATION.

  METHOD say_hello.
    hi = |Hallo{ COND #( WHEN name IS SUPPLIED THEN ` ` && name ) }!|.
  ENDMETHOD.

ENDCLASS.

CLASS ltc_test DEFINITION DEFERRED.
CLASS zcl_demo_abap DEFINITION LOCAL FRIENDS ltc_test.

CLASS ltc_test DEFINITION FOR TESTING
RISK LEVEL HARMLESS
DURATION SHORT.

  PRIVATE SECTION.
    METHODS test_calculate FOR TESTING.

ENDCLASS.

CLASS ltc_test IMPLEMENTATION.

  METHOD test_calculate.
    "Creating an object of the class under test
    DATA(ref_cut) = NEW zcl_demo_abap( ).

    "Calling method that is to be tested
    TRY.
        DATA(result1) = ref_cut->calculate( num1 = 10 operator = '+' num2 = 4 ).
      CATCH lcx_wrong_operator.
    ENDTRY.

    TRY.
        DATA(result2) = ref_cut->calculate( num1 = 10 operator = '-' num2 = 4 ).
      CATCH lcx_wrong_operator.
    ENDTRY.

    "Assertions
    cl_abap_unit_assert=>assert_equals(
          act = result1
          exp = 14
          quit = if_abap_unit_constant=>quit-no ).

    cl_abap_unit_assert=>assert_equals(
          act = result2
          exp = 6
          quit = if_abap_unit_constant=>quit-no ).
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Visibility of Components

In the class declaration part, you specify three visibility sections and include class components to define their visibility. These visibility sections serve the purpose of encapsulation in ABAP Objects. For example, you do not want to make certain components publicly available for all users. The visibility sections are as follows:

PUBLIC SECTION.

PROTECTED SECTION.

PRIVATE SECTION.

Summary:

Creating the Visibility Sections

At least one section must be specified.

CLASS zcl_demo_abap DEFINITION
  PUBLIC                       
  FINAL                        
  CREATE PUBLIC.  

    PUBLIC SECTION.
      "Here go the components.
    PROTECTED SECTION.
      "Here go the components.
    PRIVATE SECTION.
      "Here go the components.
ENDCLASS.

...

⬆️ back to top

Defining Components

All components, i. e.

• attributes (using TYPES, DATA, CLASS-DATA, and CONSTANTS for data types and data objects),
• methods (using METHODS and CLASS-METHODS),
• events (using EVENTS and CLASS-EVENTS) as well as
• interfaces (only in the public visibility section),

are declared in the declaration part of the class. There, they must be assigned to a visibility section.

Two kinds of components are to be distinguished when, for example, looking at declarations using DATA and CLASS-DATA having a preceding CLASS-:

• Instance components: Components that exist separately for each instance and can only be accessed in instances of a class.
• Static components (the declarations with CLASS-): Components that exist only once per class. They do no not exclusively exist for specific instances. They can be addressed using the name of the class.

Class Attributes

• The attributes of a class (or interface) mean the data objects declared within a class (or interface).
• Instance attributes (DATA): Determine the state of objects of a class. The data is only valid in the context of an instance. As shown further down, instance attributes can only be accessed via an object reference variable (or interface reference variable).
• Static attributes (CLASS-DATA): Their content is independent of instances of a class and, thus, valid for all instances. That means that if you change such a static attribute, the change is visible in all instances. As shown further down, static attributes can be accessed by both using an object reference variable (however, this access is not recommended) and using the class name without a prior creation of an instance.

[!NOTE]

• You can declare constant data objects that should not be changed using CONSTANTS statements. You specify the values for the constants (which are also static attributes) when you declare them in the declaration part of a class.
• The addition READ-ONLY can be used in the public visibility section. Effect:
  • Can be read from outside of the class
  • Cannot be changed from outside
  • Can only be changed using methods of the class or its subclasses
• Note that when creating attributes in the public visibility section, they are globally visible and can therefore be globally used. Note the consequences on the users when changing attributes in the public visibility section (e.g. making an attribute read-only at a later point in time when, for example, other classes use the attribute).

Declaring attributes in visibility sections. In the code snippet below, all attributes are declared in the public section.

CLASS zcl_demo_abap DEFINITION
  PUBLIC                       
  FINAL                        
  CREATE PUBLIC.  

    PUBLIC SECTION.
      TYPES some_type TYPE c LENGTH 3.               "Type declaration

      DATA: inst_number TYPE i,                      "Instance attributes
            inst_string TYPE string,
            dobj_r_only TYPE c LENGTH 5 READ-ONLY.   "Read-only attribute

      CLASS-DATA: stat_number TYPE i,                "Static attributes
                  stat_char   TYPE c LENGTH 3.

      CONSTANTS const_num TYPE i VALUE 123.          "Non-changeable constant

    PROTECTED SECTION.
      "Here go more attributes if needed.

    PRIVATE SECTION.
      "Here go more attributes if needed.

ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.

      ... "Here go all method implementations.

ENDCLASS.

⬆️ back to top

Methods

• Are internal procedures determining the behavior of the class.
• Can access all of the attributes of a class and, if not defined otherwise, change their content.
• Have a parameter interface (also known as signature) with which methods can get values to work with when being called and pass values back to the caller (see the notes on formal and actual parameters below).
• Static methods can only access static attributes of a class and trigger static events. You declare them using CLASS-METHODS statements in a visibility section.
• Instance methods can access all of the attributes of a class and trigger all events. You declare them using METHODS statements in a visibility section. Note that you must create an instance of a class first before using instance methods. Called within the same class, an instance is not required.
• CLASS-METHODS and METHODS can be followed by a colon to list one or more methods, separated by commas, or without a colon to declare a single method.

The following code snippet (which anticipates aspects described in the following sections, such as specifying the method signature, constructors etc.) shows multiple method definitions in the public section of a global class. Most of the formal parameters of the demo methods below are defined by just using the parameter name. This means passing by reference (returning parameters require to be passed by value).

CLASS zcl_demo_abap DEFINITION
  PUBLIC                       
  FINAL                        
  CREATE PUBLIC. 

    PUBLIC SECTION.
      METHODS: inst_meth1,                                      "instance methods

               inst_meth2 IMPORTING a TYPE string,

               inst_meth3 IMPORTING b TYPE i
                          EXPORTING c TYPE i,

               inst_meth4 IMPORTING d TYPE string
                          RETURNING VALUE(e) TYPE string,

               "Note that method declarations should be done with care. An example
               "as follows may not be advisable, e.g. specifying multiple output
               "parameters (both exporting and returning parameters for a method).
               "As is valid for all examples in the cheat sheet, the focus is on
               "syntax options.
               inst_meth5 IMPORTING f TYPE i
                          EXPORTING g TYPE i
                          CHANGING  h TYPE string
                          RETURNING VALUE(i) TYPE i
                          RAISING   cx_sy_zerodivide,

              constructor IMPORTING j TYPE i.                   "instance constructor with importing parameter

      CLASS-METHODS: stat_meth1,                                "static methods  

                     stat_meth2 IMPORTING k TYPE i              
                                EXPORTING l TYPE i,

                     class_constructor,                         "static constructor

                     "Options of formal parameter definitions
                     stat_meth3 IMPORTING VALUE(m) TYPE i,       "pass by value
                     stat_meth4 IMPORTING REFERENCE(n) TYPE i,   "pass by reference
                     stat_meth5 IMPORTING o TYPE i,              "same as n; the specification of REFERENCE(...) is optional
                     stat_meth6 RETURNING VALUE(p) TYPE i,       "pass by value once more (note: it's the only option for returning parameters)

                     "OPTIONAL/DEFAULT additions
                     stat_meth7 IMPORTING q TYPE i DEFAULT 123
                                          r TYPE i OPTIONAL,

                     "The examples above use a complete type for 
                     "the parameter specification. Generic types
                     "are possible.
                     stat_meth8 IMPORTING s TYPE any           "Any data type
                                          t TYPE any table     "Any internal table type                 
                                          u TYPE clike.        "Character-like types (c, n, string, d, t and character-like flat structures)

ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
   METHOD inst_meth1.
      ...
   ENDMETHOD.

  ... "Further method implementations. Note that all declared methods must go here.
ENDCLASS.

⬆️ back to top

Parameter Interface

In the simplest form, methods can have no parameter at all. Apart from that, methods can be defined with the following parameters:

[!NOTE]

• It is advisable to avoid specifying multiple different output parameters (exporting, returning, changing) in a signature to reduce complexity.
• Find more information here.
• You may find the addition EXCEPTIONS especially in definitions of older classes. They are for non-class-based exceptions. This addition should not be used in ABAP for Cloud Development. See the section Class-Based Exceptions, and the section Classic Exceptions in the Exceptions and Runtime Errors cheat sheet.

⬆️ back to top

Formal and Actual Parameters

• Formal parameters: You define method parameters by specifying a name with a type which can be a generic or complete type.
• Examples:
  • fp is the formal parameter that has a complete type: ... meth IMPORTING fp TYPE string ...
  • gen is the formal parameter that has a generic type: ... meth IMPORTING gen TYPE any ...
  • Find more information about generic types also in the Data Types and Data Objects cheat sheet.
• This formal parameter includes the specification of how the value passing should happen. Parameters can be passed by ...
  • reference: ... REFERENCE(param) ...; note that just specifying the parameter name ... param ... - as a shorter syntax - means passing by reference by default)
  • value: ... VALUE(param) ...
• An actual parameter represents the data object whose content is passed to or copied from a formal parameter as an argument when a procedure is called.
• If passing by reference is used, a local data object is not created for the actual parameter. Instead, the procedure is given a reference to the actual parameter during the call and works with the actual parameter itself.
• Note that parameters that are input and passed by reference cannot be modified in the procedure. However, the use of a reference is beneficial regarding the performance compared to creating a local data object.

The following example (which anticipates aspects described in the following sections, such as calling methods) shows a class with a simple method demonstrating the syntax for formal parameter specifications. Complete types are used.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

    "Passing by reference and value
    METHODS: meth IMPORTING i_a            TYPE i
                            REFERENCE(i_b) TYPE string
                            VALUE(i_c)     TYPE i
                  RETURNING VALUE(r_a)     TYPE string.


  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    "The values 1, hello, and 2 are actual parameters supplied when 
    "the method is called.
    DATA(result) = meth( i_a = 1
                         i_b = `hello`
                         i_c = 2 ).

  ENDMETHOD.

  METHOD meth.
    ... "Method implementation

    "Input parameters passed by reference cannot be changed in the method implementation.
    "i_a += 1.
    "i_b &&= ` world`.

    "Input parameters passed by value can be changed in the method implementation.
    i_c += 1.

    r_a = `ABAP`.

  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Complete Typing of Formal Parameters

Syntax for completely typing a formal parameter:

• TYPE complete_type
• TYPE LINE OF complete_type
• TYPE REF TO type
• LIKE dobj
• LIKE LINE OF dobj
• LIKE REF TO dobj

[!NOTE]

• complete_type: Stands for a non-generic built-in ABAP, ABAP DDIC, ABAP CDS, a public data type from a global class or interface, or a local type declared with TYPES
• REF TO types as a reference variable. A generic type cannot be specified after REF TO. A typing with TYPE REF TO data and TYPE REF TO object is considered as completely typing a formal parameter.
• Enumerated types can also be used to type the formal parameter.
• The considerations also apply to the typing of field symbols.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

    "Local types and data objects used in the example
    TYPES c3 TYPE c LENGTH 3.
    TYPES der_type TYPE TABLE FOR CREATE zdemo_abap_rap_ro_m.
    DATA int TYPE i.
    DATA itab TYPE TABLE OF zdemo_abap_fli_ve WITH EMPTY KEY.

    "Various syntax options for completely typing formal parameters
    "Note: The example parameters are all specified for passing
    "actual parameters by reference.
    METHODS: meth IMPORTING
                    "Non-generic built-in ABAP types
                    i_a TYPE i
                    i_b TYPE string
                    "ABAP DDIC types
                    i_c TYPE land1           "elementary type
                    i_d TYPE timestampl      "elementary type
                    i_e TYPE zdemo_abap_fli "structured type based on DDIC database table
                    i_f TYPE string_hashed_table "table type
                    "ABAP CDS types (all of the examples are structured types)
                    i_g TYPE zdemo_abap_fli_ve "CDS view entity
                    i_h TYPE zdemo_abap_abstract_ent "CDS abstract entity
                    i_i TYPE zdemo_abap_table_function "CDS table function
                    "Data types declared in public section of a class
                    i_j TYPE zcl_demo_abap_dtype_dobj=>t_pub_text_c30 "elementary type
                    i_k TYPE zcl_demo_abap_amdp=>carr_fli_struc "structured type
                    i_l TYPE zcl_demo_abap_amdp=>carr_fli_tab "table type
                    "Data types declared in an interface
                    i_m TYPE zdemo_abap_get_data_itf=>occ_rate "elementary type
                    i_n TYPE zdemo_abap_get_data_itf=>carr_tab "table type
                    "Local types
                    i_o TYPE c3 "elementary type
                    i_p TYPE der_type "table type (BDEF derived type)
                    "Note: Examples such as the following are not allowed type specifications of formal parameters.
                    "In the following cases, extra (local) type declarations with TYPES are required before the
                    "method declaration to type the formal parameters.
                    "i_no1 TYPE c LENGTH 3
                    "i_no2 TYPE TABLE OF zdemo_abap_fli WITH EMPTY KEY
                    "Reference types
                    i_q TYPE REF TO i "Data reference
                    i_r TYPE REF TO zdemo_abap_carr "Data reference
                    i_s TYPE REF TO zcl_demo_abap_unit_test "Object reference
                    i_t TYPE REF TO data "Data reference (considered as complete typing, too)
                    i_u TYPE REF TO object "Object reference (considered as complete typing, too)
                    "TYPE LINE OF addition (structured type based on a table type)
                    i_v TYPE LINE OF zcl_demo_abap_amdp=>carr_fli_tab
                    i_w TYPE LINE OF der_type
                    "LIKE addition (types based on existing data objects)
                    i_x LIKE int "Local data object
                    i_y LIKE zcl_demo_abap_dtype_dobj=>comma "Constant specified in a class
                    i_z LIKE zdemo_abap_objects_interface=>stat_str "Data object specified in an interface
                    "LIKE LINE OF addition (types based on existing internal tables)
                    i_1 LIKE LINE OF itab "Local internal table
                    "LIKE REF TO addition (reference types based on existing data object)
                    i_2 LIKE REF TO int "Local elementary data object
                    i_3 LIKE REF TO itab "Local internal table
                  .

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    "Calling methods and providing actual parameters
*    meth(
*      i_a = 1
*      i_b = `hello`
*      ... ).

  ENDMETHOD.

  METHOD meth.
    ... "Method implementation
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Generic Typing of Formal Parameters

Find more information on generic types in the Data Types and Data Objects cheat sheet. The following code snippet anticipates aspects described in the following sections, such as calling methods.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

    "Partially generic structured type
    TYPES ty_struc_part_gen TYPE ANY STRUCTURE CONTAINING comp1 TYPE i
                                                          comp2 TYPE string.

    "Example method demonstrating the generic typing of formal parameters
    METHODS: meth IMPORTING
                    "Any data type
                    i_data           TYPE data
                    i_any            TYPE any

                    "Elementary types
                    i_c              TYPE c         "Text field with a generic length
                    i_clike          TYPE clike     "Character-like (c, n, string, d, t, and character-like flat structures)
                    i_csequence      TYPE csequence "Text-like (c, string)
                    i_n              TYPE n         "Numeric text with generic length
                    i_x              TYPE x         "Byte field with generic length
                    i_xsequence      TYPE xsequence "Byte-like (x, xstring)
                    i_decfloat       TYPE decfloat "decfloat16 decfloat34
                    i_numeric        TYPE numeric  "Numeric (i, int8, p, decfloat16, decfloat34, f, (b, s))
                    i_p              TYPE p        "Packed number (generic length and number of decimal places)

                    "Structured types
                    i_any_struc      TYPE ANY STRUCTURE  "Fully generic structure
                    i_part_gen_struc TYPE ty_struc_part_gen "Partially generic structure

                    "Table types
                    i_any_table      TYPE ANY TABLE      "Internal table with any table type
                    i_hashed_table   TYPE HASHED TABLE
                    i_index_table    TYPE INDEX TABLE
                    i_sorted_table   TYPE SORTED TABLE
                    i_standard_table TYPE STANDARD TABLE
                    i_table          TYPE table          "Standard table

                    "Other types
                    i_simple         TYPE simple "Elementary data type including enumerated types and
                                                 "structured types with exclusively character-like flat components
                  .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    "Structure including various components of specific types
    "They represent actual parameters in the method call below
    DATA: BEGIN OF s,
            c3        TYPE c LENGTH 3,
            c10       TYPE c LENGTH 10,
            n4        TYPE n LENGTH 4,
            str       TYPE string,
            time      TYPE t,
            date      TYPE d,
            dec16     TYPE decfloat16,
            dec34     TYPE decfloat34,
            int       TYPE i,
            pl4d2     TYPE p LENGTH 4 DECIMALS 2,
            tab_std   TYPE STANDARD TABLE OF string WITH EMPTY KEY,
            tab_so    TYPE SORTED TABLE OF string WITH NON-UNIQUE KEY table_line,
            tab_ha    TYPE HASHED TABLE OF string WITH UNIQUE KEY table_line,
            xl1       TYPE x LENGTH 1,
            xstr      TYPE xstring,
            structure TYPE zdemo_abap_carr, "character-like flat structure
          END OF s.

    "Data objects to demonstrate the partially generic structured type
    DATA: BEGIN OF s_demo1,
            comp1 TYPE i,
            comp2 TYPE string,
          END OF s_demo1.

    DATA: BEGIN OF s_demo2,
            comp1 TYPE i,
            comp2 TYPE string,
            comp3 TYPE c LENGTH 5,
          END OF s_demo2.

    DATA: BEGIN OF s_demo3,
            comp2 TYPE i,
            comp3 TYPE string,
          END OF s_demo3.

    DATA: BEGIN OF s_demo4,
            comp1 TYPE i,
            comp2 TYPE c LENGTH 5,
          END OF s_demo4.

    "The following method call specifies various actual parameters for the
    "generic formal parameters.
    "Note the comments for allowed and not allowed example assignments of
    "actual parameters.
    meth(
      "------------- Any data type -------------
      "--- data/any: Allowed (examples) ---
      i_data = s-c3
      "i_data = s-time
      "i_data = s-tab_std
      "i_data = s-xstr

      i_any = s-c3
      "i_any = s-time
      "i_any = s-tab_std
      "i_any = s-xstr

      "------------- Elementary types -------------
      "--- c: Allowed (examples) ---
      i_c = s-c3
      "i_c = s-c10
      "--- c: Not allowed (examples) ---
      "i_c = s-str
      "i_c = s-n4

      "--- clike: Allowed (examples) ---
      i_clike = s-c3
      "i_clike = s-c10
      "i_clike = s-str
      "i_clike = s-structure
      "i_clike = s-time
      "i_clike = s-date
      "i_clike = s-n4
      "--- clike: Not allowed (examples) ---
      "i_clike = s-xstr
      "i_clike = s-xl1
      "i_clike = s-pl4d2

      "--- csequence: Allowed (examples) ---
      i_csequence  = s-c3
      "i_csequence  = s-c10
      "i_csequence  = s-str
      "--- csequence: Not allowed (examples) ---
      "i_csequence  = s-time
      "i_csequence  = s-date
      "i_csequence  = s-structure

      "--- n: Allowed ---
      i_n = s-n4
      "--- n: Not allowed (examples) ---
      "i_n = s-c3
      "i_n = s-int

      "--- x: Allowed ---
      i_x = s-xl1
      "--- x: Not allowed (examples) ---
      "i_x = s-xstr
      "i_x = s-c3

      "--- xsequence: Allowed ---
      i_xsequence = s-xstr
      "i_xsequence = s-xl1
      "--- xsequence: Not allowed (examples) ---
      "i_xsequence = s-c3
      "i_xsequence = s-str

      "--- decfloat: Allowed ---
      i_decfloat = s-dec16
      "i_decfloat = s-dec34
      "--- decfloat: Not allowed (examples) ---
      "i_decfloat = s-int
      "i_decfloat = s-pl4d2

      "--- numeric: Allowed (examples) ---
      i_numeric  = s-int
      "i_numeric = s-dec16
      "i_numeric = s-dec34
      "i_numeric = s-pl4d2
      "--- numeric: Not allowed (examples) ---
      "i_numeric = s-n4
      "i_numeric = s-date

      "--- p: Allowed ---
      i_p = s-pl4d2
      "--- p: Not allowed (examples) ---
      "i_p = s-dec16
      "i_p = s-dec34

      "------------- Structured types -------------
      "--- any structure: Allowed ---
      "Fully generic structure: Any structure can be assigned
      i_any_struc = s
      "i_any_struc = s-structure
      "i_any_struc = s_demo1
      "i_any_struc = s_demo2
      "i_any_struc = s_demo3
      "i_any_struc = s_demo4
       "--- any structure: Not allowed (examples) ---
      "i_any_struc = s-n4
      "i_any_struc = s-tab_std

      "--- Partially generic structure: Allowed ---
      i_part_gen_struc = s_demo1
      "i_part_gen_struc = s_demo2
      "--- Partially generic structure: Not allowed (examples) ---
      "i_part_gen_struc = s_demo3
      "i_part_gen_struc = s_demo4
      "i_part_gen_struc = s
      "i_part_gen_struc = s-structure

      "------------- Table types -------------
      "--- any table: Allowed ---
      i_any_table = s-tab_std
      "i_any_table = s-tab_ha
      "i_any_table = s-tab_so
      "--- any table: Not allowed (examples) ---
      "i_any_table = s-structure
      "i_any_table = s-c3

      "--- hashed table: Allowed ---
      i_hashed_table = s-tab_ha
      "--- hashed table: Not allowed ---
      "i_hashed_table = s-tab_std
      "i_hashed_table = s-tab_so

      "--- index table: Allowed ---
      i_index_table = s-tab_std
      "i_index_table = s-tab_so
      "--- index table: Not allowed ---
      "i_index_table = s-tab_ha

      "--- sorted table: Allowed ---
      i_sorted_table = s-tab_so
      "--- sorted table: Not allowed ---
      "i_sorted_table = s-tab_std
      "i_sorted_table = s-tab_ha

      "--- standard table/table: Allowed ---
      i_standard_table = s-tab_std
      i_table = s-tab_std
      "--- standard table/table: Not allowed ---
      "i_standard_table = s-tab_so
      "i_standard_table = s-tab_ha
      "i_table = s-tab_so
      "i_table = s-tab_ha

      "------------- Other types -------------

     "--- simple: Allowed (examples) ---
      i_simple = s-structure
      "i_simple = s-c3
      "i_simple = s-n4
      "i_simple = s-int
      "i_simple = s-pl4d2
      "i_simple = s-xstr
      "i_simple = s-str
      "--- simple: Not allowed (examples) ---
      "i_simple = s-tab_ha
      "i_simple = s-tab_so
      "i_simple = s_demo1
      "i_simple = s_demo2
      "i_simple = s_demo3
      "i_simple = s_demo4
      "i_simple = s

     ).

  ENDMETHOD.

  METHOD meth.
    ... "Method implementation
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Defining Parameters as Optional

• Parameters specified after IMPORTING and CHANGING can be defined as optional using the OPTIONAL and DEFAULT additions:
  • OPTIONAL: It is then not mandatory to pass an actual parameter.
  • DEFAULT: Also makes the passing of an actual parameter optional. However, when using this addition, as the name implies, a default value is set.
  • In the method implementations you may want to check whether an actual parameter was passed. You can use predicate expressions using IS SUPPLIED. See the example further down.

The following example (which anticipates aspects described in the following sections, such as calling methods) includes three methods that specify optional parameters. The methods are called with and without providing actual parameters. The method implementations include the use of the predicate expression IS SUPPLIED with IF statements and the COND operator. The console output of the example, run with F9, is as follows:

meth1_result_a                                    
The parameter is not supplied. Initial value: "0".
meth1_result_b                        
The parameter is supplied. Value: "2".
meth2_result_a                                    
The parameter is not supplied. Default value: "1".
meth2_result_b                        
The parameter is supplied. Value: "3".
meth3_result_b                                                                                      
num1: "4" / num2 (is not supplied; initial value): "0" / num3 (is not supplied; default value): "1" 
meth3_result_c                                                                   
num1: "5" / num2 (is supplied): "6" / num3 (is not supplied; default value): "1" 
meth3_result_d                                                                   
num1: "7" / num2 (is not supplied; initial value): "0" / num3 (is supplied): "8" 

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
    METHODS meth1 IMPORTING num        TYPE i OPTIONAL
                  RETURNING VALUE(str) TYPE string.
    METHODS meth2 IMPORTING num        TYPE i DEFAULT 1
                  RETURNING VALUE(str) TYPE string.
    METHODS meth3 IMPORTING num1       TYPE i
                            num2       TYPE i OPTIONAL
                            num3       TYPE i DEFAULT 1
                  RETURNING VALUE(str) TYPE string.

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    DATA(meth1_result_a) = meth1( ).
    DATA(meth1_result_b) = meth1( 2 ).

    DATA(meth2_result_a) = meth2( ).
    DATA(meth2_result_b) = meth2( 3 ).

    "The commented out statement is not possible as there is one
    "non-optional parameter.
    "DATA(meth3_result_a) = meth3( ).
    DATA(meth3_result_b) = meth3( 4 ).
    DATA(meth3_result_c) = meth3( num1 = 5 num2 = 6 ).
    DATA(meth3_result_d) = meth3( num1 = 7 num3 = 8 ).

    out->write( data = meth1_result_a name = `meth1_result_a` ).
    out->write( data = meth1_result_b name = `meth1_result_b` ).
    out->write( data = meth2_result_a name = `meth2_result_a` ).
    out->write( data = meth2_result_b name = `meth2_result_b` ).
    out->write( data = meth3_result_b name = `meth3_result_b` ).
    out->write( data = meth3_result_c name = `meth3_result_c` ).
    out->write( data = meth3_result_d name = `meth3_result_d` ).

  ENDMETHOD.

  METHOD meth1.
    IF num IS SUPPLIED.
      str = |The parameter is supplied. Value: "{ num }".|.
    ELSE.
      str = |The parameter is not supplied. Initial value: "{ num }".|.
    ENDIF.
  ENDMETHOD.

  METHOD meth2.
    str = COND #( WHEN num IS SUPPLIED THEN |The parameter is supplied. Value: "{ num }".|
                  ELSE |The parameter is not supplied. Default value: "{ num }".|  ).
  ENDMETHOD.

  METHOD meth3.
    str = |num1: "{ num1 }" / |.

    str &&= |{ COND #( WHEN num2 IS SUPPLIED THEN |num2 (is supplied): "{ num2 }"|
                       ELSE |num2 (is not supplied; initial value): "{ num2 }"| ) } / |.

    str &&= |{ COND #( WHEN num3 IS SUPPLIED THEN |num3 (is supplied): "{ num3 }"|
                       ELSE |num3 (is not supplied; default value): "{ num3 }"| ) } |.
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Defining Input Parameters as Preferred

• Using the PREFERRED PARAMETER addition, you can flag an input parameter from the list as preferred.
• All parameters must be optional (i.e. specified with OPTIONAL or DEFAULT).
• The preferred parameter is implicitly optional, but you should explicitly specify it as OPTIONAL or DEFAULT, or a warning will be displayed.
• When you call a method and specify a single actual parameter without specifying the name of the formal parameter in an assignment, the actual parameter is automatically assigned to the preferred parameter.

The following example (which anticipates aspects described in the following sections, such as calling methods) shows a simple method with input parameters of type i (an addition is performed using the actual parameter values), where one parameter is preferred. The IS SUPPLIED addition in COND statements checks whether parameters are supplied. The final output shows the preferred parameter assigned automatically when the formal parameter is not specified explicitly. To try the example out, create a demo class named zcl_demo_abap and paste the code into it. After activation, choose F9 in ADT to execute the class. The example is set up to display output in the console. The example should display the following:

IS SUPPLIED: num1 "X", num2 "X", num3 "X" / Addition result "9"
IS SUPPLIED: num1 "X", num2 "X", num3 "" / Addition result "7"
IS SUPPLIED: num1 "", num2 "X", num3 "X" / Addition result "6"
IS SUPPLIED: num1 "X", num2 "", num3 "X" / Addition result "6"
IS SUPPLIED: num1 "", num2 "X", num3 "" / Addition result "4"
IS SUPPLIED: num1 "", num2 "", num3 "X" / Addition result "3"
IS SUPPLIED: num1 "", num2 "", num3 "" / Addition result "1"
IS SUPPLIED: num1 "X", num2 "", num3 "" / Addition result "4"

Example code:

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

    CLASS-METHODS meth
      IMPORTING num1        TYPE i OPTIONAL
                num2        TYPE i OPTIONAL
                num3        TYPE i DEFAULT 1
                PREFERRED PARAMETER num1
      RETURNING VALUE(text) TYPE string.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    DATA(text1) = meth( num1 = 3 num2 = 3 num3 = 3 ).
    out->write( text1 ).

    DATA(text2) = meth( num1 = 3 num2 = 3 ).
    out->write( text2 ).

    DATA(text3) = meth( num2 = 3 num3 = 3 ).
    out->write( text3 ).

    DATA(text4) = meth( num1 = 3 num3 = 3 ).
    out->write( text4 ).

    DATA(text5) = meth( num2 = 3 ).
    out->write( text5 ).

    DATA(text6) = meth( num3 = 3 ).
    out->write( text6 ).

    DATA(text7) = meth( ).
    out->write( text7 ).

    "Not specifying the name of the formal parameter. The
    "actual parameter is assigned to the preferred input
    "parameter.
    DATA(text8) = meth( 3 ).
    out->write( text8 ).
  ENDMETHOD.

  METHOD meth.
    DATA(addition) = num1 + num2 + num3.
    text = |IS SUPPLIED: num1 "{ COND #( WHEN num1 IS SUPPLIED THEN 'X' ELSE '' ) }", | &&
           |num2 "{ COND #( WHEN num2 IS SUPPLIED THEN 'X' ELSE '' ) }", | &&
           |num3 "{ COND #( WHEN num3 IS SUPPLIED THEN 'X' ELSE '' ) }" / | &&
           |Addition result "{ addition }"|.
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Constructors

• Constructors are special methods that are usually used for setting a defined initial value for attributes of the class or its objects.
• A class has exactly one instance constructor and one static constructor.
• The declaration and use of constructors is optional.
• Static constructor:
  • Declared using the predefined name class_constructor as part of a CLASS-METHODS statement in the public visibility section.
  • Has no parameters.
  • Automatically and immediately called once for each class when calling a class for the first time in an internal session, i. e. when, for example, an instance of a class is created or a component is used. Note: If it is not explicitly declared and implemented, it is merely an empty method.
• Instance constructor:
  • Declared using the predefined name constructor as part of a METHODS statement. In case of global classes, it can only be declared in the public visibility section.
  • Automatically called when a class is instantiated and an instance is created.
  • Can have IMPORTING parameters and raise exceptions.

The following example (which anticipates aspects described in the following sections, such as creating instances of classes) demonstrates static and instance constructors. To try the example out, create a demo class named zcl_demo_abap and paste the code into it. After activation, choose F9 in ADT to execute the class. The example is set up to display output in the console.

Notes:

• The example class defines the instance and static constructors.
• The instance constructor includes an optional importing parameter, which static constructors do not allow. If the parameter were not optional, the class would not run with F9, as it could not pass an actual parameter. In the example, the actual parameter indicates the name of the instance created for output purposes.
• The example class creates multiple instances.
• Both instance and static attributes of each instance are accessed and added to an internal table, which is then output.
• The constructor implementations include:
  • Instance constructor:
    • Stores the current timestamp in an instance attribute.
    • Maintains a call counter for the number of times the instance constructor is called, stored in a static attribute to reflect the count per internal session.
    • Stores the manually provided instance name in an instance attribute.
  • Static constructor:
    • Stores the current timestamp in a static attribute.
    • Maintains a call counter for static constructor calls, stored in a static attribute.
• The constructors demonstrate:
  • The static constructor is called only once, even when multiple class instances are created, leading to a constant static_timestamp value and stat_constr_call_count value, which remains 1.
  • The instance_timestamp attribute shows different timestamps for each created instance.
  • The static attribute instance_constr_call_count increases with each instance. Note that running the class with F9 in ADT also calls the instance and static constructors. Thus, the final instance_constr_call_count totals the number of DO loop passes plus 1, starting with 2 for inst1 instead of 1.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
    METHODS constructor IMPORTING text TYPE string OPTIONAL.
    CLASS-METHODS class_constructor.
  PROTECTED SECTION.
  PRIVATE SECTION.
    DATA instance_timestamp TYPE utclong.
    CLASS-DATA static_timestamp TYPE utclong.
    DATA instance_name TYPE string.
    CLASS-DATA stat_constr_call_count TYPE i.
    CLASS-DATA instance_constr_call_count TYPE i.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    DATA itab TYPE string_table.

    DO 5 TIMES.
      DATA(inst) = NEW zcl_demo_abap( |inst{ sy-index }| ).
      APPEND |-------------- Instance "{ inst->instance_name }" --------------| TO itab.
      APPEND |instance_timestamp: { inst->instance_timestamp }| TO itab.
      APPEND |static_timestamp: { inst->static_timestamp }| TO itab.
      APPEND |instance_constr_call_count: { inst->instance_constr_call_count }| TO itab.
      APPEND |stat_constr_call_count: { inst->stat_constr_call_count }| TO itab.
      APPEND INITIAL LINE TO itab.
    ENDDO.

    out->write( itab ).
  ENDMETHOD.

  METHOD class_constructor.
    static_timestamp = utclong_current( ).
    stat_constr_call_count += 1.
  ENDMETHOD.

  METHOD constructor.
    instance_timestamp = utclong_current( ).
    instance_constr_call_count += 1.

    IF text IS SUPPLIED AND text IS NOT INITIAL.
      instance_name = text.
    ENDIF.
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Working with Objects and Components

Declaring Object Reference Variables

• To create an object, an object reference variable must be declared.
• It is also necessary for accessing objects and their components. That means objects are not directly accessed but only via references that point to those objects.
• This object reference variable contains the reference to the object - after assigning the reference to the object (see further down).

"Declaring object reference variables
DATA: ref1 TYPE REF TO local_class,
      ref2 TYPE REF TO global_class,
      ref3 LIKE ref1.

⬆️ back to top

Creating Objects

• Using the instance operator NEW, you can create objects of a class (and anonymous data objects, too, that are not dealt with here). As a result, you get a reference variable that points to the created object.
• Regarding the type specifications before and parameters within the parentheses:
  • Right before the first parenthesis after NEW, the type, i. e. the class, must be specified. The # character - instead of the class name - means that the type (TYPE REF TO ...) can be derived from the context (in this case from the type of the reference variable). You can also omit the explicit declaration of a reference variable by declaring a new reference variable inline, for example, using DATA. In this case, the name of the class must be placed after NEW and before the first parenthesis.
  • No parameter specified within the parentheses: No values are passed to the instance constructor of an object. However, non-optional input parameters of the instance constructor of the instantiated class must be filled. No parameters are passed for a class without an explicitly declared instance constructor. See more information: here.
• The operator basically replaces the syntax CREATE OBJECT you might stumble on. However, CREATE OBJECT statements are still required (i.e. they are the only option, NEW is not possible for them) for creating objects dynamically. For more information, see the Dynamic Programming cheat sheet.

"Declaring object reference variable
DATA: ref1 TYPE REF TO some_class.

"Creating objects
ref1 = NEW #( ).                     "Type derived from already declared ref1

DATA(ref2) = NEW some_class( ).      "Reference variable declared inline, explicit type
                                     "(class) specification
"The assumption is that this class has no mandatory importing parameters for the 
"instance constructor. If a class has, actual parameters must be provided.                                      
DATA(ref_mand_param) = NEW another_class( ip1 = ... ip2 = ... ).

"Older syntax, replaced by NEW operator 
"However, CREATE OBJECT is required in dynamic object creation.
CREATE OBJECT ref3.                  "Type derived from already declared ref3
CREATE OBJECT ref4 TYPE some_class.  "Corresponds to the result of the expression above

⬆️ back to top

Working with Reference Variables

This section covers some aspects of working with reference variables. Find a copyable example demonstrating the aspects in the next section.

Assigning Reference Variables

To assign or copy reference variables, use the assignment operator =. In the example below, both object reference variables have the same type. Note the concepts of polymorphism, upcasts and downcasts when assigning reference variables covered further down.

DATA: ref1 TYPE REF TO some_class,
      ref2 TYPE REF TO some_class.

ref1 = NEW #( ).

"Assigning existing reference
ref2 = ref1.

Overwriting reference variables: An object reference is overwritten when a new object is created with a reference variable already pointing to an instance.

DATA ref TYPE REF TO some_class.

"Creating a new object
"The example assumes there is a mandatory importing parameter for the 
"instance constructor.
ref = NEW #( 1 ).

"Creating another object using the same object reference variable
"The existing reference is overwritten.
ref = NEW #( 1 ).

Retaining object references:

• If your use case is to retain the object references, for example, if you create multiple objects using the same object reference variable, you can put the reference variables in internal tables that are declared using ... TYPE TABLE OF REF TO ....
• The following code snippet just visualizes that the object references are not overwritten. Three objects are created with the same reference variable. The internal table includes all object references and, thus, their values are retained.

DATA: ref TYPE REF TO some_class,
      itab TYPE TABLE OF REF TO some_class.

DO 3 TIMES.
  ref = NEW #( ).
  itab = VALUE #( BASE itab ( ref ) ).   "Adding the reference to itab
ENDDO.

Clearing object references: You can use CLEAR statements to explicitly clear a reference variable.

CLEAR ref.

[!NOTE] Objects use up space in the memory and should therefore be cleared if they are no longer needed. However, the garbage collector is called periodically and automatically by the ABAP runtime framework and clears all objects without any reference.

⬆️ back to top

Accessing Attributes

• Instance attributes: Accessed using the object component selector -> via a reference variable.
• Static attributes: Accessed (if the attributes are visible) using the class component selector => via the class name. Static attributes can but should not be addressed via a reference variable.

"Accessing instance attribute via an object reference variable
... ref->some_attribute ...

"Accessing static attributes via the class name
... some_class=>static_attribute ...

"Without the class name only within the class itself
... static_attribute ...

"Type and data object declarations
TYPES some_type LIKE some_class=>some_static_attribute.
DATA dobj1      TYPE some_class=>some_type.
DATA dobj2      LIKE some_class=>some_static_attribute.

The following executable example addresses aspects of this section and the previous one:

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
    METHODS constructor IMPORTING ts TYPE utclong OPTIONAL.
    DATA timestamp TYPE utclong.
    DATA instance_number TYPE i.
    CLASS-DATA static_number TYPE i.
    TYPES chars TYPE c LENGTH 4.
    CONSTANTS text TYPE chars VALUE `ABAP`.
  PROTECTED SECTION.
  PRIVATE SECTION.
    CLASS-METHODS test_static_method.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA oref TYPE REF TO zcl_demo_abap.
    DATA oref2 TYPE REF TO zcl_demo_abap.

*&---------------------------------------------------------------------*
*& Assigning object reference variables
*&---------------------------------------------------------------------*

    oref = NEW #( utclong_current( ) ).

    "Accessing instance attribute
    DATA(ts1) = oref->timestamp.
    out->write( data = ts1 name = `ts1` ).

    "Assigning reference to existing reference variable
    oref2 = oref.
    DATA(ts2) = oref2->timestamp.
    out->write( data = ts2 name = `ts2` ).

*&---------------------------------------------------------------------*
*& Overwriting a reference variable
*&---------------------------------------------------------------------*

    oref = NEW #( utclong_current( ) ).
    DATA(ts3) = oref->timestamp.
    out->write( data = ts3 name = `ts3` ).

*&---------------------------------------------------------------------*
*& Retaining object references
*&---------------------------------------------------------------------*

    DATA oref_tab TYPE TABLE OF REF TO zcl_demo_abap.

    DO 3 TIMES.
      oref = NEW #( utclong_current( ) ).
      oref->instance_number = sy-index.
      oref->static_number = sy-index.
      oref_tab = VALUE #( BASE oref_tab ( oref ) ).
    ENDDO.

    out->write( data = oref_tab name = `oref_tab` ).

*&---------------------------------------------------------------------*
*& Clearing object references
*&---------------------------------------------------------------------*

    DATA oref_generic TYPE REF TO object.
    oref_generic = NEW zcl_demo_abap( utclong_current( ) ).

    IF oref_generic IS INITIAL.
      out->write( `oref_generic is initial` ).
    ELSE.
      out->write( `oref_generic is not initial` ).
    ENDIF.

    IF oref_generic IS INSTANCE OF zcl_demo_abap.
      out->write( `oref_generic is an instance of zcl_demo_abap` ).
    ELSE.
      out->write( `oref_generic is not an instance of zcl_demo_abap` ).
    ENDIF.

    CLEAR oref_generic.

    IF oref_generic IS INITIAL.
      out->write( `oref_generic is initial` ).
    ELSE.
      out->write( `oref_generic is not initial` ).
    ENDIF.

    IF oref_generic IS INSTANCE OF zcl_demo_abap.
      out->write( `oref_generic is an instance of zcl_demo_abap` ).
    ELSE.
      out->write( `oref_generic is not an instance of zcl_demo_abap` ).
    ENDIF.

*&---------------------------------------------------------------------*
*& Accessing class attributes
*&---------------------------------------------------------------------*

    "Accessing instance attribute via an object reference variable
    oref = NEW #( utclong_current( ) ).
    "Read access
    DATA(ts4) = oref->timestamp.
    "Write access
    oref->instance_number = 123.

    "Accessing static attributes via the class name
    "Write access
    zcl_demo_abap=>static_number = 456.
    "Read access
    DATA(static_attr_access) = zcl_demo_abap=>static_number.
    "Read access (constant)
    DATA(const_value) = zcl_demo_abap=>text.

    "Accessing static attributes within the class without specifying the class name
    "See the test_static_method method for restrictions regarding instance attributes.
    "Write access
    static_number = 789.
    "Read access
    static_attr_access = static_number.
    "Read access (constant)
    const_value = text.

    "Type and data object declarations based on class attributes
    TYPES type1 TYPE zcl_demo_abap=>chars.
    TYPES type2 LIKE zcl_demo_abap=>static_number.
    TYPES type3 LIKE zcl_demo_abap=>text.
    DATA dobj1 TYPE zcl_demo_abap=>chars.
    DATA dobj2 LIKE zcl_demo_abap=>static_number.
    DATA dobj3 LIKE zcl_demo_abap=>text.

    "Without class name specification within the class itself
    TYPES type4 TYPE chars.
    TYPES type5 LIKE static_number.
    TYPES type6 LIKE text.
    DATA dobj4 TYPE chars.
    DATA dobj5 LIKE static_number.
    DATA dobj6 LIKE text.

    "Using instance attributes
    "Note: You can access static attributes via object reference variables.
    "However, it is advisable to access static attributes as shown above.
    DATA(oref3) = NEW zcl_demo_abap( utclong_current( ) ).
    TYPES type7 TYPE oref3->chars.
    TYPES type8 LIKE oref3->instance_number.

    DATA dobj7 TYPE oref3->chars.
    DATA dobj8 LIKE oref3->timestamp.
  ENDMETHOD.

  METHOD constructor.
    timestamp = ts.
  ENDMETHOD.

  METHOD test_static_method.
    "Accessing static attributes
    zcl_demo_abap=>static_number = 987.
    "Read access
    DATA(static_attr_access) = zcl_demo_abap=>static_number.
    "Read access (constant)
    DATA(const_value) = zcl_demo_abap=>text.

    "Accessing attributes within the class without specifying the class name
    "Write access
    static_number = 654.
    "Read access
    static_attr_access = static_number.
    "Read access (constant)
    const_value = text.

    "Access to instance attributes in static methods like above is not possible
    DATA inst_attr_access TYPE utclong.
    "inst_attr_access = timestamp.
    "Instance attribute access via object reference variable
    DATA(oref) = NEW zcl_demo_abap( utclong_current( ) ).
    inst_attr_access = oref->timestamp.
  ENDMETHOD.
ENDCLASS.

⬆️ back to top

Calling Methods

• Similar to accessing attributes, instance methods are called using -> via a reference variable.
• Static methods are called using => via the class name. When used within the class in which it is declared, the static method can also be called without class_name=>....
• Static methods can but should not be called via reference variable (oref->some_static_method( ).).
• When methods are called, the (non-optional) parameters must be specified within parentheses.
• You might also stumble on method calls with the older CALL METHOD statements. It is recommended to use the new syntax in new developments. Note that CALL METHOD statements are still required in the context of dynamic programming. Therefore, CALL METHOD statements should be reserved for dynamic method calls.
• Find an example class demonstrating various method calls in section Excursion: Example Class.
• When calling methods that declare importing and/or exporting parameters, keep the following in mind: For methods with importing parameters, you can or must (if other parameters are available and specified in the method call) precede the parameters and their assignments with EXPORTING. For methods with exporting parameters, you can or must use IMPORTING before the parameters and their assignments.

Examples for instance method calls and static method calls:

"Calling instance methods via reference variable;
"within the parentheses, the parameters must be specified and assigned - if required

ref->inst_meth( ... ).

"Calling static methods via/without the class name

class_name=>stat_meth( ... ).

"Only within the program in which it is declared.
stat_meth( ... ).

"Calling (static) method having no parameter

class_name=>stat_meth( ).

"Calling (static) methods having a single importing parameter:

"Note that in the method call, the caller exports values to the
"method having importing parameters defined; hence, the addition
"EXPORTING is relevant for the caller. The following three method calls are the same

"Explicit use of EXPORTING.
class_name=>meth( EXPORTING a = b ).

"Only importing parameters in the method signature: explicit EXPORTING not needed

class_name=>meth( a = b ).

"If only a single value must be passed:
"the formal parameter name (a) and EXPORTING not needed

stat_meth( b ).

"Calling (static) methods having importing/exporting parameters
"Parameters must be specified if they are not marked as optional

class_name=>meth( EXPORTING a = b c = d     "a/c: importing parameters in the method signature
                  IMPORTING e = f ).        "e: exporting parameter in the method signature

"To store the value of the parameter, you may also declare it inline.

class_name=>meth( EXPORTING a = b c = d
                  IMPORTING e = DATA(z) ).  

"Calling (static) methods having a changing parameter;
"should be reserved for changing an existing local variable and value

DATA h TYPE i VALUE 123.
class_name=>meth( CHANGING g = h ).

"Calling (static) methods having a returning parameter.
"Basically, they do the same as methods with exporting parameters
"but they are way more versatile, and you can save lines of code.

"They do not need temporary variables.
"In the example, the return value is stored in a variable declared inline.

"i and k are importing parameters
DATA(result) = class_name=>meth( i = j k = l ).

"They can be used with other statements, e. g. logical expressions.
"In the example below, the assumption is that the returning parameter is of type i.
IF class_name=>meth( i = j k = l ) > 100.
  ...
ENDIF.

"They enable method chaining.
"The example shows a method to create random integer values.
"The methods have a returning parameter.
DATA(random_no) = cl_abap_random_int=>create( )->get_next( ).

"RECEIVING parameter: Available in methods defined with a returning parameter;
"used in standalone method calls only.
"In the snippet, m is the returning parameter; n stores the result.
class_name=>meth( EXPORTING i = j k = l RECEIVING m = DATA(n) ).

⬆️ back to top

Excursion: Inline Declarations, Returning Parameters

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
    CLASS-METHODS meth1 IMPORTING i_str        TYPE string
                                  i_tab        TYPE string_table OPTIONAL
                        EXPORTING e_dec        TYPE decfloat34
                                  e_tab        TYPE string_table
                        RETURNING VALUE(r_int) TYPE i.
    CLASS-METHODS meth2 RETURNING VALUE(r_tab) TYPE string_table.
  PROTECTED SECTION.
  PRIVATE SECTION.

ENDCLASS.


CLASS zcl_demo_abap IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.    
    "Note: Calling the method in the same class means specifying 'zcl_demo_abap=>' is optional here.

    "Standalone method call
    "Specifying target data objects for all output parameters
    "Inline declarations are handy because you can create an
    "appropriately typed data object in place. No need to
    "create an extra variable, check on the type etc.
    zcl_demo_abap=>meth1(
      EXPORTING
        i_str = `ABAP`
      IMPORTING
        e_dec = DATA(a)
        e_tab = DATA(b)
      RECEIVING
        r_int = DATA(c)
    ).

    "Functional method call
    "The target data object of the returning parameter is specified on the left side of an assignment.
    "Note: In this case, you cannot specify inline declarations for the exporting parameters.
    DATA e TYPE decfloat34.
    DATA f TYPE string_table.
    DATA(g) = zcl_demo_abap=>meth1(
      EXPORTING
        i_str = `ABAP`
      IMPORTING
        "e_dec = DATA(h)
        "e_tab = DATA(i)
        e_dec = e
        e_tab = f
    ).

    "Benefits of returning parameters: They can, for example, be used in expressions
    "The following snippets show a selection (and ignore the available exporting
    "parameters).

    CASE zcl_demo_abap=>meth1( i_str = `ABAP` ).
      WHEN 0. ...
      WHEN 1. ...
      WHEN OTHERS. ...
    ENDCASE.

    IF zcl_demo_abap=>meth1( i_str = `ABAP` ) > 5.
      ...
    ELSE.
      ...
    ENDIF.

    "IF used with a predicative method call
    "The result of the relational expression is true if the result of the functional
    "method call is not initial and false if it is initial. The data type of the result
    "of the functional meth1od call, i. e. the return value of the called functional method,
    "is arbitrary. A check is made for the type-dependent initial value.
    IF zcl_demo_abap=>meth1( i_str = `ABAP` ).
      ...
    ELSE.
      ...
    ENDIF.

    DO zcl_demo_abap=>meth1( i_str = `ABAP` ) TIMES.
      ...
    ENDDO.

    "Method call result as actual parameter
    DATA(j) = zcl_demo_abap=>meth1( i_str = `ABAP` i_tab = zcl_demo_abap=>meth2( ) ).

    "Examples of returning parameters typed with a table type
    LOOP AT zcl_demo_abap=>meth2( ) INTO DATA(wa1).
      ...
    ENDLOOP.

    READ TABLE zcl_demo_abap=>meth2( ) INTO DATA(wa2) INDEX 1.

  ENDMETHOD.
  
  METHOD meth1.
    ... "Method implementation
  ENDMETHOD.

  METHOD meth2.
    ... "Method implementation
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

RETURN

• RETURN statements immediately terminate the current processing block. Usually, the statement is intended for leaving processing blocks early.

• To exit procedures such as methods explicitly, it is recommended to use RETURN. EXIT and CHECK statements might also be used for exiting procedures. However, their use inside loops is recommended. According to the guidelines (F1 docu for standard ABAP), RETURN is the recommendation.

• In case of functional methods, i.e. methods that have one returning parameter, the RETURN statement can also be specified with an expression. In doing so, the following statement

  res = some_expr.
  RETURN.
  

  can also be specified as follows:

  RETURN some_expr.
  

In the following examples, the expression result is passed to the returning parameter without naming it explicitly. As an expression, you can specify a constructor expression (and using type inference with # means using the type of the returning parameter).

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.
  PUBLIC SECTION.
    INTERFACES: if_oo_adt_classrun.
  PROTECTED SECTION.
  PRIVATE SECTION.
    CLASS-METHODS multiply
      IMPORTING num1          TYPE i
                num2          TYPE i
      RETURNING VALUE(result) TYPE i.
ENDCLASS.
CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    DATA(res1) = multiply( num1 = 2 num2 = 3 ).
    DATA(res2) = multiply( num1 = 10 num2 = 10 ).
    DATA(res3) = multiply( num1 = 99999999 num2 = 99999999 ).
    out->write( res1 ). "6
    out->write( res2 ). "100
    out->write( res3 ). "0
  ENDMETHOD.
  METHOD multiply.
    TRY.        
        "result = num1 * num2.
        RETURN num1 * num2.
      CATCH cx_sy_arithmetic_error.
        "The following statement is actually not needed in the example, but used nevertheless
        "to showcase the specification of a constructor expression after RETURN.
        RETURN VALUE #( ).
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
  PROTECTED SECTION.
  PRIVATE SECTION.
    METHODS add IMPORTING num1          TYPE i
                          num2          TYPE i
                RETURNING VALUE(result) TYPE i.

    METHODS subtract IMPORTING num1          TYPE i
                               num2          TYPE i
                     RETURNING VALUE(result) TYPE i.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    DATA(result_add) = add( num1 = 10 num2 = 20 ).
    out->write( result_add ).

    DATA(result_subtract) = subtract( num1 = 10 num2 = 20 ).
    out->write( result_subtract ).
  ENDMETHOD.

  METHOD add.
    result = num1 + num2.
  ENDMETHOD.

  METHOD subtract.
    RETURN num1 - num2.
  ENDMETHOD.
ENDCLASS.

⬆️ back to top

Self-Reference me

When implementing instance methods, you can optionally make use of the implicitly available object reference variable me which is always available at runtime and points to the respective object itself. You can use it, for example, to refer to components of the instance of a particular class:

... some_method( ... ) ...

... me->some_method( ... ) ...

You can also address the entire object, which is illustrated in the example of section Method Chaining and Chained Attribute Access. The following code snippet declares a local data object in a method. It has the same name as a data object declared in the private visibility section. me is used to access the non-local data object.

CLASS zcl_demo_abap DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
  PROTECTED SECTION.
  PRIVATE SECTION.
    DATA str TYPE string.
    METHODS meth RETURNING VALUE(text) TYPE string.
    METHODS pass_me_ref RETURNING VALUE(oref) TYPE REF TO zcl_demo_abap.
ENDCLASS.

CLASS zcl_demo_abap IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    str = `AP`.
    DATA(text) = meth( ).
    out->write( text ). "ABAP

    str = `Hello`.
    DATA(oref) = pass_me_ref( ).
    out->write( oref->str ).

    str = `World`.
    oref = pass_me_ref( ).
    out->write( oref->str ).

  ENDMETHOD.

  METHOD meth.

    "Declaring a local data object having the same
    "name as a data object declared in a visibility section
    DATA str TYPE string VALUE `AB`.

    "Addressing locally declared data object
    DATA(local_string) = str.

    "Addressing data object declared in private visibility section
    DATA(other_string) = me->str.

    text = local_string && other_string.

  ENDMETHOD.

  METHOD pass_me_ref.
    "Adressing the object using the self-reference me
    oref = me.
  ENDMETHOD.

ENDCLASS.

⬆️ back to top

Method Chaining and Chained Attribute Access

• As shown in a previous example, method chaining is possible for functional method calls (i.e. methods that have exactly one return value declared with RETURNING) at appropriate read positions.
• In this method design, the return values are reference variables that point to objects with the next method in question. The methods in the example class below assign the objects to the returning parameter using the self-reference me.
• The method's return value is then used as an ABAP operand.
• A chained method call can consist of multiple functional methods that are linked using component selectors ->.
• Class attributes can also be added to the chain.
• In the context of method chaining, constructor expressions (e.g. with NEW) come in handy. The example class below shows functional method calls (i.e. the return value of the method is used as an ABAP operand), and a standalone statement.

The following example illustrates method chaining. Find a self-contained example class further down.

"The following class creates random integers. Find more information in the
"class documentation.
"Both methods have returning parameters specified.
DATA(some_int1) = cl_abap_random_int=>create( seed = cl_abap_random=>seed( )
                                              min  = 1
                                              max  = 10 )->get_next( ).

"Getting to the result as above - not using method chaining and inline declarations.
DATA some_int2 TYPE i.
DATA dref TYPE REF TO cl_abap_random_int.

dref = cl_abap_random_int=>create( seed = cl_abap_random=>seed( )
                                   min  = 1
                                   max  = 10 ).

some_int2 = dref->get_next( ).

"Using the RECEIVING parameter in a standalone method call
DATA some_int3 TYPE i.
dref->get_next( RECEIVING value = some_int3 ).

"IF statement that uses the return value in a read position
IF cl_abap_random_int=>create( seed = cl_abap_random=>seed( )
                               min  = 1
                               max  = 10 )->get_next( ) < 5.
  ... "The random number is lower than 5.
ELSE.
  ... "The random number is equal or greater than 5.
ENDIF.

"Examples using classes of the XCO library (see more information in the
"ABAP for Cloud Development and Released ABAP Classes cheat sheets), in which
"multiple chained method calls can be specified. Each of the methods
"has a returning parameter specified.

"In the following example, 1 hour is added to the current time.
DATA(add1hour) = xco_cp=>sy->time( xco_cp_time=>time_zone->user )->add( iv_hour = 1 )->as( xco_cp_time=>format->iso_8601_extended )->value.

"In the following example, a string is converted to xstring using a codepage
DATA(xstr) = xco_cp=>string( `Some string` )->as_xstring( xco_cp_character=>code_page->utf_8 )->value.

"In the following example, JSON data is created. First, a JSON data builder
"is created. Then, using different methods, JSON data is added. Finally,
"the JSON data is turned to a string.
DATA(json) = xco_cp_json=>data->builder( )->begin_object(
  )->add_member( 'CarrierId' )->add_string( 'DL'
  )->add_member( 'ConnectionId' )->add_string( '1984'
  )->add_member( 'CityFrom' )->add_string( 'San Francisco'
  )->add_member( 'CityTo' )->add_string( 'New York'
  )->end_object( )->get_data( )->to_string( ).