You are on page 1of 23

Cos la programmazione orientata agli oggetti?

L'object orientation un metodo di risoluzione dei problemi, in cui la soluzione software riflette gli oggetti del mondo reale.
Termini:
1. Oggetti: Un oggetto una sezione di codice contenente dati e servizi;
i dati vengono definiti attributi delloggetto, i servizi (funzioni) vengono chiamati metodi; di solito i metodi operano
tramite attributi privati (vale a dire visibili solo al codice delloggetto stesso).
2. Classi: Una classe il modello delloggetto; si pu paragonare un oggetto a una variabile, mentre la classe a un tipo dati.
Allinterno di un programma si possono creare quanti si voglia oggetti per classe. Gli oggetti vengono anche chiamati
istanze di una classe.
3. Riferimenti agli oggetti: In un programma gli oggetti vengono identificati tramite dei riferimenti che puntano alloggetto
stesso (come dei puntatori allarea di memoria); tramite i riferimenti si pu accedere agli attributi e ai metodi
delloggetto.
Propriet degli oggetti
1. Incapsulamento: Loggetto interagisce con il resto del programma tramite una determinata interfaccia,
limplementazione delloggetto incapsulata, vale a dire invisibile al di fuori dell'oggetto stesso.
2. Polimorfismo: Metodi aventi lo stesso nome saranno differenti in classi differenti. Limplementazione di un metodo
specifica di una particolare classe (usando le interfacce si possono indirizzare metodi con lo stesso nome in oggetti
differenti.)
3. Ereditariet: Da una classe pu derivarne unaltra; la classe derivata erediter dati e metodi della classe superiore (
possibile per sovrascriverli con nuovo codice se si vuole modificarli).
VANTAGGI DELLOO
Software complessi diventano pi facili, perch la struttura OO fornisce una rappresentazione pi vicina alla realt.

Minor tempo per eventuali correzioni


Permette il riutilizzo dei componenti grazie al polimorfismo e allereditariet.
E pi facile scoprire eventuali errori nella fase di progettazione.

Oggetti ABAP
Gli oggetti abap sono completamente compatibili con le istruzioni convenzionali.

Dai functions groups agli oggetti


La cosa pi vicina agli oggetti nelle versioni precedenti di SAP sono i gruppi funzioni, dove i dati globali del gruppo
possono essere visti come atttributi e i moduli funzione come metodi.
Quando nel programma viene chiamata una funzione, nella sessione interna del programma viene attivata unistanza (zona
di memoria contente i dati del gruppo) al gruppo di funzioni, tramite la quale operiamo indirettamente con i dati globali del
function group.
La differenza con gli oggetti che, mentre possibile aprire pi istanze per function group differenti, non possibile aprire
pi istanze allo stesso gruppo funzioni (vale a dire non si possono creare pi copie delle variabili globali di un functiongroup).
Esempio: ho il gruppo funzioni contatore formato dalle tre funzioni setta_contatore, incrementa_contatore,
importa_contatore.
Chiamo nel programma la prima funzione passando una variabile contenente il valore 5, che finir in una variabile
globale interna al gruppo funzioni (chiamata ad esempio NUMERO).

Chiamando la seconda incrementer questo valore di uno.


Chiamando la terza mi sar restituito il valore.
Se dopo la chiamata alla prima funzione lavessi richiamata ancora passando il valore 8 avrei semplicemente
sovrascritto il contenuto di NUMERO; non potr mai avere con i function group due istanze separate una con
NUMERO a 5 e una con NUMERO a 8, mentre con gli oggetti possibile.

Classi
Le classi sono i modelli per gli oggetti, cio la loro descrizione astratta. Gli attributi e i metodi di un oggetto sono le
componenti di una classe.
Le classi possono essere definite sia localmente (dentro il programma) sia globalmente per mezzo del class builder, in
questo caso viene creato un programma apposito detto class pool in cui vengono sviluppate le varie componenti della classe.
DEFINIZIONE DI UNA CLASSE LOCALE
La definizione di una classe avviene atttraverso listruzione:
CLASS <nomeclasse> DEFINITION.
.
ENDCLASS.
Dentro la dichiarazione vanno dichiarate le componenti della stessa (attributi, eventi, metodi).
Per implementare i metodi dichiarati dentro la definition si usa questa istruzione:

CLASS <nomeclasse> IMPLEMENTATION.

