You have written a lot of code in Chapters 3–7. Loops, internal tables, SELECT statements, ALVs. But look at your programs — they are probably 200+ lines of code all sitting in one block.

That works for small exercises. It fails in real projects. When a program is 2,000 lines long, finding bugs takes hours. Reusing logic in another program means copy-paste. Testing one piece means testing everything.

This chapter fixes that. You will learn ABAP modularization — the art of breaking code into small, reusable, testable pieces. There are three main tools: FORMs, Function Modules, and Classes.

🎯 What You Will Learn in This Chapter

• Why modularization matters in real ABAP projects
• How to use FORM / PERFORM subroutines with USING and CHANGING parameters
• How to create and call Function Modules in SE37 and Function Groups
• How to write Object-Oriented ABAP classes with methods, attributes, and constructors
• The difference between static and instance methods
• When to use each approach — and which one modern ABAP prefers

📘 Why Modularization Matters

Imagine a real SAP project: 500+ custom programs, 200 function modules, and 50 team members touching the same codebase. Without modularization, this becomes chaos.

🧩 Method 1: Subroutines (FORM / PERFORM)

A FORM is a local subroutine that lives inside a single ABAP program. You define it once and call it with PERFORM. It cannot be called from other programs — that is its limitation and its simplicity .

Basic syntax

FORM greet_user USING iv_name TYPE string.
  WRITE: / 'Hello,', iv_name.
ENDFORM.

START-OF-SELECTION.
  PERFORM greet_user USING 'Rohit'.

Parameter types

Example with USING and CHANGING

FORM calculate_tax
  USING    iv_amount TYPE p
  CHANGING cv_tax    TYPE p.

  cv_tax = iv_amount * '0.18'.
ENDFORM.

DATA: lv_amount TYPE p DECIMALS 2 VALUE '1000.00',
      lv_tax    TYPE p DECIMALS 2.

PERFORM calculate_tax USING lv_amount CHANGING lv_tax.
WRITE: / 'Tax:', lv_tax.

📦 Method 2: Function Modules

A Function Module is a global, reusable unit stored in a Function Group. Unlike FORMs, Function Modules can be called from any ABAP program, support RFC (remote calls), and have a formal parameter interface with typing and exceptions .

Key concepts

• Function Group: A container created in SE80 that holds related Function Modules and shares global data
• Function Module: Created in SE37, has a name, a parameter interface, and source code
• Parameters: IMPORTING, EXPORTING, CHANGING, TABLES (deprecated)
• Exceptions: Can raise errors that the caller handles
• RFC: Can be flagged as Remote-Enabled for external system calls

Creating a Function Module — Steps

FUNCTION z_calculate_tax.
  ev_tax = iv_amount * '0.18'.
ENDFUNCTION.

DATA: lv_amount TYPE p DECIMALS 2 VALUE '1000.00',
      lv_tax    TYPE p DECIMALS 2.

CALL FUNCTION 'Z_CALCULATE_TAX'
  EXPORTING
    iv_amount = lv_amount
  IMPORTING
    ev_tax    = lv_tax.

WRITE: / 'Tax:', lv_tax.

🏛️ Method 3: Object-Oriented ABAP (Classes)

Classes are the modern standard for ABAP development. They are the only modularization technique allowed in ABAP Cloud, and they are what RAP and CDS development rely on .

The two parts of a class

Attributes and Methods

• Attributes: Variables that belong to the class (static or instance)
• Methods: Functions that belong to the class (static or instance)
• Static: Belongs to the class itself. Called directly with class_name=>method_name( )
• Instance: Belongs to a specific object created with CREATE OBJECT

Complete example — a Tax Calculator class

CLASS zcl_tax_calculator DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      constructor IMPORTING iv_rate TYPE p,
      calculate   IMPORTING iv_amount TYPE p
                  RETURNING VALUE(rv_tax) TYPE p.

  PRIVATE SECTION.
    DATA mv_rate TYPE p.
ENDCLASS.

CLASS zcl_tax_calculator IMPLEMENTATION.
  METHOD constructor.
    mv_rate = iv_rate.
  ENDMETHOD.

  METHOD calculate.
    rv_tax = iv_amount * mv_rate.
  ENDMETHOD.
ENDCLASS.

" Using the class
DATA: lo_calc TYPE REF TO zcl_tax_calculator,
      lv_tax  TYPE p DECIMALS 2.

CREATE OBJECT lo_calc EXPORTING iv_rate = '0.18'.
lv_tax = lo_calc->calculate( iv_amount = '1000.00' ).
WRITE: / 'Tax:', lv_tax.

Static vs Instance — quick comparison

🔧 Constructors — Automatic Setup

A constructor is a special method that runs automatically. ABAP has two:

Constructors have no return value and are called automatically — you never call them yourself.

When to use each

• constructor — to set up instance attributes when an object is created
• class_constructor — to load static data (buffers, config) once for the whole class

⚖️ Forms vs Function Modules vs Classes

📝 Chapter Summary

• Modularization breaks large programs into small, reusable, testable units.
• FORM/PERFORM — local subroutines, using USING and CHANGING parameters. Legacy but common.
• Function Modules — global units in a Function Group, created in SE37, support RFC. Used for integration.
• Classes — the modern standard. Support encapsulation, inheritance, polymorphism.
• Static methods belong to the class; instance methods need CREATE OBJECT.
• Constructors run automatically — constructor on instantiation, class_constructor once when the class is first used.
• Write new code as classes. Read old code for FORMs and Function Modules.