topic Re: abap object in Application Development and Automation Discussions

abap object

Former Member — Wed, 06 Feb 2008 09:34:49 GMT

I know some what knowledge about abap objects. I am little confuting on casting. Please guide me. Don’t send link because I can understand from that.

Re: abap object

Former Member — Wed, 06 Feb 2008 09:37:55 GMT

Hi,

Go to ABAPDOCU tcode and see example programs in abap objects section, you will find separate programs for upcasting and downcasting .

Up-Cast (Widening Cast)

Variables of the type reference to superclass can also refer to subclass instances at runtime.

If you assign a subclass reference to a superclass reference, this ensures that

all components that can be accessed syntactically after the cast assignment are

actually available in the instance. The subclass always contains at least the same

components as the superclass. After all, the name and the signature of redefined

methods are identical.

The user can therefore address the subclass instance in the same way as the

superclass instance. However, he/she is restricted to using only the inherited

components.

In this example, after the assignment, the methods GET_MAKE, GET_COUNT,

DISPLAY_ATTRIBUTES, SET_ATTRIBUTES and ESTIMATE_FUEL of the

instance LCL_TRUCK can only be accessed using the reference R_VEHICLE.

If there are any restrictions regarding visibility, they are left unchanged. It is not

possible to access the specific components from the class LCL_TRUCK of the

instance (GET_CARGO in the above example) using the reference R_VEHICLE.

The view is thus usually narrowed (or at least unchanged). That is why we

describe this type of assignment of reference variables as up-cast. There is a

switch from a view of several components to a view of a few components. As

the target variable can accept more dynamic types in comparison to the source

variable, this assignment is also called Widening Cast

Static and Dynamic Types of References

A reference variable always has two types at runtime: static and dynamic.

In the example, LCL_VEHICLE is the static type of the variable R_VEHICLE.

Depending on the cast assignment, the dynamic type is either LCL_BUS or

LCL_TRUCK. In the ABAP Debugger, the dynamic type is specified in the form

of the following object display.

Down-cast (Narrowing Cast)

Variables of the type “reference to superclass” can also refer to subclass instances

at runtime. You may now want to copy such a reference (back) to a suitable

variable of the type “reference to subclass”.

If you want to assign a superclass reference to a subclass reference, you must

use the down-cast assignment operator MOVE ... ?TO ... or its short form

?=. Otherwise, you would get a message stating that it is not certain that all

components that can be accessed syntactically after the cast assignment are

actually available in the instance. As a rule, the subclass class contains more

components than the superclass.

After assigning this type of reference (back) to a subclass reference to the

implementing class, clients are no longer limited to inherited components: In the

example given here, all components of the LCL_TRUCK instance can be accessed

(again) after the assignment using the reference R_TRUCK2.

The view is thus usually widened (or at least unchanged). That is why we describe

this type of assignment of reference variables as down-cast. There is a switch

from a view of a few components to a view of more components. As the target

variable can accept less dynamic types after the assignment, this assignment is

also called Narrowing Cast

Reward if found helpfull,

Cheers,

Chaitanya.

Re: abap object

Former Member — Wed, 06 Feb 2008 11:01:46 GMT

hi,

One of the significant principles of inheritance is that an instance from a subclass can be used in every

context in which an instance from the superclass appears. This is possible because the subclass has

inherited all components from the superclass and therefore has the same interface as the superclass. The

user can therefore address the subclass instance in the same way as the superclass instance.

Variables of the type “reference to superclass” can also refer to subclass instances at runtime.

The assignment of a subclass instance to a reference variable of the type “reference to superclass” is

described as a narrowing cast, because you are switching from a view with more detail to a view with less

detail.

A reference variable always has two types: static and dynamic:

- The static type of a reference variable is determined by variable definition using TYPE REF TO. It cannot

and does not change. It establishes which attributes and methods can be addressed

- The dynamic type of a reference variable is the type of the instance currently being referred to, it is

therefore determined by assignment and can change during the program run. It establishes what coding is

to be executed for redefined methods.

The static type of a reference variable

Is determined using TYPE REF TO

Remains constant throughout the program run

Establishes which attributes and methods can be

addressed

The dynamic type of a reference variable

Is determined by assignment

Can change during the program run

Establishes what coding is to be executed for redefined

methods

The widening cast logically represents the opposite of the narrowing cast. The widening cast cannot be

checked statically, only at runtime. The Cast Operator “?=” (or the equivalent “MOVE ... ?TO …”) must be

used to make this visible.

With this kind of cast, a check is carried out at runtime to ensure that the current content of the source

variable corresponds to the type requirements of the target variables.

Hope this is helpful, Do reward.

Re: abap object

Former Member — Wed, 06 Feb 2008 11:05:09 GMT

hi,

Follow the link and download the PDF for abap objects.

http://www.esnips.com/doc/6d16a298-9227-4d32-acf1-e91164c89daf/3-ABAP-Objects(P283)

Hope this is helpful, Do reward.

Re: abap object

Former Member — Wed, 06 Feb 2008 11:32:45 GMT

