Using Inheritance

Objective

After completing this lesson, you will be able to use inheritance.

Up-Cast and Down-Cast

To instantiate a subclass, you declare a reference variable with the type of the relevant class. Then you use the NEW operator to create the instance. You must pass values to all obligatory parameters of the constructor.

Using Superclass References

A reference variable with the type of a superclass (in this case lcl_plane) can also hold references to objects with the type of a subclass. This makes sense, since a passenger plane or a cargo plane is a plane.

However, a reference variable with the type of the superclass is only aware of the components defined in the superclass. Consequently, when you use a reference with this type to manage an instance of a subclass, you can only address the components from the superclass, even though the actual object to which the reference points is an instance of the subclass.

Assigning object references to a reference variable of a different type is called casting. Assigning a reference that points to a subclass to a reference variable with the type of a superclass is called an up-cast, because you are making the assignment to a type higher up in the inheritance hierarchy.

Calling Methods After an Up-Cast

When you use a reference variable with type ref to lcl_plane to manage a passenger plane instance, you cannot use it to access components that belong to the passenger plane class, as the plane class does not know that they exist and the syntax check cannot know what type of object the reference will actually point to at runtime.

Using the reference, you can, however, access methods whose original definition is contained in the class. This is the case with the get_attributes method in the example in the figure. The question here is which implementation of the method will be called. In this case, the system looks at runtime to see what type of object the reference variable is pointing to, and calls the implementation from the corresponding class. In other words, although we are using a plane reference to manage an instance of the passenger plane class, it is still the method implementation from the passenger plane class that is called.

Assigning a Generic Reference to a Specific Type

You can always assign a reference variable with the type of a subclass to a reference variable with the type of a superclass. For example, you can always assign a passenger plane reference to a plane reference. As we have seen, this is because a passenger plane is a plane. Assigning reference variables in the opposite direction, however, is more tricky. This is because a plane reference can contain references to other classes than the passenger plane class. In other words, where every passenger plane is a plane, not every plane is a passenger plane.

Given an object references plane with type ref to lcl_plane and passenger_plane with type ref to lcl_passenger_plane, the system will always allow you to write plane = passenger_plane. However, the assignment passenger_plane = plane leads to a syntax error because the syntax check cannot be sufficiently sure that the plane reference will actually hold a reference to a passenger plane object at that moment.

The CAST Operator

The syntax check does not let you assign a superclass reference directly to a subclass reference. However, you can still do it using the CAST operator. Casting means looking at an object as though it has a different type. In the example, we tell the system to treat "plane" as though it were an instance of the passenger plane class. This is syntactically correct, as we are now pretending that "vehicle" on the right-hand side of the expression has the same type as "passenger" on the left-hand side. However, there is still no guarantee that plane actually contains a passenger plane reference, and if it turns out not to contain one at runtime, the assignment cannot be made. Left unprotected, this assignment could cause a runtime error.

Securing a Down-Cast

If you are not certain that the object to which a reference variable is pointing is actually an instance of the correct subclass, you can check it using the logical expression IS INSTANCE OF. In this example, the assignment to the passenger plane reference is only processed if plane actually points to an instance of the class lcl_passenger_plane.

Try It Out: Up-Cast and Down-Cast

Create a new class that implements the interface IF_OO_ADT_CLASSRUN.

Switch to the Local Types tab and copy the following code snippet into the editor:

Code Snippet

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114

CLASS lcl_plane DEFINITION.
PUBLIC SECTION.
TYPES: BEGIN OF ts_attributes,
name TYPE string,
value TYPE string,
END OF ts_attributes,
* declare table - do not allow the same attribute to be used more than once
tt_attributes TYPE SORTED TABLE OF ts_attributes WITH UNIQUE KEY name.


METHODS constructor IMPORTING iv_manufacturer TYPE string
iv_type TYPE string.
METHODS: get_Attributes RETURNING VALUE(rt_Attributes) TYPE tt_attributes.


