Professional Documents
Culture Documents
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.
Oggetti ABAP
Gli oggetti abap sono completamente compatibili con le istruzioni convenzionali.
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:
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.
(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.
<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.
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.
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>.
*---------------------------------------------------------------------------------------------------------------------------------------------------*
esempi:
bisogna creare un oggetto che incrementa una varibiale sommandolo ad un valore impostato in un attributo
dichiarazione classe
*--------------------------------------------------------------------------------------------------------------------*
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
*--------------------------------------------------------------------------------------------------------------------*
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> ...