CA-Visual Objects

Subsistemul OOP

Acest material este o continuare a articolului despre mecanismele automate din CA-Visual Objects. Se presupune, că cititorul a avut contact cu un limbaj orientat obiect, măcar la nivelul obiectelor limbajului CA-Clipper.

În mare parte, subsistemul OOP al limbajului CA-Visual Objects se conformează standardului în cea ce priveşte, în general, limbajele orientate obiect. Totuşi - parţial datorat prezenţei unui depozit de date active - există anumite diferenţe de implementare. Pe lângă aceste diferenţe, mai puţin importante, CA-Visual Objects oferă o serie de noutăţi excitante şi soluţii elegante, care nu pot fi regăsite la alte limbaje. Cei doi factori, prezenţa depozitului activ de date, respectiv noutăţile prezente fac din CA-Visual Objects un limbaj promiţător.

Merită menţionat, de la început, că entitătile din CA-Visual Objects nu sunt delimitate de clauze de tipul BEGIN - END sau FUNCTION - RETURN. Entitătile sunt păstrate independent în depozitul de date al mediului (repository) -aceasta are implicaţia interesantă, pe de o parte că secventialitatea entităţilor nu are nici o importanţă, pe de altă parte o entitate pur şi simplu se termină acolo, unde începe o nouă entitate...

Noţiuni de bază

În CA-Visual Objects sunt prezente diverse clase predefinite care pot fi utilizate direct, dar şi programatorului i se permite definirea claselor proprii. În acest sens, sunt disponibile toate mecanismele obişnuite şi chiar şi facilităţi noi în privinţa mecanismelor orientate obiect.

Declararea unei clase
O clasă este o colecţie a obiectelor similare. Compilatorul trebuie să deţină informaţii asupra obiectelor cu care programele vor opera. (Evident, se poate închipui un sistem, care să manevreze cu definiţii de clase în runtime...) Ca urmare, clasele într-un mod sau altul trebuie declarate. Comanda pentru a declara o clasă utilizator este

class MyClass

Clasa astfel declarată este cea mai simplă clasă, deoarece un obiect al acestei clase nu are nici atribute (numite variabile de instantă), nici rutine de servicii sau acţiuni asociate (numite metode).

O clasă sau o declaraţie singuratică de clasă nu are nici o utilitate, deoarece aşa cum este nu poate să facă nimic; este doar o definiţie a proprietătilor pe care le-ar avea un obiect al clasei, şi comportamentul lui - dacă acest obiect ar exista...

Diferenţa între o clasă şi un obiect este critică: pe când obiectul există în spatiu şi în timp, clasa este o definiţie abstractă, o reţetă sau un plan de a construi obiectul respectiv. Puţin simplificat , o clasă există în timpul compilării, şi obiectele doar în timpul execuţiei programului.

Instanţierea obiectelor

Comanda executabilă de creare a unui obiect, sau a unei instanţe a unei clase, se dă prin numele clasei, urmat de acolade ({}). În contextul exemplului precedent:

MyClass{}

Ca urmare a acestei comenzi executabile, sistemul va crea un obiect, un exemplar al clasei MyClass. Se poate testa tipul rezultatului returnat, folosind funcţia ValType().

? ValType( MyClass{} ) // "O" de la Obiect

Obiecte ale claselor predefinite pot fi instanţiate exact la fel, doar că nu se declară clasele respective - declaraţia lor se găseşte în diverse biblioteci.

În anumite situaţii, obiectele create conform exemplului precedent sunt utile prin efectele laterale ale procesului de creare. Dacă în viitor se doreşte accesarea obiectului creat, este nevoie de un mecanism prin care se asigură regăsirea obiectului respectiv.

Implementare referenţială

Ca şi rezultat al instanţierii unei clase, sistemul returnează o referinţă la obiectul creat; această valoare (referinţă) poate fi păstrată într-o variabilă. Operatiile pe obiecte se pot face numai prin variabile, care conţin o referinţă la obiectul respectiv.

oObiect := MyClass{}

Valoarea referinţei este o valoare totalmente obişnuită, este de tipul „O“ (de la Object), ea poate fi atribuită unei variabile, transmisă unei funcţii ca şi parametru, sau returnată de aceasta.