PROTECTED SECTION.
DATA manufacturer TYPE string.
DATA type TYPE string.

PRIVATE SECTION.

ENDCLASS.


CLASS lcl_plane IMPLEMENTATION.
METHOD constructor.
manufacturer = iv_manufacturer.
type = iv_type.
ENDMETHOD.


METHOD get_attributes.
rt_attributes = VALUE #( ( name = 'MANUFACTURER' value = manufacturer )
( name = 'TYPE' value = type ) ) .
ENDMETHOD.


ENDCLASS.


CLASS lcl_cargo_plane DEFINITION INHERITING FROM lcl_plane.
PUBLIC SECTION.
METHODS constructor IMPORTING iv_manufacturer TYPE string
iv_type TYPE string
iv_cargo TYPE i.
METHODS get_attributes REDEFINITION.
private section.
data cargo type i.
ENDCLASS.


CLASS lcl_cargo_plane IMPLEMENTATION.
METHOD constructor.


super->constructor( iv_manufacturer = iv_manufacturer iv_type = iv_type ).
cargo = iv_cargo.


ENDMETHOD.


METHOD get_attributes.


* method uses protected attributes of superclass


rt_attributes = value #( ( name = 'MANUFACTURER' value = manufacturer )
( name = 'TYPE' value = type )
( name ='CARGO' value = cargo ) ).


ENDMETHOD.


ENDCLASS.


CLASS lcl_passenger_plane DEFINITION INHERITING FROM lcl_Plane.
PUBLIC SECTION.
METHODS constructor IMPORTING iv_manufacturer TYPE string
iv_type TYPE string
iv_seats TYPE i.
METHODS get_Attributes REDEFINITION.
private section.
data seats type i.
ENDCLASS.


CLASS lcl_passenger_plane IMPLEMENTATION.


METHOD constructor.


super->constructor( iv_manufacturer = iv_manufacturer iv_type = iv_type ).


ENDMETHOD.


METHOD get_attributes.


* Redefinition uses call of superclass implementation

rt_attributes = super->get_attributes( ).
rt_Attributes = value #( base rt_attributes ( name = 'SEATS' value = seats ) ).

ENDMETHOD.

ENDCLASS.

Switch to the Global Class tab and paste the following code snippet into the implementation of method if_oo_adt_classrun~main( ):

Code Snippet

12345678910111213141516171819202122232425262728293031323334353637383940414243444546

DATA passenger TYPE REF TO lcl_passenger_Plane.
DATA cargo TYPE REF TO lcl_cargo_plane.
DATA plane TYPE REF TO lcl_Plane.






passenger = NEW #( iv_manufacturer = 'BOEING' iv_type = '737-800' iv_seats = 130 ) .
cargo = NEW #( iv_manufacturer = 'AIRBUS' iv_type = 'A340' iv_cargo = 60000 ).


out->write( 'Output using passenger plane object reference' ).
out->write( passenger->Get_attributes( ) ).


plane = passenger.


out->write( 'Output using superclass object reference' ).
out->write( plane->get_attributes( ) ).


* Can't use the superclass reference to get the number of seats of the
* passenger plane, because the relevent method isn't declared in the superclass.


* plane->get_seats( ).


* Can't assign the plane directly to a passenger plane reference variable, because
* not every plane is a passenger plane.


*passenger = plane.


* Make sure the plane is actually a passenger plane, then force the cast.
IF plane IS INSTANCE OF lcl_passenger_plane.
passenger = CAST #( plane ).
ENDIF.


ENDMETHOD.

Select CTRL + F3 to activate the class and F9 to execute it as a console app.
Play around with the source code to get familiar with the concepts.

Work with Superclass References

