Wood J. Object-Oriented Programming with ABAP Objects

Подождите немного. Документ загружается.

2 | Working with Objects

Figure 2.2 Reassigning Object References - Part 1

If. for example, you assign the value of Ref_2 to Ref_l (see Figure 2.3), then both

reference variables will contain an address that points to the same object instance

(i.e., 0bject_2). In this case, if there are no other object reference variables point-

ing to Object_l, the object will be orphaned. In Chapter 4, Object Initialization

and Cleanup, you will see how the ABAP runtime environment automatically

cleans up these orphaned objects using a process known

garbage collection.

Figure 2.3 Reassigning Object References - Part 2

2.2.4 Working with Instance Components

To interact with an object instance in an ABAP program, you must use an object

reference variable that points to that object instance because direct access to the

object is strictly forbidden. One way to think about the relationship between an

object reference variable and the object instance it refers to is to consider the con-

nection between a remote control and a TV. Here, the remote control provides an

interface that can be used to communicate with the TV (e.g.. by pressing buttons).

Creating and Using Objects | 2.2

Similarly, you can use an object reference variable to access instance components.

This is achieved through the use of the object component selector operator. The

object component selector (->) allows you to access the instance components of

an object.

To demonstrate how to work with the object component selector, let's consider

an example of

Point object in a Cartesian coordinate system. Ifyou've slept since

your last high school geometiy class, a Cartesian coordinate system (or plane) is a

two-dimensional grid that contains a horizontal x-axis and vertical y-axis (see Fig-

ure 2.4). You can plot points on a graph by specifying an x-coordinate and a y-

coordinate, for example, point (1,2) in the graph of Figure 2.4.

HII

-3 -2 -1

(U)

I I »

1 2 3

Figure 2.4 The Cartesian Coordinate System

The code in Listing 2.14 defines a class called 1cl_polnt that represents a single

point in a Cartesian coordinate system. The instance method get_di stance is

used to calculate the Euclidean distance between two points in the Cartesian

plane. Because get_distance is an instance method, it must be accessed using an

object reference variable. The object pointed to by this object reference variable

implicitly becomes the first point; the second point is provided via the importing

reference parameter im_point2.

CLASS lcl_point DEFINITION.

PUBLIC SECTION.

DATA: x TYPE i.

y TYPE i.

"X-Coordinate

"YCoordinate

METHODS get_distance IMPORTING im_point2

TYPE REF TO lcl.point

2 | Working with Objects

EXPORTING ex_distance

TYPE f.

ENDCLASS.

CLASS ld_p0int IMPLEMENTATION.

METHOD get_distance.

* Method-Local Data Declarations:

DATA: 1v_dx TYPE 1. "Oiff. X

1v_dy TYPE 1. "Diff. Y

* Calculate the Euclidean distance between the points:

lv_dx - im_point2->x - me->x.

lv_dy - im_point2>y - me >y.

ex_distance -

SQRT( ( 1v_dx * lv_dx ) + ( lv_dy * lv_dy ) ).

ENDMETHOD.

ENDCLASS.

Listing 2.14 Using the Object Component Selector - Part 1

To perform the calculation, the x- andy-coordinates for both points must be eval-

uated. To clarify the use of the attributes associated with the implicit first point,

the self-reference variable

was used. Each object instance implicitly contains an

object reference attribute called me. The

reference variable contains a reference

to the object in which it is enclosed. The use of the self-reference variable is

optional for accessing attributes within a method; the system will quietly insert it

behind the scenes when omitted. The self-reference variable is primarily used for

emphasis but is also occasionally used to pass a reference of the current object to

another method, and so on.

The code snippet in Listing 2.15 shows how the object component selector is

used to access public attributes (e.g., x and y) and public methods of class

lcl_point using object reference variables. In this example, two object reference

variables (lr_point_a and lr_point_b, respectively) are instantiated, assigning

their x- andy-coordinates, and calculating the distance between the points. Meth-

ods are typically invoked in ABAP using the CALL METHOD statement, as evidenced

by the call that you see to method get_d1 stance.

* Local Data Declarations:

DATA: 1r_point_a TYPE REF TO lcl_point.

1r_point_a TYPE REF TO lcl.point.

Creating and Using Objects 2.2

lv_distance TYPE f.

* Instantiate both of the points:

CREATE 08JECT lr_point_a.

lr_point_a->x - 1.

lr_point_a->y - 1.

CREATE OBJECT lr_point_b.

lr_point_b->x - 3.

1r_point_b->y - 3.

* Calculate the distance and display the results:

CALL HETHOO 1r_point_a->get_distance

EXPORTING

im_point2 - lr_point_b

IMPORTING

ex_distance - lv_distance.

WRITE: "Distance between point a and point b Is:

lv_distance.

Listing 2.15 Using the Object Component Selector - Part 2

2.2.5 Working with Class Components

During the analysis process, you will sometimes stumble across attributes and

behaviors that are only associated with a class and not necessarily any particular

instance of that class. Such components should be defined as class components. To

demonstrate the use of class components, the lcl_point class has been revised

from Listing 2.14 to make use of some class components (see Listing 2.16).