Fără să intrăm în detalii, propun studierea următoarei secvenţe de cod dat, pentru exemplificarea caracterului referenţial:

local oOne, oTwo

oOne := MyClass{}
 	  oTwo := MyClass{}
 	  ? oOne == oTwo // afiseaza FALSE
 	  oTwo := oOne
 	  ? oOne == oTwo // afiseaza TRUE
 	  oTwo:MyExportVar := 10
 	  ? oOne:MyExportVar // afiseaza 10

Tipizarea variabilelor

Din motive de productivitate şi eficienţă, CA-Visual Objects suportă atât variabile netipizate, cât şi variabile strict tipizate. (Parantezele drepte încadrează clauze opţionale.)

local oObiect [as usual]

Linia de mai sus declară o variabilă locală de tip nedefinit sau polimorfă. Compilatorul nu verifică şi nu restricţionează sub nici o formă tipul valorilor care pot fi păstrate în variabile polimorfe.

CA-Visual Objects oferă posibilitatea tipizării statice a variabilelor. În acest context, cuvântul static nu se referă la delimitarea vizibilitătii, ci la restricţionarea definitivă doar la un singur tip a valorilor care pot fi păstrate în variabila respectivă.
Conform sintaxei de definire a funcţiilor, argumentele acestuia urmează aceleaşi reguli de tipizare ca şi variabilele în general.

Variabilele utilizate, indiferent de valabilitatea lor, pot fi deci strict tipizate.

local oObiect as

Pe lângă tipurile de bază ale limbajului (SYMBOL; INT, FLOAT, SHORT, LONG, BYTE, WORD, DWORD, REAL4, REAL8; DATE; LOGIC; VOID; PTR, PSZ, AS , AS PTR) ca şi tip se acceptă şi numele unei structuri sau - cea ce este important în acest context - şi numele unei clase. Bibliografia citată (Edward Yourdon, Object-Oriented Systems Design - An Integrated Approach, [Prentice Hall, 1992] pag. 5) sintetizând ceea ce este comun la autorii diverselor cărţi, defineşte noţiunea de clasă sau tipul obiectelor ca şi sinonime pentru setul de obiecte cu caracteristici identice (aceleaşi atribute descriptive şi acelaşi comportament). În acest mod, practic „se extinde“ limbajul, creând noi tipuri.

Tipul OBJECT este un tip de bază predefinit.

local oObiect as object

Prin această comandă, se declară o variabilă, care poate păstra valori de tip OBJECT. Orice altă tentativă de atribuire se va solda cu eroare.

class MyClass1
 	  class MyClass2

function Start
 	  local oObiect1, oObiect2 as 
 	  object
 	  oObiect1 := MyClass1{}
 	  oObiect2 := MyClass2{}
 	  oObiect1 := 4 // eroare de com
 	  pilare
 	  Process(oObiect2) // acceptat

function Process(oObj as object)
 	  ...

Problema este că, în acest fel, compilatorul nu va fi capabil să verifice cu exactitate clasa. Nivelul următor de severitate în declararea tipului se poate regăsi în exemplul de mai jos:

class MyClass1
 	  class MyClass2

function Start
 	  local oObiect1 as MyClass1
 	  local oObiect2 as MyClass2

 oObiect1 := MyClass1{}
 	  oObiect2 := MyClass2{}
 	  oObiect1 := oObiect2 // eroare 
 	  de compilare
 	  Process(oObiect2) // eroare 
 	  de compilare

function Process1(oObj as 
 	  MyClass1)
 	  ...

Folosind o tipizare strictă, indiferent de nivelul de severitate, aceasta oferă nu numai un cod mai rapid, dar şi posibilitatea eliminării unor erori latente, deja din timpul compilării.

function Process(oObj as object)

Bineînţeles, şi varianta mai slab tipizată are avantajele ei: în acest mod se permite definirea unui cod polimorf, care de exemplu poate prelucra obiectele diverselor clase.

 Process( MyClass1{} )
 	  Process( MyClass2{} )

În concluzie, se poate lucra cu următoarele feluri de variabile:
• variabile netipizate sau polimorfe (AS USUAL)
• variabile strict tipizate (AS )