In the previous exercise, you created a common superclass LCL_FLIGHT for the classes LCL_PASSENGER_FLIGHT and LCL_CARGO_FLIGHT. Now you will modify the local class LCL_CARRIER to utilize the inheritance relationship. You will type reference variables used as parameters to the type of the superclass and, instead of two separate instance attributes passenger_flights and cargo_flights, define a single instance attribute flights in which you can store references to all flight instances, regardless of whether they are passenger or cargo flights.

Template:

/LRN/CL_S4D401_OOS_INHERITANCE (Global Class)

Solution:

/LRN/CL_S4D401_OOS_INH_USAGE (Global Class)

Task 1: Copy Template (Optional)

Copy the template class /LRN/CL_S4D401_OOS_INHERITANCE. If you finished the previous exercise, you can skip this task and continue editing your class ZCL_##_SOLUTION.

Steps

Copy class /LRN/CL_S4D401_OOS_INHERITANCE to a class in your own package (suggested name: ZCL_##_SOLUTION, where ## stands for your group number).
1. In the Project Explorer, right-click class /LRN/CL_S4D401_OOS_INHERITANCE to open the context menu.
2. From the context menu, choose Duplicate....
3. Enter the name of your package in the Package field. In the Name field, enter ZCL_##_SOLUTION, where ## stands for your group number.
4. Choose Next.
5. Confirm the transport request and choose Finish.
Activate the copy.
1. Press Ctrl + F3 to activate the class.

Task 2: Generic Parameter

In local class LCL_CARRIER, adjust the definitions of methods FIND_PASSENGER_FLIGHT and FIND_CARGO_FLIGHT. In both methods, type the exporting parameter e_flight as a reference variable based on local class LCL_FLIGHT.

Steps

In local class LCL_CARRIER, adjust the definition of method FIND_CARGO_FLIGHT. Type the returning parameter e_flight with LCL_FLIGHT instead of LCL_CARGO_FLIGHT. Make sure you save the change.

Adjust the code as follows:

ABAP

123456789
  METHODS find_cargo_flight
    IMPORTING
      i_airport_from_id TYPE /dmo/airport_from_id
      i_airport_to_id   TYPE /dmo/airport_to_id
      i_from_date       TYPE /dmo/flight_date
      i_cargo           TYPE /lrn/plane_actual_load
    EXPORTING
      e_flight          TYPE REF TO lcl_flight
      e_days_later      TYPE i.

Analyze the use of the local variable flight in the implementation of the method FIND_CARGO_FLIGHT.
1. To display the type of the reference variable flight, place the cursor on the variable name and press F2.
Analyze the call of method FIND_CARGO_FLIGHT in method IF_OO_ADT_CLASSRUN~MAIN in your global class.
1. To display the type of the reference variable cargo_flight, place the cursor on the variable name and press F2.

Adjust the definition of method FIND_PASSENGER_FLIGHT in the same way. Type the returning parameter e_flight with LCL_FLIGHT instead of LCL_PASSENGER_FLIGHT.

Adjust the code as follows:

ABAP

123456789
  METHODS find_passenger_flight
    IMPORTING
      i_airport_from_id TYPE /dmo/airport_from_id
      i_airport_to_id   TYPE /dmo/airport_to_id
      i_from_date       TYPE /dmo/flight_date
      i_seats           TYPE i
    EXPORTING
      e_flight          TYPE REF TO lcl_flight
      e_days_later      TYPE i.

Activate the code to verify that this change also does not cause any syntax errors.
1. Press Ctrl + F3 to activate the code.

Task 3: Generic Attribute

In local class LCL_CARRIER, define a private instance attribute flights in which you can store references to instances of LCL_PASSENGER_FLIGHT and LCL_CARGO_FLIGHT at the same time. Fill the attribute in the implementation of the CONSTRUCTOR method with the combined content of attributes passenger_flights and cargo_flights.

Steps

In local class LCL_FLIGHT, use a quick fix to generate a public table type that is based on this class (suggested name for the table type: tab).
1. Go to the definition of local class LCL_FLIGHT.
2. In the CLASS statement, place the cursor on lcl_flight and press Ctrl + 1 to invoke the available quick fixes.
3. From the list of available quick fixes, choose Generate table type for lcl_flight.
4. The new TYPES statement should look something like this:
  ABAP
```
1
  TYPES tab TYPE STANDARD TABLE OF REF TO lcl_flight WITH DEFAULT KEY.
```
In the private section of local class LCL_CARRIER, define a new instance attribute flights. Type it with the table type that you just created in local class LCL_FLIGHT.
1. Adjust the code as follows:
  ABAP
```
1234
  DATA passenger_flights TYPE lcl_passenger_flight=>tt_flights.
  DATA cargo_flights     TYPE lcl_cargo_flight=>tt_flights.

  DATA flights           TYPE lcl_flight=>tab.
```
Adjust the implementation of the CONSTRUCTOR method of local class LCL_CARRIER. After you called method GET_FLIGHTS_BY_CARRIER of LCL_PASSENGER_FLIGHT, add all object references stored in passenger_flights to flights.
1. Go to the implementation of the CONSTRUCTOR method in local class LCL_CARRIER.
2. Before the ENDMETHOD statement, add the following code:
  ABAP
```
123
  LOOP AT passenger_flights INTO DATA(passflight).
    APPEND passflight TO flights.
  ENDLOOP.
```
  If you prefer a table comprehension, add the following code instead:
  ABAP
```
12345
  flights = VALUE #( BASE flights
                     FOR pflight IN passenger_flights (
                       pflight
                                                      )
            ).
```

Similarly, implement a loop over cargo_flights and add these references to flights as well.

Before the ENDMETHOD statement, add the following code:

ABAP

123
  LOOP AT cargo_flights INTO DATA(cargoflight).
    APPEND cargoflight TO flights.
  ENDLOOP.

If you prefer a table comprehension, add the following code instead:

ABAP

12345
  flights = VALUE #( BASE flights
                     FOR cflight IN cargo_flights (
                       cflight
                                                  )
            ).

