How to Implement a Persistence Class

Step 1: Prepare a Database Table

• Example: Table ZEMPLOYEES with fields EMPID, ENAME, DEPT.
• Make sure it has a primary key (mandatory).

Step 2: Create a Persistence Object

• Go to transaction SE24.
• Create a new class → select Persistent Class type.
• Enter database table name (e.g., ZEMPLOYEES).
• Save and activate.

SAP will automatically generate:

• Persistence Class (ZCL_EMPLOYEES)
• Agent Class (ZCA_EMPLOYEES)

Step 3: Use in ABAP Program

DATA: lo_employee TYPE REF TO zcl_employees,
lo_agent TYPE REF TO zca_employees.

” Get the agent class
lo_agent = zca_employees=>agent.

” Create new employee object
CREATE OBJECT lo_employee.

” Set values
lo_employee->set_empid( ‘1001’ ).
lo_employee->set_ename( ‘John Doe’ ).
lo_employee->set_dept( ‘IT’ ).

” Save to DB
lo_employee->update( ).

” Fetch existing employee by key
lo_employee = lo_agent->get_persistent( ‘1001’ ).
WRITE: / ‘Employee:’, lo_employee->get_ename( ).

Advantages of Persistence Classes

• Encapsulation – No need to expose SQL, use methods instead.
• Consistency – Follows object-oriented principles.
• Reusability – Same persistence class can be reused across programs.
• Error Handling – Provided by framework methods (INSERT, UPDATE, DELETE).

• Defined with CLASS ... DEFINITION ABSTRACT.
• Can have:
  • Attributes (data)
  • Concrete methods (implemented)
  • Abstract methods (declared but not implemented — must be redefined in subclass)
• Cannot be instantiated directly — only subclasses can be created.
• Supports inheritance (a subclass inherits implementation + attributes).
• Can implement interfaces too.

Think of an abstract class as a partially implemented blueprint.

Example :

CLASS cl_vehicle DEFINITION ABSTRACT.
PUBLIC SECTION.
METHODS: start ABSTRACT, ” must be implemented in subclass
stop. ” already implemented
ENDCLASS.

CLASS cl_vehicle IMPLEMENTATION.
METHOD stop.
WRITE: / ‘Vehicle stopped.’.
ENDMETHOD.
ENDCLASS.

Interface

• Defined with INTERFACE ....
• Can contain:
• Method declarations only (no implementation).
• Constants, types, attributes (but no data storage).
• No concrete code inside (implementation happens in the class that implements it).
• A class can implement multiple interfaces (like multiple inheritance).
• Cannot be instantiated or inherited — only implemented.

Think of an interface as a contract: “any class implementing me must provide these methods.”

Example:

INTERFACE if_flyable.
METHODS fly.
ENDINTERFACE.

INTERFACE if_swimmable.
METHODS swim.
ENDINTERFACE.

Key Differences:

When to Use

• Use an abstract class when:

  • You want to share implementation across subclasses.

  • You want to define default behavior that can be reused.

  • Example: CL_VEHICLE (base) → CL_CAR, CL_TRUCK.

• Use an interface when:

  • You just need a common contract across unrelated classes.

  • You want to achieve multiple inheritance of behavior.

  • Example: IF_FLYABLE, IF_SWIMMABLE, IF_SERIALIZABLE.

Example: 

” First interface
INTERFACE if_flyable.
METHODS: fly.
ENDINTERFACE.

” Second interface
INTERFACE if_swimmable.
METHODS: swim.
ENDINTERFACE.

” A class implementing multiple interfaces
CLASS cl_duck DEFINITION.
PUBLIC SECTION.
INTERFACES: if_flyable,
if_swimmable.
METHODS: display.
ENDCLASS.

CLASS cl_duck IMPLEMENTATION.
METHOD if_flyable~fly.
WRITE: / ‘The duck is flying.’.
ENDMETHOD.

METHOD if_swimmable~swim.
WRITE: / ‘The duck is swimming.’.
ENDMETHOD.

METHOD display.
WRITE: / ‘I am a duck with multiple abilities!’.
ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
DATA(duck) = NEW cl_duck( ).

duck->display( ).
duck->if_flyable~fly( ).
duck->if_swimmable~swim( ).

Output:

I am a duck with multiple abilities!
The duck is flying.
The duck is swimming.

Key Points:

• CLASS … DEFINITION uses INTERFACES: to include multiple interfaces.

• Methods from interfaces must be implemented in the class.

• When calling interface methods, you can:

  • Use fully qualified names: object->if_interface~method( )

  • Or, if redefined explicitly as public methods, call them directly.

• This is the standard way to achieve “multiple inheritance” in ABAP.

CLASS main_class DEFINITION.
PUBLIC SECTION.
METHODS: display.
PRIVATE SECTION.
DATA: secret TYPE string VALUE ‘Top Secret’.
FRIENDS friend_class. ” grant access
ENDCLASS.

CLASS main_class IMPLEMENTATION.
METHOD display.
WRITE: / ‘Main class display:’, secret.
ENDMETHOD.
ENDCLASS.

CLASS friend_class DEFINITION.
PUBLIC SECTION.
METHODS: reveal IMPORTING obj TYPE REF TO main_class.
ENDCLASS.

CLASS friend_class IMPLEMENTATION.
METHOD reveal.
” Directly access the private attribute of main_class
WRITE: / ‘Friend class can access:’, obj->secret.
ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
DATA(main) = NEW main_class( ).
DATA(frd) = NEW friend_class( ).

main->display( ).
frd->reveal( main ).

Output: 

Main class display: Top Secret
Friend class can access: Top Secret