ENDCLASS.
DICHIARAZIONE DI UN ATTRIBUTO
Un attributo viene dichiarato come una normale variabile.
DATA:
Esistono anche attributi particolari (statici) non legati ad una singola istanza, ma legati alla classe, cio validi per tutte le
istanze di quella classe. Vanno dichiarati cos:
CLASS-DATA:..
DICHIARAZIONE DI UN METODO
Un metodo dichiarato nella parte di definizione tramite listruzione:
METHODS:
Ed implementato nella implementation tramite listruzione:
METHOD <nomemetodo>.
.
ENDMETHOD.

Esistono anche metodi statici, definiti cos:


CLASS-METHODS:..
Questi ultimi per possono usare solo attributi ed eventi statici a loro volta.
Esistono anche due metodi speciali, CONSTRUCTOR e CLASS-CONSTRUCTOR, che vengono chiamati automaticamente
alla chiamata della classe.
EVENTI
Gli oggetti possono usare gli eventi per azionare dei metodi attivabili da evento in altri oggetti o classi.
Un evento si dichiara nella definition con listruzione:
EVENTS:..
Esistono anche eventi statici definiti con:
CLASS-EVENTS:.
Per alzare un evento da un metodo si usa listruzione:
RAISE EVENT <nomeevento>.
Per legare un metodo allalzarsi di un evento bisogna usare lestensione alla dichiarazione del metodo:
FOR EVENT <nomeevento> OF <nomeclasse>

(N.B. il metodo non deve appartenere per forza alla stessa classe in cui dichiarato levento, ci penser listruzione SET
HANDLER da programma a legarli.)
Listruzione SET HANDLER va messa nel programma su cui girano gli oggetti e lega gli eventi ai metodi che devono
azionare.
TIPI e COSTANTI
Nelle classi possibile anche dichiarare dei tipi e delle costanti, mediante le istruzioni:
TYPES:
CONSTANTS:..
SEZIONI DI VISIBILITA
La definizione di una classe pu essere divisa in tre sezioni di visibilit.
CLASS <nomeclasse> DEFINITION.
PUBLIC SECTION.
.
PROTECTED SECTION.
.
PRIVATE SECTION.
.
ENDCLASS.

Le regole di accesso ad un attributo cambiano a seconda della sezione in cui questultimo dichiarato.
Public section
Gli attributi dichiarati qui dentro sono accessibili direttamente da programmi, dai metodi della classe, dalle sue
sottoclassi.
Protected section
Gli attributi in questa sezione sono accessibili dai metodi della classe e dalle sottoclassi della stessa.
Private section
Gli attributi in questa sezione sono accessibili solo dai metodi della classe.

CHIAMATA DEGLI OGGETTI


Per chiamare un oggetto internamente ad un programma bisogna prima di tutto creare un riferimento (o puntatore) alla
classe delloggetto.
Si usa perci listruzione:
TYPES: <nomeriferimento> TYPE REF TO <nomeclasse>.
Il passo successivo la creazione dellistanza legata ad una variabile di tipo riferimento.
DATA: <nomevar> TYPE <nomeriferimento>
START-OF-SELECTION.
CREATE OBJECT <nomevar>.
In questo modo nel programma si creata una variabile legata ad una zona di memoria, in cui i dati sono organizzati
come nella classe voluta, e tramite questa variabile possibile accedere ai metodi e agli attributi pubblici della classe.

<nomevar>-<nomeattributo>.
CALL METHOD <nomevar>-<nomemetodo>.
Per accedere agli attributi e ai metodi statici:
<nomeclasse>=><nomeattributo>.
CALL METHOD <nomeclasse>=><nomemetodo>,
E possibile creare pi istanze semplicemente usando pi volte listruzione Create object con diverse variabili sempre di
tipo riferimento.
E possibile che due riferimenti dello stesso tipo puntino alla stessa classe semplicemente usando listruzione
<nomevar1>=<nomevar2>.
(N.B. usare la classe OBJECT in TYPE REF equivale a far puntare il riferimento a NULL.)
La vita di un oggetto nel programma ha termine con la fine del programma.

DICHIARAZIONE E CHIAMATA DI METODI


DICHIARAZIONE DI UN METODO
METHODS <nomemetodo> IMPORTING..[VALUE(]<i>[)] TYPE tipo [OPTIONAL]..
EXPORTING..[VALUE(]<e>[)] TYPE tipo [OPTIONAL]..
CHANGING..[VALUE(]<c>[)] TYPE tipo [OPTIONAL]..