Tipizarea variabilelor, care vor conţine referinţe la obiecte, poate fi făcută cu diverse grade de libertate:
• netipizat, sau declarat polimorf (AS USUAL)
• tipizat static ca şi obiect în general (AS OBJECT)
• tipizat static corespunzător clasei (AS )

Subclasarea sau specializarea

În ideea refolosirii componentelor, una din proprietătile de importanţă deosebită a limbajului este posibilitatea definirii unei clase, bazată pe definiţia unei alte clase. În acest caz, clasele copil moştenesc toate atributele şi comportamentul de la clasa părinte. Prin această tehnică, este posibilă extinderea unei clase, fără perturbarea funcţionalităţii.

class MyClass
 	  class MyClass1 inherit MyClass
 	  class MyClass2 inherit MyClass

Variabilele de instanţă

Proprietăţile, atributele unui obiect se materializează în structuri de date de o complexitate oarecare. Fiecare exemplar (instanţă) al clasei la crearea ei „primeşte“ o copie a întregului set de variabile. Declararea acestor variabile, adică a variabilelor de instanţă se face la nivelul clasei, dar în acel moment (la compilare) reprezintă doar „şablonul“ după care se vor crea obiectele clasei respective.

class MyClass
 	  instance nVarNumerica [as ]

Variabilele de instanţă se conformează aceloraşi reguli de tipizare ca şi toate variabilele: pot fi polimorfe, sau - folosind clauza opţională AS - pot fi şi tipizate static (tip clasic sau tip extins, prin numele unei structuri de date - structure, union, sau prin numele unei clase).

Valoare iniţială a variabilelor de instanţă
Ca şi la variabilele obişnuite, se permite iniţializarea şi a variabilelor de instanţă deja la definirea lor, cu observaţia că, în acest scop, se pot folosi doar valori simple (deci de exemplu nu se poate iniţializa cu valori de tipul OBJECT).

class MyClass
 	  instance nVarNumerica := 0 as short

Variabilele tipizate, la crearea lor, automat se iniţializează la valoarea nulă a tipului respectiv (NULL_ARRAY, NULL_CODEBLOCK, NULL_DATE, FALSE, NULL_OBJECT, NULL_STRING, NULL_SYMBOL, 0, NULL_PSZ, NULL_PTR); dacă variabila este polimorfă (AS USUAL), valoarea de iniţializare este NIL (NIL este o valoare fără tip, în contrast cu VOID, care este un tip fără valori)

Valabilitatea şi vizibilitatea variabilelor de instanţă
Luând în considerare principiile încapsulării, capitolul privind vizibilitatea variabilelor de instanţă primeşte o importanţă deosebită.

Valabilitatea variabilelor de instanţă este strict legată de valabilitatea obiectului din care fac parte, dar vizibilitatea lor este determinată de modificatorul aplicat la declararea lor.

[protect|hidden|export] 
[instance]  [as ]

Vizibilitatea variabilelor de instanţă din CA-Visual Objects se conformează tabelului următor:

Exterior
 	  în Clasă
 	  în Subclase
 	  EXPORT 
 	  (
 	  (
 	  (
 	  PROTECT
 	  (
 	  (
 	  HIDDEN
 	  (
 	  INSTANCE
 	  )
 	  )))))

Deoarece diverse obiecte ale aceleiaşi clase (sau al unei alte clase) au inevitabil variabile de instanţă cu acelaşi nume, nu este suficientă specificarea numelui variabilei de instanţă. Pentru a înlătura nesiguranţa la referirea unei variabile de instanţă, este nevoie şi de specificarea obiectului de care aparţine variabila. Pentru a referi o variabilă de instanţă se foloseşte operatorul send (:).

class MyClass
 	  export MyExportVar as int

function Start
 	  local oOne, oTwo as MyClass

oOne := MyClass{}
 	  oTwo := MyClass{}

oOne:MyExportVar := 10
 	  oTwo:MyExportVar := 49

? oOne:MyExportVar // afiseaza 10

