Mini Lesson Practice — Local Classes and Local Types

Learning path

Complete the guided mini lesson — Local Classes and Local Types before starting this practice. When you finish, continue to Lesson 5 — Object APIs, Validation & Collaboration.

Build a practical business-style program using:

one global class
local structured types
one local table type
one local helper class

Scenario:

A company receives employee expense claims. Each claim must be evaluated before it can be approved, rejected, or sent for manager approval.

The purpose is to practise:

class pool
Local Types
local TYPES
local classes
visibility
responsibility separation

Practice information

Recommended time	About 2.5–3 hours
Environment	SAP BTP ABAP Trial
Global class	ZCL_EXPENSE_PROCESSOR_###
Local helper	lcl_claim_evaluator
Main focus	Local types + local class design

1. Create the global class

Create:

ZCL_EXPENSE_PROCESSOR_###

Description:

Expense Claim Processor

Implement:

IF_OO_ADT_CLASSRUN

The global class should be responsible for:

creating input
calling the evaluator
displaying results

2. Open Local Types

Open:

Local Types

Do not put the helper in:

Test Classes

Do not create another global helper class.

3. Create ty_claim

Define a local structured type containing:

claim_no
employee_id
category
amount
currency
receipt_attached
days_old
urgent

Suggested ABAP types:

claim_no         TYPE string
employee_id      TYPE string
category         TYPE string
amount           TYPE decfloat34
currency         TYPE string
receipt_attached TYPE abap_bool
days_old         TYPE i
urgent           TYPE abap_bool

4. Create tt_claims

Define:

tt_claims

as a standard internal table of:

ty_claim

with:

EMPTY KEY

5. Create ty_evaluation

Define another local structured type containing:

claim_no
accepted
requires_manager
decision
message

Suggested types:

claim_no         TYPE string
accepted         TYPE abap_bool
requires_manager TYPE abap_bool
decision         TYPE string
message          TYPE string

6. Create the local helper class

Create:

lcl_claim_evaluator

Its public method:

evaluate

must:

IMPORT ty_claim
RETURN ty_evaluation

The evaluation rules belong in this local class.

Do not put them in main.

7. Rule A — amount

If:

amount <= 0

then:

accepted = false
decision = REJECTED
message  = Amount must be greater than zero

Do not continue evaluating that claim.

8. Rule B — age

If:

days_old > 60

then:

accepted = false
decision = REJECTED
message  = Claim is older than 60 days

Do not continue evaluating that claim.

9. Rule C — receipt

If:

amount > 25

and:

receipt_attached = false

then:

accepted = false
decision = REJECTED
message  = Receipt is required for claims over 25

Do not continue evaluating that claim.

10. Rule D — manager approval

If the claim passed all rejection rules:

accepted = true

Manager approval is required when:

amount >= 500

or:

urgent = true

Then return:

requires_manager = true
decision = MANAGER APPROVAL

Otherwise:

requires_manager = false
decision = APPROVED

11. Currency assumption

Do not implement currency conversion.

Treat:

amount
currency

as input data.

Use:

EUR

for the required test cases.

12. Create at least six claims

Your test data must cover:

normal approval
manager approval because amount >= 500
manager approval because urgent = true
rejection because amount <= 0
rejection because claim is older than 60 days
rejection because receipt is missing

13. Suggested test cases

Claim	Amount	Receipt	Days old	Urgent	Expected
CLM-001	18	No	5	No	Approved
CLM-002	720	Yes	12	No	Manager approval
CLM-003	90	Yes	3	Yes	Manager approval
CLM-004	0	Yes	2	No	Rejected
CLM-005	120	Yes	75	No	Rejected
CLM-006	80	No	10	No	Rejected

14. Implement the global orchestration

In:

IF_OO_ADT_CLASSRUN~MAIN

the global class should:

1. create the tt_claims table;
2. create one lcl_claim_evaluator object;
3. loop over the claims;
4. call evaluate;
5. output every result.

15. Output requirements

For every claim, output at least:

Claim Number
Decision
Message

Optional:

Employee ID
Amount
Currency
Requires Manager

16. Architecture check

Your solution should look like:

ZCL_EXPENSE_PROCESSOR_###
        ↓
     tt_claims
        ↓
       LOOP
        ↓
lcl_claim_evaluator
        ↓
   ty_evaluation
        ↓
      output