RETURNING.. VALUE(<r>)
EXCEPTIONS..<e>.
Lo stesso formato va bene per anche per CLASS-METHODS
IMPLEMENTAZIONE DI UN METODO
METHOD <nomemetodo>.

ENDMETHOD.
Dentro limplementazione possibile dichiarare delle variabili locali, usare la RAISE <exceptions> e la MESSAGE
RAISING dei function module.
CHIAMATA DI UN METODO
CALL METHOD <nomemetodo> EXPORTING .. <i>=<f>
IMPORTING .. <e>=<g>
CHANGING .. <c>=<f>
RECEIVING .. r=h
EXCEPTIONS.. <e>= rc
METODO A CHIAMATA PER EVENTO
Un metodo legato ad un evento si dichiara cos:
METHODS <nomemetodo> FOR EVENT <nomeevento> OF <nomeclasse o nomeinterfaccia>

I parametri di importazione del metodo devono coincidere con quelli di esportazione dellevento.

EREDITARIETA (SOTTOCLASSI)
Lereditariet permette di far derivare una nuova classe da una classe esistente.
Per far derivare una classe basta usare:
CLASS <nomesottoclasse> DEFINITION INHERITING FROM <nomesuperclasse>.
La sottoclasse eredita tutte le componenti della classe superiore ma pu usare solo quelli protetti o pubblici, quelli privati
possono essere usati solo dai metodi ereditati dalla classe superiore, i quali a loro volta, non possono usare gli attributi
privati dichiarati nella sottoclasse (cio quelli aggiunti in pi rispetto alla superclasse).
Un metodo ereditato pu essere ridefinito tramite listruzione REDEFINITION associata a METHODS.
I metodi e gli attributi statici ereditati faranno riferimento sempre e comunque alla classe da cui provengono.

INTERFACCE
Le interfacce consentono di accedere a classe differenti e a metodi differenti, usando gli stessi nomi per tutti.
Linterfaccia una struttura la cui definizione simile a quella di una classe, ma la cui implementazione viene fatta
allinterno delle varie classi a cui viene associata.

DEFINIZIONE DI INTERFACCIA
INTERFACE <nomeinterfaccia>.
.
ENDINTERFACE.
Nella definizione si possono usare tutte le componenti delle classi (metodi, attributi, eventi) ma non si possono usare le varie
sezioni di visibilit (linterfaccia public per definizione.)
IMPLEMENTAZIONE DI INTERFACCIA
Per implementare uninterfaccia questa va prima di tutto dichiarata allinterno della classe a cui si vuole associarla con
listruzione:
INTERFACES <nomeinterfaccia>.
Va dichiarata solo nella sezione public.
Per implementare i metodi dellinterfaccia, nella sezione di implementazione dei metodi della classe, si deve dare
listruzione:
METHOD <nomeinterfaccia~nomemetodointerfaccia>.
..
ENDMETHOD.
Naturalmente se linterfaccia viene associata anche ad unaltra classe i suoi vari metodi andranno implementati di nuovo
(non necessariamente uguale pero ) allinterno di questultima.

RIFERIMENTI ALLE INTERFACCE


Allinterno di un programma il riferimento ad uninterfaccia si dichiara in modo simile a quello di una classe :
TYPES: <nomeriferimentointerfaccia> TYPE REF TO <interfaccia>
Similmente per accedere ai metodi si usa:
Call method <nomevarinterfaccia>-><nomemetodo>
INDIRIZZAMENTO DI UN INTERFACCIA AD UNA VARIABILE
Per collegare una variabile interfaccia ad una classe in cui in precedenza era stata dichiarata si deve prima dichiarare una
variabile di classe e poi associare le due variabili in questo modo:
<nomevarintefaccia>=<nomevarclasse>
In questo modo con listruzione
Call method <nomevarinterfaccia>-><nomemetodo> si accedera al metodo cosi come e stato implementato dentro quella
classe ; per usare lo stesso metodo ma dichiarato in unaltra classe sara sufficiente ripetere lassociazione alla nuova classe.
(NB: listruzione CALL METHOD <nomevarclasse>-><nomeinterfaccia~nomemetodo> e perfettamente equivalente alla
precedente)