Variabilele de instanţă exportate fac parte din interfaţa publică a obiectelor, reflectă starea reală a acestora. Variabilele EXPORT care sunt deci vizibile codului exterior clasei violează principiul încapsulării, deoarece permit acces necontrolat la atributele obiectelor. Ca urmare, vom reveni cu o soluţie la această problemă după o scurtă introducere a folosirii metodelor...

Metode

Comportamentul, serviciile specifice unei clase se materializează într-un grup de funcţii sau aşa-zise metode, care sunt strict legate de clasa respectivă.

O metodă conform definiţiei din CA-Visual Objects este codul unei singure acţiuni în comportamentul obiectului; în general, metodele sunt ca şi funcţiile (au parametri, conţin declaraţii şi instrucţiuni, comenzi şi valori returnate), cu anumite diferenţe:
• sunt definite în contextul unei clase
• în timpul execuţiei metodele „cunosc“, adică posedă informatii despre clasa de care aparţin, şi pot accesa metodele şi variabilele de instanţă proprii şi moştenite ale clasei.
• implicit o metodă returnează o referintă la obiectul însuşi (vezi cuvântul cheie special SELF)

Definirea metodelor
Metodele unei clase se definesc similar cu funcţiile. Diferenţa evidentă la prima vedere este prezenţa unei clauze suplimentare în prima linie a definiţiei, clauză care se referă la clasa de care aparţine metoda.

method MyMethod() 
 	  class MyClass

Corpul metodei poate conţine şi una sau mai multe comenzi RETURN [], a cărei prezenţă nu este necesară sau obligatorie.

Invocarea metodelor
Sistemul folosit pentru invocarea metodelor este sistemul mesajelor. Pentru a invoca o metodă a unui obiect (de fapt o metodă care este ataşată clasei, pentru o instanţă a clasei), se trimite un mesaj obiectului, folosind uzual operatorul send (:), precum şi numele metodei, urmat de paranteze rotunde - încuibând o eventuală listă a parametrilor actuali.

// :([])

class MyClass

method Music() class MyClass
 	  Tone(440,5)
 	  function Start
 	  local oOne := MyClass{}
 	  oOne:Music()

La recepţionarea unui mesaj, se execută metoda cu acelaşi nume - dacă aceasta există. Invocarea unei metode prin sistemul de mesaje este similară apelării unei funcţii sau a unei subrutine.

Referinţe la obiectul curent
În cadrul unei metode, se poate referi obiectul curent pentru care s-a invocat metoda, prin cuvântul cheie SELF.

class MyClass

method MyMethod1 class MyClass
 	  ? "Sunt in prima metoda"
 	  MyMethod2() // 1
 	  self:MyMethod2() // 2

method MyMethod2 class MyClass
 	  Qout("Sunt in a doua metoda") // 3

Linia marcată cu 1 este eronată, deoarece - vezi liniile 1 şi 3 - apelul unei metode se poate confunda cu apel de funcţie. Soluţia este folosirea unei referinţe la obiectul curent SELF şi a operatorului send (:) pentru a înlătura nesiguranţa - vezi linia 2.

Merită făcută observaţia, că limbajul este consecvent în modul de invocare al funcţiilor şi metodelor: funcţiile se apelează totdeauna prin simplul nume, iar metodele folosind o valoare de tip referinţă (variabilă sau SELF), operatorul send şi numele metodei.

Valoarea returnată
Dacă nu se defineşte printr-o comandă explicită RETURN [], atunci prin definiţie metodele returnează implicit valoarea SELF. În acest fel, este posibilă o înlănţuire, în aceeaşi comandă, a mai multor apeluri de metode:

oWindow:Line(oP1, oP2):Draw()

Vizibilitatea metodelor
Metodele unei clase sunt vizibile atât din afara clasei, cât şi din celelalte metode ale clasei. Vizibilitatea, în general, determină din ce context cum pot fi invocate metodele. Vizibilitatea normală implică că toate metodele pot fi apelate din clasă şi toate subclasele acesteia, precum şi din modulele exterioare clasei.

Există două cuvinte cheie care pot fi folosite pentru a modifica vizibilitatea metodelor: PROTECT şi HIDDEN. Metodele protejate sunt vizibile din clasa curentă şi subclasele ei, iar cele ascunse doar din clasa pentru care s-a definit metoda.

Metode tipizate