Task 4: Generic Access and Down-Cast

Eliminate instance attributes passenger_flights and cargo_flights in local class LCL_CARRIER and replace them with the new attribute flights. Where the code accesses specific components of the subclasses, implement a down-cast.

Steps

In the definition part of local class LCL_CARRIER, remove or comment the definition of attributes passenger_flights and cargo_flights.
1. Select the two DATA statements and press Ctrl + < to add a comment sign in front of each code row:
  ABAP
```
12
*  DATA passenger_flights TYPE lcl_passenger_flight=>tt_flights.
*  DATA cargo_flights     TYPE lcl_cargo_flight=>tt_flights.
```

In method CONSTRUCTOR, use inline declarations to declare passenger_flights and cargo_flights as local variables.

Adjust the code as follows:

ABAP

1234567
  DATA(passenger_flights) =
         lcl_passenger_flight=>get_flights_by_carrier(
                                 i_carrier_id = i_carrier_id ).

  DATA(cargo_flights) =
         lcl_cargo_flight=>get_flights_by_carrier(
                                 i_carrier_id = i_carrier_id ).

After the method calls with the inline declarations, fill a private instance attribute with the number of rows in local variable passenger_flights (suggested name: pf_count).
Hint
First implement the value assignment. Then use a quick fix to create the attribute declaration.
1. Adjust the code as follows:
  ABAP
```
12345
  DATA(passenger_flights) =
         lcl_passenger_flight=>get_flights_by_carrier(
                                 i_carrier_id = i_carrier_id ).

  pf_count = lines( passenger_flights ).
```
2. Place the cursor on pf_count, press Ctrl + 1 and choose Declare attribute pf_count.
Similarly, fill a private instance attribute with the number of rows in local variable cargo_flights (suggested name: cf_count).
1. Adjust the code as follows:
  ABAP