EVENTI
Nella gestione degli eventi per chiamata si intende unazione , mentre per alzamento si intende la reazione.
In particolare i metodi a chiamata devento sono quei metodi la cui attivazione dipende dallalzarsi dellevento a loro
associato in seguito ad una chiamata da parte di un altro metodo.
CHIAMATA DI EVENTO
Per chiamare un evento dentro un metodo e necessario che sia prima dichiarato dentro la classe:
EVENTS <nomeevento> EXPORTING VALUE<e> TYPE tipo [optional] value e obbligatorio
Per gli eventi statici
CLASS-EVENTS <nomeevento>.
Agli eventi e possibile dare solo parametri di esportazione che coincideranno con quelli di importazione del metodo ad essa
legato.
Per chiamare levento si usera dentro limplementazione di un metodo listruzione:
RAISE EVENT <nomeevento> EXPORTING <e>=<f>.

ALZAMENTO DEGLI EVENTI


Per far si che un metodo parta alla chiamata di un evento (NB il metodo puo essere anche in una classe diversa da quella
dell evento) bisogna che sia dichiarato cosi:
METHODS <nomemetodo> FOR EVENT <nomeevento> OF <nomeclasse o interfaccia> IMPORTING ..<e>
Per i class-method vale la stessa dichiarazione.
Per legare a livello di programma il metodo chiamato con listanza della classe in cui e contenuto levento si usa
listruzione:
SET HANDLER <nomemetodochiamatodaevento> FOR <nomevarclasse>
In alternativa si puo usare .FOR ALL INSTANCES
Per gli eventi statici non si deve usare FOR..

*---------------------------------------------------------------------------------------------------------------------------------------------------*
esempi:
bisogna creare un oggetto che incrementa una varibiale sommandolo ad un valore impostato in un attributo
dichiarazione classe

CLASS contatore DEFINITION.


PUBLIC SECTION.
Data: incrementatore type n
METHODS somma importing numero type n
Exporting numeroinc type n.
ENDCLASS.
Implementazione metodo
CLASS contatore IMPLEMENTATION.
METHOD somma.
Numeroinc = numero + incrementatore.
ENDMETHOD.
ENDCLASS.
Codice nel programma
Type: classe TYPE REF TO contatore.
definisco il tipo alla classe
Data: var type classe.
creo listanza(riferimento)
Start-of-selection.
CREATE OBJECT var.
Var->incrementatore = 5
do valore allattributo pubblico
Call method var->somma exporting numero = 3
Importing numeroinc = numeronuovo

*--------------------------------------------------------------------------------------------------------------------*
Si vuole creare anche una nuova classe simile alla prima che pero decrementa e si usera uninterfaccia per accedere ad
entrambe.
INTERFACE operazioni DEFINITION.
Data: incrementatore type n.
Methods: operazione importing numero type n
Exporting numeronuovo type n.
ENDINTERFACE.
CLASS contatore DEFINITION.
INTERFACES operazioni.
ENDCLASS.
CLASS contatore2 DEFINITION.
INTERFACES operazioni.
ENDCLASS.
CLASS contatore IMPLEMENTATION.
METHOD operazioni~operazione.
Numeronuovo = numero + incrementatore.
ENDMETHOD.
ENDCLASS.
CLASS contatore2 IMPLEMENTATION.

METHOD operazioni~operazione.
Numeronuovo = numero incrementatore.
ENDMETHOD.
ENDCLASS.
Nel programma
Data: interfaccia type ref to operazioni.
Data: conta1 type ref to contatore
Data: conta2 type ref to contatore2
Start-of-selection.
CREATE OBJECT conta1,conta2.
Interfaccia = conta1 associo linterfaccia alla prima classe
Interfaccia->incrementatore = 5
Call method Interfaccia->operazioni exporting numero = 3
Importing numeronuovo = numeronuovo. numero nuovo sara uguale a 8
Interfaccia = conta2 associo linterfaccia alla seconda classe
Interfaccia->incrementatore = 3
Call method Interfaccia->operazioni exporting numero = 5
Importing numeronuovo = numeronuovo. numero nuovo sara uguale a 2