Începând cu versiunea 2.0 CA-Visual Objects permite definirea şi a metodelor strict tipizate. Metodele tipizate - cu totul, că flexibilitatea lor este mult mai mică, sunt utile deoarece prin folosirea lor se obţine un cod mult mai stabil şi mai rapid (legarea metodelor poate fi făcută timpurie, deja în timpul compilării).

Pentru a declara metodele tipizate, se foloseşte clauza opţională DECLARE a definiţiei de clasă:

declare method

Definiţia metodei se extinde cu specificarea tipului returnat, şi a convenţiei de apel, ca şi la funcţii. (Datorită caracterului hibrid al limbajului, sunt prezente mai multe posibilităti de a declara modul de apel al funcţiilor şi procedurilor. CALLBACK respectă convenţia Windows, PASCAL asigură eficienţă prin rigiditatea ei, respectiv CLIPPER oferă flexibilitatea obişnuită la limbajele Xbase.)

class MyClass
 	  declare method TypedMusic

method TypedTone(wFreq as word, wDur as word) 
 	      as MyClass pascal
 	      Tone(wFreq, wDur)
 	  return self

method UntypedTone(wFreq, wDur)
 	      Tone(wFreq, wDur)
 	  return self

Avantajul variantei tipizate este viteza mai mare, respectiv siguranţa, corectitudinea mărită a codului, faţă de flexibilitatea superioară a metodelor netipizate.

Metoda Init()
În limbajul CA-Visual Objects nu există o metodă specială predefinită sau definită de utilizator, de tip constructor. Alocarea memoriei necesare se face automat de sistem, programatorului i se oferă „doar“ posibilitatea definirii unei metode speciale Init(), care - dacă este definită - se invocă automat, imediat după crearea obiectului. Automat se transmit, ca şi parametrii de apel ai metodei Init(), argumentele operatorului de instanţiere.

class MyClass

method Init(arg1, arg2) class 
 	      MyClass
 	  ? arg1, arg2

function Start()
 	  local oMyClass as MyClass
 	  oMyClass := MyClass{440, 20}
 	  // se tipareste 440, 20

De obicei, metoda Init() este folosită la executarea unor iniţializări (de exemplu, la setarea unor valori implicite pentru variabilele de instanţă sau alocarea unor resurse - ca şi deschiderea unui fişier - necesare funcţionării obiectului).

Metoda Axit()
Controlul asupra procesului de creare a obiectelor este preluat de CA-Visual Objects, dar cum am mai precizat, definind o metodă cu numele Init(), utilizatorul poate executa funcţii de iniţializare sau alocare de resurse, imediat după crearea obiectului. Similar, procesul de distrugere a obiectelor în mod normal este controlat de sistem, dar utilizatorul primeşte dreptul de a executa anumite operaţiuni, înainte de distrugerea obiectului în cauză.

De remarcat este, conform filozofiei CA-Visual Objects, că timpul de viaţă al unui obiect este strâns legat de posibilitatea de referenţiere a ei. Adică, până când există o variabilă prin care obiectul poate fi referit, el există, dar odată cu dispariţia tuturor referinţelor asupra ei, obiectul este osândit distrugerii. Acest proces de distrugere este executat de un mecanism automat de colectare a reziduurilor.

Dacă utilizatorul defineşte metoda Axit(), aceasta este invocată automat, înainte de distrugerea obiectului.

class DBServer
 	  PROTECT cAlias as STRING

method Init(cFileName) class 
 	  DBServer
 	  cAlias := cFileName
 	  use (cAlias) new

method Axit() class DBServer
 	  (cAlias)->(dbCloseArea())

Extinderea funcţionalităţii unei clase

Cum am mai discutat, obiectele au o parte statică - care se reflectă prin structură, prin relaţii şi atribute; şi o parte dinamică - oglindită prin comportament, sau mesaje şi servicii (sinonimă: metode).

„Fiecare obiect are o interfaţă bine definită, care determină care sunt stimulii care sunt acceptaţi de obiect, adică ce operaţii pot fi efectuate asupra obiectelor. (...) Fiecare stimul cauzează executarea unei operaţii, sau accesează direct o variabilă de instanţă.“

