SE24 — SE24 Class Builder for ABAP OO Development
SE24 is the Class Builder, used to create and maintain global ABAP OO classes and interfaces: their attributes, methods, events, and inheritance relationships. It generates and stores method source code in system-managed includes rather than in a single flat program, which is the main source of confusion when developers try to edit or transport classes without understanding that structure.
This page covers SE24, the transaction for building and maintaining global ABAP classes and interfaces. It focuses on how the tool splits a class across metadata tables and generated code includes, and on the diagnostic checks needed when a class behaves differently than expected between environments or after transport.
Reviewed by an ERPClimb SAP consultant on 15 Sept 2026· 1,100 words
Purpose
SE24 is the Class Builder. It lets a developer define global classes and interfaces: their attributes, methods, events, parameters, exceptions, and their inheritance or interface relationships. Unlike a report or function module, a class built here is not one flat block of code. The definition (attributes, method signatures, visibility sections) is stored as metadata, and each method's implementation is stored separately as generated source. This split is the structural fact behind most confusion: editing a class 'directly' outside the tool, or expecting a single object to move as one unit in a transport without its components, leads to inconsistent or incomplete objects. SE24 and SE80's class editor operate on the same underlying objects, so a class started in one can be finished in the other without conflict.
When it is used
SE24 is reached for whenever custom development needs object-oriented ABAP: implementing a BAdI's interface, writing a helper class for a Fiori OData service, building a reusable utility class, or implementing an enhancement spot. It sits squarely in the technical development layer, not in any business process directly. A consultant chooses SE24 over SE38 or SE80's program editor specifically when the requirement is class-based rather than procedural, for example when SAP's own framework expects an interface implementation (a BAdI, an exit class, a persistence class). There is no Fiori app equivalent because this is a backend authoring tool, not an end-user transaction; on newer systems the same work increasingly happens in Eclipse-based ADT instead, but SE24 remains available and consistent with it.
How to use it in practice
- Enter a class name; if it does not exist, choose create and supply a description and category (usable type, exception class, etc.)
- Work through the tabs: Properties for superclass and interfaces, Attributes for instance/static data, Methods for signatures, Events for triggers
- Add interfaces on the Interfaces tab if the class must implement one; unimplemented methods appear automatically on the Methods tab
- Double-click a method to open its source code editor and write the implementation
- Check syntax, then activate the class; activation fails if an interface method is missing an implementation
- Test with the built-in class tester (F8) or a unit test class before releasing for transport
Key data objects
- SEOCLASS - class header: name, category, final/abstract flags, superclass
- SEOCOMPO - components of the class: methods, attributes, events, their visibility and type
- SEOSUBCO - parameters and exceptions belonging to each method
- SEOMETAREL - inheritance and interface implementation relationships between classes
- Generated method source (accessed through the include structure behind the class, not a plain program name) - the actual executable ABAP for each method
How to prove it in the data
In SE16, open SEOCLASS filtered on CLSNAME to confirm the class exists and check its version state (active versus inactive/modified). Then open SEOCOMPO filtered on the same class key (CLSKEY or equivalent link field) to list all methods and attributes and confirm a specific method is actually present as a component with the expected visibility. If a method seems to run old logic, compare the active version state here against what was last transported; a mismatch usually means the class was changed and never released, or released without activation on the target system.
ECC vs S/4HANA
SE24 itself is essentially unchanged on S/4HANA; the underlying class metadata and generated-code structure work the same way. What has shifted is tooling preference: ABAP development on S/4HANA, particularly for the ABAP RESTful programming model and cloud-ready extensions, is increasingly done in Eclipse-based ADT rather than the SAP GUI class editor, though both edit the same objects and either can be used interchangeably. There is no Fiori replacement, since this remains a backend developer tool.
Common pitfalls and how to diagnose them
- Version mismatch: a class edited and saved but not activated shows an inconsistent state; production behavior lags because the inactive version was never promoted. Check the class's active/inactive indicator before assuming the code is wrong.
- Local versus global class confusion: a class defined locally inside a report (via SE38) is not the same object as a global class in SE24 even with an identical name; developers sometimes debug the wrong one entirely.
- Incomplete interface implementation: activation fails or a method silently does nothing because the class claims to implement an interface but one or more interface methods were never coded; the Methods tab will still list them as inherited stubs.
- Incomplete transport: a class transported without all its generated components (a method added after the transport request was released) compiles on the source system but fails or behaves differently on the target; check the transport's object list against the current component list in SEOCOMPO.
- Direct edits to generated or framework classes: classes generated by BAdI enhancement implementations or proxy generation get overwritten on regeneration; changes made by hand in SE24 disappear without warning after the next regeneration run.
- Redefinition and inheritance surprises: a subclass redefines a method but the calling code still references the superclass's static type, so the expected override never executes; trace the actual runtime type before assuming the redefinition is broken.
Whose problem this is
This is squarely an ABAP developer's problem, not functional or Basis, unless the symptom is a transport failure crossing into Basis territory. A clean handover to development includes the class name, the specific method involved, the transport request number if relevant, and exact reproduction steps or the calling context (which BAdI, which program, which test case) that triggers the unexpected behavior.
Related SAP objects
Reviewed pages this object connects to in the ERPClimb knowledge graph.
Source: ERPClimb — https://erpclimb.com/sap-tcodes/se24ERPClimb is an independent platform and is not affiliated with SAP SE. Reference pages are written and reviewed by SAP consultants for learning and troubleshooting.