• 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.

What is BAPI?

• BAPI is a function module that is RFC-enabled (Remote Function Call).
• It enables integration of SAP with non-SAP systems, third-party software, or other SAP modules.
• Used in object-oriented programming in SAP: Each BAPI is associated with a Business Object Repository (BOR) object.

Typical Use Cases

• Create or update business objects (e.g., customer, material, sales order).
• Query data like inventory, employee details, etc.
• Interface SAP with mobile apps, web services, or middleware.

Advantages of BAPI

• Standardized and reusable
• Secure and consistent data handling
• Easier integration with external apps
• Promotes loosely-coupled architecture

Examples: Business Object: BUS2012
BAPI Used: BAPI_PO_CREATE