Folosind mecanismul subclasării, se asigură moştenirea structurii şi comportamentului clasei părinte de către clasele copil.

Funcţionalitatea noii clase se poate extinde prin
• definirea de noi variabile de instanţă (reale sau virtuale)
• definirea unor metode noi
• extinderea funcţionalităţii metodelor existente.

Variabilele virtuale

Din exteriorul unei clase doar variabilele de instanţă EXPORT sunt vizibile, celelalte variabile interne sau neexportate sunt neaccesibile din funcţii sau metode externe clasei. Pentru a accesa variabilele interne se pot folosi metode. Aceasta corespunde principiului încapsulării, dar este o soluţie incomodă.

class Employee
 	  export Name
 	  protect Salary

method SetSalary(x) class Employee
 	  if self:ValidSalary(x) // Vali
 	        darea valorii
 	      return (Salary := x)
 	  else
 	      self:Error(...)
 	      return nil
 	  endif

method GetSalary() class Employee
 	  return Salary
 	  ...
 	  oEmp := Employee{}
 	  oEmp:Name := "Jones"
 	  oEmp:SetSalary(10000) // Sin
 	  taxa diferita!
 	  ? oEmp:Name
 	  ? oEmp:GetSalary() // Sin
 	  taxa diferita!

O soluţie mult mai elegantă - şi extrem de flexibilă - este oferită de metodele speciale ACCESS şi ASSIGN. Aceste metode se folosesc la implementarea variabilelor de instanţă virtuale, care de fapt simulează prin intermediul metodelor ACCESS şi ASSIGN o variabilă de instanţă „obişnuită“.

Sintaxa pentru accesarea, respectiv pentru asignarea acestor variabile virtuale este aceeaşi ca şi pentru o variabilă reală - singura diferenţă este că accesul prin acest mod devine controlat.

class Employee
 	  export Name
 	  protect Salary

assign Salary(x) class Employee
 	  if self:ValidSalary(x) // Vali
 	        darea asignarii
 	      return (Salary := x)
 	  else
 	      self:Error(...)
 	      return nil
 	  endif

access Salary() class Employee
 	  return Salary
 	  ...
 	  oEmp := Employee{}
 	  oEmp:Name := "Jones"
 	  oEmp:Salary := 10000 // Nu exista nici o
 	  ? oEmp:Name // diferenta la asignare
 	  ? oEmp:Salary // sau referentiere

Cum se observă, se pot defini fără nici o restricţie sau obligativitate metode ACCESS şi ASSIGN cu acelaşi nume ca şi variabila de instanţă la care au rolul de a controla accesul.

Variabilele calculate

Dat fiind faptul că nu se impune ca să existe o variabilă concretă care să stea „în spatele“ metodelor de acces şi asignare, se pot defini metode speciale care implementează variabile virtuale read-only, write-only, sau read-write; aceste variabile sunt vizibile doar, sau dacă doriţi, există prin intermediul acestor metode speciale.

class Meeting
 	  protect cPerson as string
 	  protect dDate as date
 	  // Variabile virtuale
 	  //Data - R/W
 	  //Zi, Luna, An - R/O

method Init(nume_persoana) class Meeting
 	  self:cPerson := nume_persoana

assign Data(data_intilnire) class Meeting
 	  if (data_intilnire := Today())
 	      self:dDate := data_intilnire
 	  else // eroare
 	  endif

access Data class Meeting
 	  return self:dDate

access Zi class Meeting
 	  return Day(self:dDate)

access Luna class Meeting
 	  return Month(self:dDate)

access An class Meeting
 	  return Year(self:dDate)
 	  ...
 	  oMeeting := Meeting{}
 	  oMeeting:Data := 1997.10.14
 	  ? oMeeting:Zi // 14
 	  ? oMeeting:Year // 1997

Referinţa la superclasă

Cuvântul cheie SUPER serveşte la referirea predecesorului direct al unei clase. Prin acest cuvânt cheie, este posibilă referirea metodelor şi a variabilelor de instanţă vizibile ale superclasei (sau a părintelui).

Extinderea funcţionalităţii metodelor