HI,

Narrowing Cast:

Getting a super class variable to refer to a subclass variable is called Narrowing Cast

E.g. Obj_super = obj_sub.

After Narrowing cast, you can use the super class reference to access the components of the subclass instance that were inherited from super class

The components inherited from the superclass can be addressed

Also called “Up-Cast”

Use: A user who is not interested in the finer points of subclasses, but only in the attributes of the superclass, does not need to know about them. The user only wants to work with references to the superclass. Hence in order to allow the user to work with subclass objects, you need a Narrowing cast

Also used to access interface components

Widening Cast:

Getting a sub class variable to refer to a superclass variable is called Widening Cast

Also called “Down-Cast”

The problem (Need for widening cast):

Data: r_vehicle TYPE REF To lcl_vehicle.

LOOP AT vehicle_list INTO r_vehicle.

*Only for trucks

ENDLOOP.

The solution (Widening cast):

Data: r_vehicle TYPE REF To lcl_vehicle,

r_truck TYPE REF TO lcl_truck.

LOOP AT vehicle_list INTO r_vehicle.

TRY.

r_truck ?= r_vehicle.

*processing for trucks

CATCH CX_SY_MOVE_CAST_ERROR INTO r_exception.

*processing for error situation

CLEANUP.

ENDTRY.

ENDLOOP.

Example:

&----

*& Report ZTRG_OBJ6 *

*& *

&----

*& *

&----

REPORT ztrg_obj7.

----

CLASS lcl_super DEFINITION

----

CLASS lcl_super DEFINITION.

PUBLIC SECTION.

METHODS: m1,

m2,

constructor.

PRIVATE SECTION.

DATA: v1 TYPE i.

ENDCLASS. "lcl_super DEFINITION

----

CLASS lcl_super IMPLEMENTATION

----

CLASS lcl_super IMPLEMENTATION.

METHOD m1.

WRITE: /, 'v1: ', v1.

ENDMETHOD. "m1

METHOD m2.

WRITE /'super'.

ENDMETHOD. "m2

METHOD constructor.

v1 = 1.

ENDMETHOD. "constructor

ENDCLASS. "lcl_super IMPLEMENTATION

----

CLASS lcl_sub1DEFINITION

----

CLASS lcl_sub1 DEFINITION INHERITING FROM lcl_super.

PUBLIC SECTION.

METHODS: m2 REDEFINITION,

m3,

constructor.

PRIVATE SECTION.

DATA: v1 TYPE i,

v2 TYPE i.

ENDCLASS. "lcl_sub DEFINITION

----

CLASS lcl_sub1IMPLEMENTATION

----

CLASS lcl_sub1 IMPLEMENTATION.

METHOD m2.

WRITE: 'sub',

/, 'v1: ', v1,

/, 'v2: ', v2.

CALL METHOD super->m2. "THIS WILL CALL M2 OF THE SUPER-CLASS

ENDMETHOD. "m2

METHOD constructor.

CALL METHOD super->constructor.

CALL METHOD m2. "THIS WILL CALL M2 OF THE SUB-CLASS

ENDMETHOD. "constructor

METHOD m3.

WRITE 'Test'.

ENDMETHOD.

ENDCLASS. "lcl_sub IMPLEMENTATION

----

CLASS lcl_sub DEFINITION

----

CLASS lcl_sub2 dEFINITION INHERITING FROM lcl_super.

PUBLIC SECTION.

METHODS: m2 REDEFINITION,

m3,

constructor.

PRIVATE SECTION.

DATA: v1 TYPE i,

v2 TYPE i.

ENDCLASS. "lcl_sub DEFINITION

----

CLASS lcl_sub IMPLEMENTATION

----

CLASS lcl_sub2 IMPLEMENTATION.

METHOD m2.

WRITE: 'sub',

/, 'v1: ', v1,

/, 'v2: ', v2.

CALL METHOD super->m2. "THIS WILL CALL M2 OF THE SUPER-CLASS

ENDMETHOD. "m2

METHOD constructor.

CALL METHOD super->constructor.

CALL METHOD m2. "THIS WILL CALL M2 OF THE SUB-CLASS

ENDMETHOD. "constructor

METHOD m3.

WRITE 'Test'.

ENDMETHOD.

ENDCLASS. "lcl_sub IMPLEMENTATION

START-OF-SELECTION.

DATA: obj TYPE REF TO lcl_super,

obj1 TYPE REF TO lcl_sub1,

obj2 TYPE REF TO lcl_sub2,

OBJECT_LIST TYPE TABLE OF REF TO lcl_super.

CREATE OBJECT obj.

CREATE OBJECT obj1.

CREATE OBJECT obj2.

append obj1 to OBJECT_LIST.

append obj2 to OBJECT_LIST.

loop at OBJECT_LIST into obj.

TRY.

obj1 ?= obj.

write 'Obj1 found'.

CATCH CX_SY_MOVE_CAST_ERROR.

write 'Exception caught'.

ENDTRY.

endloop.