```
12345
  DATA(cargo_flights) =
         lcl_cargo_flight=>get_flights_by_carrier(
                             i_carrier_id = i_carrier_id ).

  cf_count = lines( cargo_flights ).
```
2. Place the cursor on cf_count, press Ctrl + 1 and choose Declare attribute cf_count.

In method GET_OUTPUT, replace the embedded LINES functions with the attributes you just defined.

Adjust the code as follows:

ABAP

123456
  METHOD get_output.
    APPEND |{ 'Carrier Name:'(001)       } { me->name }| TO r_result.
    APPEND |{ 'Passenger Flights:'(002)  } { pf_count }| TO r_result.
    APPEND |{ 'Average free seats:'(003) } { get_average_free_seats(  ) }| TO r_result.
    APPEND |{ 'Cargo Flights:'(004)      } { cf_count }| TO r_result.
  ENDMETHOD.

In method FIND_CARGO_FLIGHT, replace attribute cargo_flights with attribute flights.
1. Adjust the code as follows:
  ABAP
```
12
*  LOOP AT me->cargo_flights INTO DATA(flight)
  LOOP AT me->flights INTO DATA(flight)
```

In the call of method GET_FREE_CAPACITY add a CAST expression.

Adjust the code as follows:

ABAP

1234
  IF connection_details-airport_from_id = i_airport_from_id
    AND connection_details-airport_to_id = i_airport_to_id
*    AND flight->get_free_capacity(  ) >= i_cargo.
    AND CAST lcl_cargo_flight( flight )->get_free_capacity(  ) >= i_cargo.

To make sure you only consider instances of LCL_CARGO_FLIGHT, extend the WHERE condition of the LOOP.
Hint
Remember that in internal tables with elementary row type you address the content with pseudo-component table_line.
1. Adjust the code as follows:
  ABAP
```
123
  LOOP AT me->flights INTO DATA(flight)
    WHERE table_line->flight_date >= i_from_date
      AND table_line IS INSTANCE OF lcl_cargo_flight.
```

Adjust the implementation of method FIND_PASSENGER_FLIGHT in the same way.

Adjust the code as follows:

ABAP

12345678910111213141516171819
  LOOP AT me->flights INTO DATA(flight)
    WHERE table_line->flight_date >= i_from_date
      AND table_line IS INSTANCE OF lcl_passenger_flight.

    DATA(connection_details) = flight->get_connection_details(  ).

    IF connection_details-airport_from_id = i_airport_from_id
      AND connection_details-airport_to_id = i_airport_to_id
      AND CAST lcl_passenger_flight( flight )->get_free_seats( ) >= i_seats.

      DATA(days_later) = flight->flight_date - i_from_date.

      IF days_later < e_days_later. "earlier than previous one?
        e_flight = flight.
        e_days_later = days_later.
      ENDIF.
    ENDIF.

  ENDLOOP.

Adjust the implementation of the GET_AVERAGE_FREE_SEATS method. Use the internal table flights in the table reduction and add a CAST expression and a WHERE condition to the reduction. The required number of passenger flights is stored in the attribute pf_count created above.

Adjust the code as follows:

ABAP

12345678910111213141516
  METHOD get_average_free_seats.
* Table Reduction
********************************************************
*    r_result = REDUCE #(
*                 INIT i = 0
*                 FOR flight IN passenger_flights
*                 NEXT i += flight->get_free_seats( )
*                       ) / lines( passenger_flights ).

    r_result = REDUCE #(
                 INIT i = 0
                 FOR flight IN flights
                 WHERE ( table_line IS INSTANCE OF lcl_passenger_flight )
                 NEXT i += CAST lcl_passenger_flight( flight )->get_free_seats( )
                       ) / pf_count.
  ENDMETHOD.

Activate and test your global class as console app.
1. Press Ctrl + F3.
2. Press F9.

Next lesson