Dacă pentru o subclasă se defineşte o metodă cu un nume, care se suprapune cu denumirea unei metode a părintelui, pentru obiectele subclasei la un apel se va identifica şi executa noua metodă. Practic noua metodă înlocuieşte vechea metodă a superclasei. Prin aceasta, funcţionalitatea clasei se modifică.

class MyParentClass
 	  method DoSomething() class MyParentClass
 	  ? "Face ceva cu MyParentClass."

class MyClass inherit MyParentClassmethod 
     DoSomething class MyClass
 	  ? "Face ceva cu MyClass."

function Start
 	  local oMyClass as MyClass
 	  oMyClass := oMyClass{}
 	  oMyClass:DoSomething()
 	  // Face ceva cu MyClass.

Sunt situaţii, când se doreşte - fără perturbarea funcţionalităţii - o extindere a metodei redefinite. Pentru aceasta, nu este necesară cunoaşterea structurii clasei-părinte: folosind cuvântul cheie SUPER, se poate executa şi metoda superclasei.

class MyParentClass
 	  method DoSomething() class MyParentClass
 	  ? "Face ceva cu MyParentClass."

class MyClass inherit MyParentClass
 	  method DoSomething class MyClass
 	  super:DoSomething()
 	  ? "Face ceva cu MyClass."

function Start
 	  local oMyClass as MyClass
 	  oMyClass := oMyClass{}
 	  oMyClass:DoSomething()
 	  // Face ceva cu MyParentClass.
 	  // Face ceva cu MyClass.

Folosirea acestei tehnici este singura posibilitate de a extinde funcţionalitatea unei metode la o subclasă.

Exemplu clasic este metoda specială Init(), care trebuie să execute anumite iniţializări la nivelul clasei curente - fără ca să se cunoască structura sau „nevoile“ superclasei.

class MyCild inherit MyParent
 	  // Structura lui MyParent nu este cunoscuta
 	  method Init(arg_list) class 
 	  MyChild
 	  super:Init(arg_list) // Init() al clasei MyParent
 	   // cod specific clasei MyChild

Metodele NoIVarGet(), NoIVarPut() şi NoMethod()

Pentru a detecta mesajele la care în mod direct nu poate răspunde clasa, sunt dedicate trei metode. În funcţie de sintaxa prin care se trimite mesajul obiectului, se invocă metoda corespunzătoare.

NoIVarGet() se apelează la referirea pentru citire (operatia get) a unei variabile de instanţă inexistentă conform sintaxei :

NoIVarPut() se apelează la referirea pentru atribuire (operatia put) a unei variabile de instanţă inexistentă conform sintaxei : :=

NoMethod() se apelează la receptionarea de către un obiect a unei mesaj pentru care nu există metoda corespunzătoare, conform sintaxei :([])

Ideea de bază este ca, în cazul în care obiectul primeşte un mesaj pe care mecanismul automat nu îl poate controla direct, să nu se „anunţe“ direct sistemul de erori, ci să fie apelat un mecanism care poate decide comportamentul obiectului în cauză.

Obiecte cu interfaţă dinamică

O utilizare deosebit de interesantă a acestei tehnici, specifice limbajului CA-Visual Objects, este posibilitatea creării obiectelor care sunt capabile să-şi „modifice“ structura sau comportamentul în runtime.

Ca şi exemplu de valoare clasică, se poate prezenta problema reflectării structurii unei baze de date (.DBF) în obiectul de interfaţă, să o numim DBServer - în cazul în care structura fişierului de date nu este în prealabil cunoscută.

class DBServer
 	  protect cAlias as string

method Init(cFileName, AliasName) 
 	  class DBFServer
 	  use (cFileName) alias (Alias
 	  Name) new
 	  self:cAlias := AliasName

method NoIVarGet(SymName) class 
 	  DBFServer
 	  local symAlias as symbol
 	  symAlias := String2Symbol(cAlias)
 	  return FieldGetAlias(symAlias, 
 	  SymName)

method NoIVarPut(SymName,uValue) 
 	  class DBFServer
 	  local symAlias as symbol
 	  symAlias := 
 	  String2Symbol(cAlias)
 	  return FieldPutAlias(symAlias,Sym
 	  Name,uValue)

