Mastering the ABAP NEW Operator: A Deep Dive with Code Examples

From `CREATE OBJECT` to `NEW`: Modernizing Your ABAP Code

For years, ABAP developers have relied on the trusty CREATE OBJECT statement to bring their classes to life. It's reliable, it's familiar, but with the evolution of ABAP towards a more modern, expressive syntax (starting with ABAP 7.40), a new and more powerful constructor operator has taken center stage: the NEW operator.

If you're looking to write cleaner, more concise, and more readable code, understanding and adopting the NEW operator is a crucial step. Let's dive deep into what it is, how it works, and why you should be using it.

The Old Way: CREATE OBJECT

Let's first look at the traditional way of instantiating an object. This typically involves two distinct steps: declaring the reference variable and then creating the object instance.

*&---------------------------------------------------------------------* *& 1. Declare a reference variable for the class *&---------------------------------------------------------------------* DATA: lo_vehicle TYPE REF TO zcl_vehicle. *&---------------------------------------------------------------------* *& 2. Instantiate the object using CREATE OBJECT *&---------------------------------------------------------------------* CREATE OBJECT lo_vehicle.

The Modern Way: The NEW Operator

The NEW operator streamlines this process significantly. It allows you to create an object instance and assign it to a reference variable in a single, fluid statement. The most powerful feature is its ability to be used with an inline declaration (DATA(...)), which infers the data type automatically.

*&---------------------------------------------------------------------* *& Create an object in a single line with inline declaration *&---------------------------------------------------------------------* DATA(lo_vehicle) = NEW zcl_vehicle( ).

Notice how two lines (and sometimes more) are condensed into a single, easy-to-read line. This is the core advantage of the NEW operator.

In-Depth Usage and Examples

The NEW operator is more than just a shortcut. It enables several powerful programming patterns.

1. Passing Parameters to the Constructor

With CREATE OBJECT, you passed parameters to the constructor using the EXPORTING addition. With NEW, it feels much more like calling a regular method, making the code more intuitive.

Imagine our ZCL_VEHICLE class has a constructor that accepts the number of wheels.

*&-- Traditional Method with CREATE OBJECT DATA: lo_car TYPE REF TO zcl_vehicle. CREATE OBJECT lo_car EXPORTING iv_wheels = 4. *&-- Modern Method with NEW DATA(lo_motorcycle) = NEW zcl_vehicle( iv_wheels = 2 ).

2. Inline Instantiation in Method Calls

You can create a new object instance directly within a method's parameter list. This is extremely useful for passing newly created objects to other methods without needing an intermediate variable.

*& Assume a method 'REGISTER_VEHICLE' in a 'ZCL_REGISTRY' class DATA(lo_registry) = NEW zcl_registry( ). *& Pass a brand new object directly into the method call lo_registry->register_vehicle( NEW zcl_vehicle( iv_wheels = 18 ) " A new truck object ).

3. Method Chaining

One of the most elegant features enabled by NEW is method chaining. You can instantiate an object and immediately call one of its methods in the same statement. The result of the method call can then be assigned to a variable.

Let's say our ZCL_VEHICLE class has a method GET_DESCRIPTION( ) that returns a string.

*& Create a new object, call a method on it, and store the result DATA(lv_description) = NEW zcl_vehicle( iv_wheels = 4 )->get_description( ). *& lv_description now holds the string returned by the method WRITE: / lv_description.

4. Creating Tables of Objects

The NEW operator can also be used with the VALUE operator to construct internal tables of objects in a very clean way.

*& Define a table type for our vehicle objects TYPES: tt_vehicles TYPE TABLE OF REF TO zcl_vehicle. *& Fill the internal table using VALUE and NEW DATA(lt_fleet) = VALUE tt_vehicles( ( NEW zcl_vehicle( iv_wheels = 2 ) ) ( NEW zcl_vehicle( iv_wheels = 4 ) ) ( NEW zcl_vehicle( iv_wheels = 4 ) ) ( NEW zcl_vehicle( iv_wheels = 18 ) ) ).

Conclusion: Why You Should Make the Switch

Adopting the NEW operator is a clear win for any ABAP developer working on a modern SAP system. The benefits are undeniable:

• Conciseness: It drastically reduces the number of lines needed to instantiate objects.
• Readability: The syntax is more intuitive and aligns with modern object-oriented languages.
• Power: It enables powerful patterns like method chaining and streamlined table construction.
• Efficiency: Combined with inline declarations (DATA()), it lets the compiler do the work of type inference, leading to faster development.

While CREATE OBJECT still works and isn't going away, the NEW operator is the modern, preferred, and superior way to create objects in ABAP. Make it a part of your daily coding practice to write cleaner, more effective, and more maintainable programs.