17. Responsibility check

Complete:

The global class is responsible for:
_____________________________________

The local helper class is responsible for:
_____________________________________

The local data types are responsible for:
_____________________________________

18. Visibility check

Answer:

Can an unrelated global class directly instantiate lcl_claim_evaluator?

Can another class address ty_claim as ZCL_EXPENSE_PROCESSOR_###=>TY_CLAIM?

Explain why.

19. Local or global?

Decide whether each should remain local or become global.

A. Claim evaluator used only by this class pool

B. Currency conversion service used by twenty applications

C. Evaluation result type used only by the processor and helper

D. Public API result type used by many consumers

Explain each decision.

20. Repair exercise — wrong tab

A student puts:

lcl_claim_evaluator

in:

Test Classes

Answer:

Why is this the wrong location?

What belongs in Test Classes?

21. Repair exercise — everything in main

Imagine:

main
├─ checks amount
├─ checks age
├─ checks receipt
├─ checks approval
└─ outputs result

Explain two disadvantages.

Then explain what improves when evaluation moves into:

lcl_claim_evaluator

22. Repair exercise — unnecessary global helper

Suppose a student creates:

ZCL_CLAIM_EVALUATOR_###

even though nothing outside the expense processor uses it.

Answer:

Is it technically possible?

Why might a local class be the cleaner design?

23. Repair exercise — type vs variable

Explain:

TYPES ty_claim ...

versus:

DATA claim TYPE ty_claim.

Then declare one additional variable based on:

ty_claim

without copying its components.

24. Repair exercise — local vs public member type

Imagine moving:

ty_claim

into:

PUBLIC SECTION.

of the global class.

Answer:

How would another class address it?

What would become part of the global class API?

Is that desirable for this exercise?

25. Optional challenge — second local helper

Create:

lcl_claim_summary

Its responsibility is to summarize evaluation results.

Count:

approved
manager approval
rejected

Keep responsibilities separate:

lcl_claim_evaluator
→ evaluates one claim

lcl_claim_summary
→ summarizes many evaluations

26. Optional challenge — result table type

Create:

tt_evaluations

as a local table type of:

ty_evaluation

Collect results during processing and pass them to:

lcl_claim_summary

27. Optional investigation — Class-Relevant Local Types

The required solution uses:

Local Types

For an optional investigation:

1. add a private reference attribute to the global class;
2. type it with a local helper class;
3. observe why that local definition must be available as a Class-Relevant Local Type.

Remove the experiment afterward if it makes your final solution unnecessarily complex.

28. Knowledge check

1. What is a class pool?

2. How many global classes are in one class pool?

3. What other local definitions can a class pool contain?

4. Why is lcl_claim_evaluator called a local class?

5. Where is ty_claim visible?

6. Why is ty_claim not a public type of ZCL_EXPENSE_PROCESSOR_###?

7. What is the difference between Local Types and Class-Relevant Local Types?

8. What belongs in Test Classes?

9. When should an implementation helper stay local?

10. When should you create a reusable global class instead?

29. Submission checklist

• ZCL_EXPENSE_PROCESSOR_### exists.
• It implements IF_OO_ADT_CLASSRUN.
• ty_claim is defined locally.
• tt_claims is defined locally.
• ty_evaluation is defined locally.
• lcl_claim_evaluator exists.
• Helper implementation is in Local Types.
• evaluate imports one claim.
• evaluate returns one evaluation.
• Amount rule is implemented.
• Age rule is implemented.
• Receipt rule is implemented.
• Manager-approval rule is implemented.
• At least six claims are tested.
• Every required rule path is exercised.
• main does not duplicate evaluation logic.
• Student can explain why the helper is local.
• Student can explain Local Types vs Test Classes.
• Student can explain Local Types vs Class-Relevant Local Types.

30. End-of-practice mental model

Class Pool
│
├─ Global Class
│    └─ orchestrates the use case
│
├─ Local Types
│    ├─ ty_claim
│    ├─ tt_claims
│    ├─ ty_evaluation
│    └─ lcl_claim_evaluator
│
└─ Test Classes
     └─ reserved for ABAP Unit

The key design question is:

Does this type or helper need to be part of a reusable external API, or is it an implementation detail of this class pool?

Continue to Lesson 5 — Object APIs, Validation & Collaboration →