function Main()
 	  local oDBF as DBFServer
 	  oDBF := DBFServer{"\DEMO\ 
 	  TEST.DBF", "TEST"}
 	  ? oDBF:CIMP1, oDBF:CIMP2
 	  // citire
 	  oDBF:CIMP1 := "NetWorks Ltd." 
 	  // scriere

Operatori ca şi metode

O funcţionalitate extrem de interesantă, oferită de CA-Visual Objects, este posibilitatea extinderii elegante a sintaxei operatorilor folositi la tipuri de date simple şi pe clase (tipuri) definite de utilizator.

Operatorii care pot fi redefiniţi, respectiv corespondenţa dintre operatori şi metodele care joacă rolul operatoarelor este determinată intern.

Lista metodelor dublate prin operatori, care pot fi definite pentru orice clasă, este: Add(), Mul(), Sub(), Div(), Pow(), Gtr(), Less(), GtrEqu(), LessEqu(), Neg(), Not()

În fond, pentru operatorii redefiniţi se vor apela pur şi simplu metodele corespunzătoare. Avantajul major al acestei tehnici este că acest apel se va face conform sintaxei operatorilor.

class Complex
 	  export re as float
 	  export im as float

method Init(fReal, fImaginar) 
 	  class Complex
 	  self:re := fReal
 	  self:im := fImaginar

method Add(b) class Complex 
 	  // redefineste +
 	  local z as COMPLEX
 	  z := Complex{SELF:re+b:re, 
 	  SELF:im+b:im}
 	  return z

function Start()
 	  local z1, z2, z3 as COMPLEX
 	  z1 := Complex{1, -2}
 	  z2 := Complex{1, 3.5}
 	  z3 := z1 + z2
 	  ? z3:im // afiseaza 1.5

Avantajul major al acestei tehnici este că se poate lucra mult mai natural cu obiecte, folosind sintaxa deja obişnuită a operatorilor pentru operaţii considerate clasice.

Informaţii de clase runtime

Interfaţa publică a unei clase poate fi interogată prin intermediul unor funcţii speciale. În cele ce urmează, prezentăm câteva categorii - însă fără dorinta să fim compleţi
• transmiterea mesajelor: Send(), SendClass(), asend(), ASendClass()
• informaţii despre clase: CheckInstanceOf(), ClassCount(), ClassList(), ClassName(), ClassTree(), ClassTreeClass(); IsAccess(), IsAssign(), IsClass(), IsInstanceOf(), IsInstanceOfUsual(), IsMethod(), IsMethodClass(), IsMethodUsual(), OOPTree(), OOPTreeClass()
• manipulare obiecte: CreateInstance(), Object2Array(), GetAppObject()
• prelucrarea variabilelor de instanţă: IVarGet(), IVarGetInfo(), IVarGetSelf(), IVarList(), IVarListClass(), IVarPut(), IVarPutInfo(), IVarPutSelf(), NoIVarGet(), NoIVarPut()
• prelucrări metode: MethodList(), MethodListClass(), NoMethod()

Domeniul fiind prea vast, în acest moment nu intenţionăm să intrăm în detalii.
Array-uri de obiecte

În cazul în care un vector conţine obiecte similare, acelaşi mesaj poate fi trimis la toate obiectele vectorului printr-o sintaxă foarte simplă:

local aChildWindows as ARRAY

Expresia

aChildWindows:Destroy()

este perfect echivalentă cu următoarea secvenţă de comenzi

 for i := 1 to Len(aChildWindows)
 	      aChildWindows[i]:Destroy() 
 	  next i

Concluzii

Subsistemul obiectual al limbajului CA-Visual Objects este robust şi comprehensiv. El se bazează pe sâmburele obiectual al limbajului CA-Clipper, şi ca urmare este o extensie naturală a unui limbaj Xbase, dedicat prelucrării bazelor de date. Eficient şi flexibil, este la fel de competitiv ca şi celelalte limbaje obiectuale populare. Dar CA-Visual Objects este caracterizat de simplitate şi de o eleganţă deosebită.

Subsistemul obiectual al CA-Visual Objects, împreună cu mecanismele automate şi serviciile oferite, îi conferă limbajului puterea necesară ca aceasta să poate aspira spre a deveni standard industrial.