CLASS lcl.point DEFINITION.

PUBLIC SECTION.

CONSTANTS: CO_QUADRANT_l TYPE i VALUE 1.

C0_QUADRANT_2 TYPE i VALUE 2.

CO_QUADRANT_3 TYPE i VALUE 3.

C0_QUADRANT_4 TYPE i VALUE 4.

CLASS-DATA: next_point_no TYPE i. "Next Point Number

DATA: point_no TYPE i. "Point Number

x TYPE i. "XCoordinate

2 | Working with Objects

y TYPE i. "Y-Coordinate

METHODS:

constructor.

get_point_number RETURNING value(re_number)

TYPE i.

get_quadrant RETURNING value(re_quadrant)

TYPE i.

CLASS METHODS:

get_distance IMPORTING im_pointl

TYPE REF TO lcl.point

im_point2

TYPE REF TO lcl.point

RETURNING value(re_distance)

TYPE f.

ENDCLASS.

CLASS 1C1_point IMPLEMENTATION.

METHOD constructor.

next_point_no - next_point_no + 1.

point_no - next_point_no.

ENDMETHOD.

METHOD get_point_number.

re_number - point_no.

ENDMETHOD.

METHOD get_quadrant.

IF x > 0.

IF y > 0.

re_quadrant - CO_QUADRANT_l.

ELSE.

re_quadrant - CO_QUADRANT_4.

ENDIF.

ELSE.

IF y > 0.

re_quadrant - CO_OUADRANT_2.

ELSE.

re_quadrant - CO_QUADRANT_3.

ENDIF.

Creating and Using Objects | 2.2

ENDMETHOD.

HETHOO get.distance.

* Method-Local Data Declarations:

OATA: 1v_dx TYPE i. "Diff. X

1v_dy TYPE i. "Diff. Y

* Calculate the distance between the two points:

lv_dx - im_point2->x - im_pointl->x.

lv_dy - 1m_point2->y - im_pointl->y.

re_distance -

SQRT( ( 1v_dx * 1v_dx ) + ( lv_dy * lv_dy ) ).

ENDMETHOD.

ENOCLASS.

Listing 2.16 Revising Class IcLpoint to Use Class Components

As you can see in Listing 2.16, class lcl.point has been enhanced to include sev-

eral different kinds of class components. The attribute next_point_no is a class

attribute that is used to keep track of the next available point number that can be

assigned to a point when it is created. To exploit this functionality, a special

method called constructor has been defined. This method is called automatically

by the ABAP runtime environment whenever an object of

class

lcl_point is cre-

ated (see Chapter 4, Object Initialization and Cleanup, for more details). Inside

the constructor method, the next available point number (i.e., next_point_no) is

incremented, and the value is assigned to the instance attribute point_no. The

value of the assigned point number can be retrieved using the get_point_number

method.

In this implementation of

class

icl_point, a new instance method has also been

created called get_quadrant to return the current quadrant location for the point.

Inside method get_quadrant, the public constant attributes CO_QUADRANT_x are

used to specify the quadrant values rather than using hard-coded literal values.

Within the bounds of class lcl_point, the use of the class attributes do not have

to be qualified. However, outside of class lcl_point, these public constant