*-----------------------------------------------------------------------------------------------------------------------*
Adesso voglio che nel momento in cui lancio il metodo somma si attvi un metodo di unaltra classe che faccia la
sottrazione.
CLASS contatore DEFINITION.
PUBLIC SECTION.
Data: incrementatore type n
EVENTS lancio EXPORTING value(numero) type n.
METHODS somma importing numero type n
Exporting numeroinc type n.
ENDCLASS.
CLASS contatore IMPLEMENTATION.
METHOD somma.
Numeroinc = numero + incrementatore.
RAISE EVENT lancio EXPORTING numero = numeroinc
ENDMETHOD.
ENDCLASS.
CLASS contatore1 DEFINITION.
PUBLIC SECTION.
Data: numerofinale type n.
METHODS sottrazione FOR EVENT lancio OF contatore IMPORTING numero. il tipo di numero dipende dal tipo
dichiarato nella dichiarazione dellevento.

PRIVATE SECTION.
Data: valore type n.
ENDCLASS.
CLASS contatore1 IMPLEMENTATION.
METHOD sottrazione.
Valore = 1.
Numerofinale = numero valore.
ENDMETHOD.
ENDCLASS.
Nel programma
Data: conta1 type ref of contatore.
Data: conta2 type ref of contatore1.
Start-of-selection.
CREATE OBJECT: conta1,conta2.
SET HANDLER conta2->sottrazione FOR ALL INSTANCES.
Conta1->incrementatore = 5
Call method somma exporting numero = 3 importing numeroinc = numero.
*----a questo punto scatta levento e il metodo ad esso associato
write: contatore1->numerofinale. numerofinale sara uguale a 8 1 = 7
*--------------------------------------------------------------------------------------------------------------------*

Per creare oggetti globali si deve usare il class builder

Uso delle tabelle interne negli oggetti


Nella creazione di classi non e possibile usare occurs per la creazione di tabelle interne.
La sintassi corretta per la dichiarazione:
TYPES | DATA: BEGIN OF line_type,
...
fi ...,
...
END OF line_type.
TYPES itab TYPE | LIKE STANDARD TABLE OF line_type
WITH NON-UNIQUE DEFAULT KEY
[INITIAL SIZE n].
DATA itab TYPE | LIKE [STANDARD] TABLE OF line_type
[INITIAL SIZE n].
oppure
DATA itab TYPE | LIKE TABLE of line_type.

Lestensione header line non e usata , infatti gli oggetti non accettano tabelle con header line
Queste operazioni non vengon supportate dagli oggetti:
INSERT TABLE itab.
COLLECT itab.
READ TABLE itab ...
MODIFY TABLE itab ...
MODIFY itab ... WHERE ...
DELETE TABLE itab.
LOOP AT itab ...
Operations for index tables
APPEND itab.
INSERT itab ...
MODIFY itab ...
Ma vanno sostituite da:
INSERT wa INTO TABLE itab.
COLLECT wa INTO itab.
READ TABLE itab ... INTO wa ASSIGNING <fs>.
MODIFY TABLE itab FROM wa ...
MODIFY itab FROM wa ... WHERE ...
DELETE TABLE itab FROM wa.
LOOP AT itab INTO wa ... ASSIGNING <fs> ...

Operations for index tables


APPEND wa TO itab.
INSERT wa INTO itab ...
MODIFY itab FROM wa ...
Dove wa e unarea di lavoro che sostituisce lheader line (es wa(255). ) in alternativa si puo usare un field-simbols
Per usare gli eventi at new at last.ecc larea di lavoro deve essere dichiarata like alla tabella interna.
I range non sono permessi
Nella chiamata di un metodo il tipo di una tabella di dichiara con type table.
*-----------------------------------------------------------------------------------------------------------------------*
NOTE per il class builder .
1- Non e possibile modificare il sorgente delle parti pubbliche della classe nella definition.
2- I metodi con eventi vanno ,per il motivo di cui sopra , definiti come protected o private per poi modificare la loro
definizione aggiungendo for event da codice e poi dargli di nuovo la public come visibilita.
3- Si usa type anche per i modelli di struttura da dictionary.
4- Per definire attributi o parametri tabella interna e meglio creare un type-pool in cui venga definito un tipo tabella interna
(vedi sopra) , per poi usarlo nella classe (in generale e meglio usarlo per tutti gli attributi). In alternativa usare il tipo
generico TABLE.
5- Il metodo constructor viene eseguito subito dopo la create object
6- Il class constructor e eseguito subito prima della create object
7- Non e possibile usare negli oggetti strutture di tipo range