attributes must be accessed using the class component selector (-» operator.

For example, to access the constant value for Quadrant 1 in the coordinate plane,

you could use the following expression: lcl_point->CO_QUAORANT_l. The class

component selector can be used to access any type of

class

component, including

2 | Working with Objects

methods, types, and so on. It is possible to use the class component selector in

conjunction with an object reference variable (i.e., oref->c1ass_component).

However, this syntax can become confusing as you will see later in the book.

Therefore, this book sticks to the convention of binding the class component

selector to the class name. This convention emphasizes the fact that the compo-

nents are related to the class itself rather than a particular instance of the class.

If you look closely at class lcl_point, you will notice that the method

get_di stance has been redefined as a class method. Because get_distance is no

longer invoked on a particular instance of class lcl_point, the method signature

had to be changed to provide importing parameters for both points. Here, keep in

mind that class methods cannot implicitly access instance attributes or instance

methods within the class because there is no me self-reference associated with the

static context of the class. Rather, class methods can only access instance

attributes through object reference variables created locally or passed in as input

parameters. Class methods can, of course, access other class methods and

attributes without any such restrictions.

The example code shown in Listing 2.17 illustrates some of the updated features

of class lcl_point. First, four object instances have been created: lr_po1nt_a,

lr_point_b,

r_point_c, and

r_point_d. Each time an object is created, the con-

structor method is invoked, and a unique point number is assigned using the

class attribute next_point_no. This functionality is evidenced by the call to

method get_po1nt_number for the point referenced by

r_po1nt_c, which should

produce the expected value 3. Similarly, the call to method get_quadrant should

determine that the point referenced by

r_point_c is located in Quadrant 3 based

on the assigned x- and y-coordinate values. Finally, the call to class method

get_distance calculates the distance between the points referenced by

lr_point_c and

r_point_d. Here, notice the use of the class component selector

in the lcl_point->get_di stance method call.

OATA: 1r_point_a TYPE REF TO lcl_point.

1r_point_b TYPE REF TO lcl_point,

1r_point_C TYPE REF TO lcl_point.

1r_point_d TYPE REF TO lcl.point.

1v_point_number TYPE numcl.

lv_quadrant TYPE numcl.

lv_distance TYPE f.

Creating and Using Objects | 2.2

* Create some sample point objects:

CREATE OBJECT lr_point_a.

lr_point_a->x - 2.

lr_point_a->y - 3.

CREATE OBJECT lr_point_b.

1r_point_b->x - 2.

lr_point_b->y " -1.

CREATE OBJECT lr_point_c.

1r_point_c->x - -3.

lr_point_c->y - -4.

CREATE OBJECT lr_point_d.

1r_point_d->x - -5.

lr_point_d->y - 1.

* Determine the point number & quadrant of point C:

1v_point_number - 1r_point_c->get_point_number( ).

lv_quadrant - 1r_point_c->get_quadrant( ).

WRITE: / 'Point C has Point if'.

v_point_number.

'and resides in quadrant'. 1v_quadrant.

* Calculate the distance between points C and 0:

lv_distance -

lcl_point->get_distance( im_pointl - lr_point_c

1m_point2 - lr_point_d ).

WRITE: / "Distance between point C and point D is:

lv_distance.

Listing 2.17 Working with Class Components

2.2.6 Creating Complex Expressions Using Functional Methods

The use of the CALL METHOD statement is optional for functional methods. This

relaxed syntax supports the use of functional methods as operands in an expres-

sion. When used in an expression, functional methods are invoked, and the value

of the RETURNING parameter is substituted into the expression before it is evalu-

ated.

To demonstrate how this works in code, a simple class called lcl_material has

been created in Listing 2.18 that is used to represent a material that might be pro-

duced by a given manufacturer. For the purposes of this basic example, only two

2 | Working with Objects

attributes are defined that store the material's ID number and a flag that indicates

whether or not the material can be dangerous to handle. These instance attributes

are called material_number and hazardous_ind, respectively. The instance

method is_hazardous is a boolean method that returns the value of the

hazardous_i nd flag in the returning value parameter re_resul t. Boolean methods

return a value of either true or false and should normally be named according to

the convention IS_<adjective>.

CLASS lcl_material DEFINITION.

PUBLIC SECTION.

TYPE-POOLS: abap.

DATA: material_number TYPE string.

hazardous_ind TYPE abap_bool.

METHODS: is_hazardous RETURNING VALUE(re_result)

TYPE abap_bool.

ENDCLASS.

CLASS lcljnaterial IMPLEMENTATION.

METHOD is_hazardous.

re_result - hazardous_1nd.

ENDMETHOD.

ENDCLASS.

Listing 2.18 Defining a Functional Method for a Material Class

The sample test code in Listing 2.19 creates an object of type lcl_material and

assigns a reference to that object in object reference variable Immaterial. After

the material object is created, some test values arc assigned to the instance

attributes material_number and hazardous_ind. In the IF statement, the

is_hazardous method is called to determine whether or not the material should

be handled with care. The results of this method call are returned before the logi-

cal expression is evaluated. Thus, in the example, the logical expression evaluates

to true because the hazardous.ind attribute was initialized to true right before

the is_hazardous method was called. As you would expect, this causes the pro-

gram flow to branch to the IF processing block of the IF statement.

DATA: Immaterial TYPE REF TO lcl.material.

CREATE OBJECT Immaterial.

Immaterial->material_number - '1234567890'.

1mmaterial->hazardous_ind - abap_true.

Creating and Using Objects | 2.2

IF Immaterial->is_hazardous( ) EO abap_true.

WRITE: / 'Material'. Immaterial->material_number.

'should be handled with caution!'.

ELSE.

WRITE: / 'Material'. 1r_material->material_number.

'can be handled normally.'.

ENOIF.

Listing 2.19 Using Functional Methods in Expressions

In the case of method is_hazardous from Listing 2.19, no parameters were

passed in because there were no importing parameters defined. Of course, if a

functional method does define importing parameters, these parameters must be

provided in the method call. However, the syntax rules for passing these param-

eters are somewhat flexible. For example, if the functional method only provides

a single importing parameter, you can simply provide the importing parameter

using the syntax shown in Listing 2.20.

method_name( actual_parameter ).

Listing 2.20 Functional Method Calls with One Parameter

Similarly, if there is more than one importing parameter defined for a functional

method, you can pass the parameters using the form shown in Listing 2.21.

method_name( pi - fl ... pn - fn).

Listing 2.21 Functional Method Calls with Multiple Parameters

Obviously, the implementation of the isjiazardous method in Listing 2.19 is

extremely contrived. Nevertheless, even a simple example such as this demon-

strates the potential power in being able to wrap the result of a complex calcula-

tion neatly into an ABAP expression. Table 2.2 shows other places where you can

use functional methods in ABAP expressions.

ABAP Expression Where Used

MOVE In the source field of the expression.

Example:

MOVE oref >meth( ) TO...

Table 2.2 Using Functional Methods in Expressions