Capitolul V
5.1 Variabile

5.1.1 Declaraţii de variabile

5.1.1.1 Tipul unei variabile
5.1.1.2 Numele variabilelor
5.1.1.3 Iniţializarea variabilelor

5.1.2 Tipuri primitive

5.1.2.1 Tipul boolean
5.1.2.2 Tipul caracter
5.1.2.3 Tipuri întregi

5.1.2.3.1 Tipul octet
5.1.2.3.2 Tipul întreg scurt
5.1.2.3.3 Tipul întreg
5.1.2.3.4 Tipul întreg lung

5.1.2.4 Tipuri flotante

5.1.2.4.1 Tipul flotant
5.1.2.4.2 Tipul flotant dublu
5.1.2.4.3 Reali speciali definiţi de IEEE

5.1.3 Tipuri referinţă

5.1.3.1 Tipul referinţă către o clasă
5.1.3.2 Tipul referinţă către o interfaţă
5.1.3.3 Tipul referinţă către un tablou

5.1.4 Clasa de memorare

5.1.4.1 Variabile locale
5.1.4.2 Variabile statice
5.1.4.3 Variabile dinamice

5.1.5 Tablouri de variabile

5.1.5.1 Declaraţia variabilelor de tip tablou
5.1.5.2 Iniţializarea tablourilor.
5.1.5.3 Lungimea tablourilor
5.1.5.4 Referirea elementelor din tablou
5.1.5.5 Alocarea şi eliberarea tablourilor

5.1.6 Conversii

5.1.6.1 Conversii de extindere a valorii
5.1.6.2 Conversii de trunchiere a valorii
5.1.6.3 Conversii pe tipuri referinţă
5.1.6.4 Conversii la operaţia de atribuire
5.1.6.5 Conversii explicite
5.1.6.6 Conversii de promovare aritmetică

5.1.1 Declaraţii de variabile

O variabilă în limbajul Java este o locaţie de memorie care poate păstra o valoare de un anumit tip. În ciuda denumirii, există variabile care îşi pot modifica valoarea şi variabile care nu şi-o pot modifica, numite în Java variabile finale. Orice variabilă trebuie să fie declarată pentru a putea fi folosită. Această declaraţie trebuie să conţină un tip de valori care pot fi memorate în locaţia rezervată variabilei şi un nume pentru variabila declarată. În funcţie de locul în sursa programului în care a fost declarată

variabila, aceasta primeşte o clasă de memorare locală sau statică. Această clasă de memorare defineşte intervalul de existenţă al variabilei în timpul execuţiei.

În forma cea mai simplă, declaraţia unei variabile arată în felul următor:

Tip NumeVariabilă [, NumeVariabilă]*; 

5.1.1.1 Tipul unei variabile

Tipul unei variabile poate fi fie unul dintre tipurile primitive definite de limbajul Java fie o referinţă. Creatorii limbajului Java au avut grijă să

definească foarte exact care sunt caracteristicile fiecărui tip primitiv în parte şi care este setul de valori care se poate memora în variabilele care au tipuri primitive. În plus, a fost exact definită şi modalitatea de reprezentare a acestor tipuri primitive în memorie. În acest fel, variabilele Java devin independente de platforma hardware şi software pe care lucrează.

În acelaşi spirit, Java defineşte o valoare implicită pentru fiecare tip de dată, în cazul în care aceasta nu a primit nici o valoare de la utilizator. În acest fel, ştim întotdeauna care este valoarea cu care o variabilă intră în calcul. Este o practică bună însă aceea ca programele să nu depindă niciodată de aceste iniţializări implicite.

5.1.1.2 Numele variabilelor

Numele variabilei poate fi orice identificator Java. Convenţia nescrisă de formare a numelor variabilelor este aceea că orice variabilă care nu este finală are un nume care începe cu literă minusculă în timp ce

variabilele finale au nume care conţin numai majuscule. Dacă numele unei variabile care nu este finală conţine mai multe cuvinte, cuvintele începând cu cel de-al doilea se scriu cu litere minuscule dar cu prima literă majusculă. Exemple de nume de variabile care nu sunt finale ar putea fi:

culoarea numărulDePaşi următorulElement

Variabilele finale ar putea avea nume precum:

PORTOCALIUVERDEALBASTRUDESCHIS 

5.1.1.3 Iniţializarea variabilelor

Limbajul Java permite iniţializarea valorilor variabilelor chiar în momentul declarării acestora. Sintaxa este următoarea:

Tip NumeVariabilă = ValoareIniţială;

Desigur, valoarea iniţială trebuie să fie de acelaşi tip cu tipul variabilei sau să poată fi convertită într-o valoare de acest tip.

Deşi limbajul Java ne asigură că toate variabilele au o valoare iniţială bine precizată, este preferabil să executăm această iniţializare în mod explicit pentru fiecare declaraţie. În acest fel mărim claritatea propriului cod.

Regula ar fi deci următoarea: nici o declaraţie fără iniţializare.

5.1.2 Tipuri primitive

5.1.2.1 Tipul boolean

Tipul boolean este folosit pentru memorarea unei valori de adevăr. Pentru acest scop, sunt suficiente doar două valori: adevărat şi fals. În Java aceste două valori le vom nota prin literalii true şi respectiv false.

Aceste valori pot fi reprezentate în memorie folosindu-ne de o singură cifră binară, adică pe un bit.

Valorile booleene sunt foarte importante în limbajul Java pentru că ele sunt valorile care se folosesc în condiţiile care controlează instrucţiunile repetitive sau cele condiţionale. Pentru a exprima o condiţie este suficient să scriem o expresie al cărui rezultat este o valoare booleană, adevărat sau fals.

Valorile de tip boolean nu se pot transforma în valori de alt tip în mod nativ. La fel, nu există transformare nativă dinspre celelalte valori înspre tipul boolean. Cu alte cuvinte, având o variabilă de tip boolean nu putem memora în interiorul acesteia o valoare întreagă pentru că limbajul Java nu face pentru noi nici un fel de presupunere legată de ce înseamnă o anumită valoare întreagă din punctul de vedere al valorii de adevăr. La fel, dacă avem o variabilă întreagă, nu îi putem atribui o valoare de tip boolean.

Orice variabilă booleană nou creată primeşte automat valoarea implicită false. Putem modifica această comportare specificând în mod explicit o valoare iniţială true după modelul pe care îl vom descrie mai târziu.

Pentru a declara o variabilă de tip boolean, în Java vom folosi cuvântul rezervat boolean ca în exemplele de mai jos:

boolean terminat;
boolean areDreptate;

Rândurile de mai sus reprezintă declaraţia a două variabile de tip boolean numite terminatrespectiv areDreptate. Cele două variabile au, după declaraţie, valoarea false. Adică nu e terminat dar nici n-are dreptate.

5.1.2.2 Tipul caracter

Orice limbaj de programare ne oferă într-un fel sau altul posibilitatea de a lucra cu caractere grafice care să reprezinte litere, cifre, semne de punctuaţie, etc. În cazul limbajului Java acest lucru se poate face folosind tipul primitiv numit tip caracter.

O variabilă de tip caracter poate avea ca valoare coduri Unicode reprezentate pe 16 biţi, adică doi octeţi. Codurile reprezentabile astfel sunt foarte multe, putând acoperi caracterele de bază din toate limbile scrise existente.

În Java putem combina mai multe caractere pentru a forma cuvinte sau şiruri de caractere mai lungi. Totuşi, trebuie să precizăm că aceste şiruri de caractere nu trebuiesc confundate cu tablourile de caractere pentru că ele conţin în plus informaţii legate de lungimea şirului.

Codul nu este altceva decât o corespondenţă între numere şi caractere fapt care permite conversii între variabile întregi şi caractere în ambele sensuri. O parte din aceste transformări pot să altereze valoarea originală din cauza dimensiunilor diferite ale zonelor în care sunt memorate cele două tipuri de valori. Convertirea caracterelor în numere şi invers poate să fie utilă la prelucrarea în bloc a caracterelor, cum ar fi trecerea tuturor literelor minuscule în majuscule şi invers.

Atunci când declarăm un caracter fără să specificăm o valoare iniţială, el va primi automat ca valoare implicită caracterul nullal codului Unicode, \u0000?.

Pentru a declara o variabilă de tip caracter folosim cuvântul rezervat char ca în exemplele următoare:

char primaLiteră;
char prima, ultima;

În cele două linii de cod am declarat trei variabile de tip caracter care au fost automat iniţializate cu caracterul null. În continuare, vom folosi interschimbabil denumirea de tip caracter cu denumirea de tip char, care are avantajul că este mai aproape de declaraţiile Java.

5.1.2.3 Tipuri întregi

5.1.2.3.1 Tipul octet

Între tipurile întregi, acest tip ocupă un singur octet de memorie, adică opt cifre binare. Într-o variabilă de tip octet sunt reprezentate întotdeauna valori cu semn, ca de altfel în toate variabilele de tip întreg definite în limbajul Java. Această convenţie simplifică schema de tipuri primitive care, în cazul altor limbaje include separat tipuri întregi cu semn şi fără.

Fiind vorba de numere cu semn, este nevoie de o convenţie de reprezentare a semnului. Convenţia folosită de Java este reprezentarea în complement faţă de doi. Această reprezentare este de altfel folosită de majoritatea limbajelor actuale şi permite memorarea, pe 8 biţi a 256 de numere începând de la -128 până la 127. Dacă aveţi nevoie de numere mai mari în valoare absolută, apelaţi la alte tipuri întregi.

Valoarea implicită pentru o variabilă neiniţializată de tip octet este valoarea 0 reprezentată pe un octet.

Iată şi câteva exemple de declaraţii care folosesc cuvântul Java rezervat byte:

byte octet;
byte eleviPeClasa;

În continuare vom folosi interschimbabil denumirea de tip octet cu cea de tip byte.

5.1.2.3.2 Tipul întreg scurt

Tipul întreg scurt este similar cu tipul octet dar valorile sunt reprezentate pe doi octeţi, adică 16 biţi. La fel ca şi la tipul octet, valorile

sunt întotdeauna cu semn şi se foloseşte reprezentarea în complement faţă de doi. Valorile de întregi scurţi reprezentabile sunt de la -32768 la 32767 iar valoarea implicită este 0 reprezentat pe doi octeţi.

Pentru declararea variabilelor de tip întreg scurt în Java se foloseşte cuvântul rezervat short, ca în exemplele următoare:

short i, j;
short valoareNuPreaMare;

În continuare vom folosi interschimbabil denumirea de tip întreg scurt şi cea de tip short.

5.1.2.3.3 Tipul întreg

Singura diferenţă dintre tipul întreg şi tipurile precedente este faptul că valorile sunt reprezentate pe patru octeţi adică 32 biţi. Valorile reprezentabile sunt de la -2147483648 la 2147483647 valoarea implicită fiind 0. Cuvântul rezervat este int ca în:

int salariu;

În continuare vom folosi interschimbabil denumirea de tip întreg şi cea de tip int.

5.1.2.3.4 Tipul întreg lung

În fine, pentru cei care vor să reprezinte numerele întregi cu semn pe 8 octeţi, 64 de biţi, există tipul întreg lung. Valorile reprezentabile sunt de la -9223372036854775808 la 9223372036854775807 iar valoarea implicită este 0L.

Pentru cei care nu au calculatoare care lucrează pe 64 de biţi este bine de precizat faptul că folosirea acestui tip duce la operaţii lente pentru că nu există operaţii native ale procesorului care să lucreze cu numere aşa de mari.

Declaraţia se face cu cuvântul rezervat long. În continuare vom folosi interschimbabil denumirea de tip întreg lung cu cea de tip long.

5.1.2.4 Tipuri flotante

Acest tip este folosit pentru reprezentarea numerelor reale sub formă de exponent şi cifre semnificative. Reprezentarea se face pe patru octeţi, 32 biţi, aşa cum specifică standardul IEEE 754.

5.1.2.4.1 Tipul flotant

Valorile finite reprezentabile într-o variabilă de tip flotant sunt de forma:

sm2e

unde s este semnul +1 sau -1, m este partea care specifică cifrele reprezentative ale numărului, numită şi mantisă, un întreg pozitiv mai mic decât 2²⁴ iar e este un exponent întreg între -149 şi 104.

Valoarea implicită pentru variabilele flotante este 0.0f. Pentru declararea unui număr flotant, Java defineşte cuvântul rezervat float. Declaraţiile se fac ca în exemplele următoare:

float procent;
float noi, ei;

În continuare vom folosi interschimbabil denumirea de tip flotant şi cea de tip float.

5.1.2.4.2 Tipul flotant dublu

Dacă valorile reprezentabile în variabile flotante nu sunt destul de precise sau destul de mari, puteţi folosi tipul flotant dublu care foloseşte opt octeţi pentru reprezentare, urmând acelaşi standard IEEE 754

Valorile finite reprezentabile cu flotanţi dubli sunt de forma:

sm2e 

unde s este semnul +1 sau -1, m este mantisa, un întreg pozitiv mai mic decât 2⁵³ iar e este un exponent întreg între -1045 şi 1000. Valoarea implicită în acest caz este 0.0d.

Pentru a declara flotanţi dubli, Java defineşte cuvântul rezervat double ca în:

double distanţaPânăLaLună;

În continuare vom folosi interschimbabil denumirea de tip flotant dublu şi cea de tip double.

În afară de valorile definite până acum, standardul IEEE defineşte câteva valori speciale reprezentabile pe un flotant sau un flotant dublu.

5.1.2.4.3 Reali speciali definiţi de IEEE

Prima dintre acestea este NaN (Not a Number), valoare care se obţine atunci când efectuăm o operaţie a cărei rezultat nu este definit, de exemplu 0.0 / 0.0.

În plus, standardul IEEE defineşte două valori pe care le putem folosi pe post de infinit pozitiv şi negativ. Şi aceste valori pot rezulta în urma unor calcule.

Aceste valori sunt definite sub formă de constante şi în ierarhia standard Java, mai precis în clasa java.lang.Float şi respectiv în java.lang.Double. Numele constantelor este POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN.

În plus, pentru tipurile întregi şi întregi lungi şi pentru tipurile flotante există definite clase în ierarhia standard Java care se numesc respectiv java.lang.Integer, java.lang.Long, java.lang.Float şi java.lang.Double. În fiecare dintre aceste clase numerice sunt definite două constante care reprezintă valorile minime şi maxime care se pot reprezenta în tipurile respective. Aceste două constante se numesc în mod uniform MIN_VALUE şi MAX_VALUE.

5.1.3 Tipuri referinţă

Tipurile referinţă sunt folosite pentru a referi un obiect din interiorul unui alt obiect. În acest mod putem înlănţui informaţiile aflate în memorie.

Tipurile referinţă au, la fel ca şi toate celelalte tipuri o valoare implicită care este atribuită automat oricărei variabile de tip referinţă care nu a fost iniţializată. Această valoare implicită este definită de către limbajul Java prin cuvântul rezervat null.

Puteţi înţelege semnificaţia referinţei nule ca o referinţă care nu trimite nicăieri, a cărei destinaţie nu a fost încă fixată.

Simpla declaraţie a unei referinţe nu duce automat la rezervarea spaţiului de memorie pentru obiectul referit. Singura rezervare care se face este aceea a spaţiului necesar memorării referinţei în sine. Rezervarea obiectului trebuie făcută explicit în program printr-o expresie de alocare care foloseşte cuvântul rezervat new.

O variabilă de tip referinţă nu trebuie să trimită pe tot timpul existenţei sale către acelaşi obiect în memorie. Cu alte cuvinte, variabila îşi poate schimba locaţia referită în timpul execuţiei.

5.1.3.1 Tipul referinţă către o clasă

Tipul referinţă către o clasă este un tip referinţă care trimite către o instanţă a unei clasei de obiecte. Clasa instanţei referite poate fi oricare clasă validă definită de limbaj sau de utilizator.

Clasa de obiecte care pot fi referite de o anumită variabilă de tip referinţă la clasă trebuie declarată explicit. De exemplu, pentru a declara o referinţă către o instanţă a clasei Minge, trebuie să folosim următoarea sintaxă:

Minge mingeaMea;

Din acest moment, variabila referinţă de clasă numită mingeaMea va putea păstra doar referinţe către obiecte de tip Minge sau către obiecte aparţinând unor clase derivate din clasa Minge. De exemplu, dacă avem o altă clasă, derivată din Minge, numită MingeDeBaschet, putem memora în referinţa mingeaMea şi o trimitere către o instanţă a clasei MingeDeBaschet.

În mod general însă, nu se pot păstra în variabila mingeaMea referinţe către alte clase de obiecte. Dacă se încercă acest lucru, eroarea va fi semnalată chiar în momentul compilării, atunci când sursa programului este examinată pentru a fi transformată în instrucţiuni ale maşinii virtuale Java.

Să mai observăm că o referinţă către clasa de obiecte Object, rădăcina ierarhiei de clase Java, poate păstra şi o referinţă către un tablou. Mai multe lămuriri asupra acestei afirmaţii mai târziu.

5.1.3.2 Tipul referinţă către o interfaţă

Tipul referinţă către o interfaţă permite păstrarea unor referinţe către obiecte care respectă o anumită interfaţă. Clasa obiectelor referite poate fi oricare, atâta timp cât clasa respectivă implementează interfaţa cerută.

Declaraţia se face cu următoarea sintaxă:

ObiectSpaţioTemporal mingeaLuiVasile;

în care tipul este chiar numele interfeţei cerute. Dacă clasa de obiecte Minge declară că implementează această interfaţă, atunci variabila referinţă mingeaLuiVasile poate lua ca valoare referinţa către o instanţă a clasei Minge sau a clasei MingeDeBaschet.

Prin intermediul unei variabile referinţă către o interfaţă nu se poate apela decât la funcţionalitatea cerută în interfaţa respectivă, chiar dacă obiectele reale oferă şi alte facilităţi, ele aparţinând unor clase mai bogate în metode.

5.1.3.3 Tipul referinţă către un tablou

Tipul referinţă către un tablou este un tip referinţă care poate păstra o trimitere către locaţia din memorie a unui tablou de elemente. Prin intermediul acestei referinţe putem accesa elementele tabloului furnizând indexul elementului dorit.

Tablourile de elemente nu există în general ci ele sunt tablouri formate din elemente de un tip bine precizat. Din această cauză, atunci când declarăm o referinţă către un tablou, trebuie să precizăm şi de ce tip sunt elementele din tabloul respectiv.

La declaraţia referinţei către tablou nu trebuie să precizăm şi numărul de elemente din tablou.

Iată cum se declară o referinţă către un tablou de întregi lungi:

long numere[];

Numele variabilei este numere. Un alt exemplu de declaraţie de referinţă către un tablou:

Minge echipament[];

Declaraţia de mai sus construieşte o referinţă către un tablou care păstrează elemente de tip referinţă către o instanţă a clasei Minge. Numele variabilei referinţă este echipament. Parantezele drepte de după numele variabilei specifică faptul că este vorba despre un tablou.

Mai multe despre tablouri într-un paragraf următor.

5.1.4 Clasa de memorare

Fiecare variabilă trebuie să aibă o anumită clasă de memorare. Această clasă ne permite să aflăm care este intervalul de existenţă şi vizibilitatea unei variabile în contextul execuţiei unui program.

Este important să înţelegem exact această noţiune pentru că altfel vom încerca să referim variabile înainte ca acestea să fi fost create sau după ce au fost distruse sau să referim variabile care nu sunt vizibile din zona de program în care le apelăm. Soluţia simplă de existenţă a tuturor variabilelor pe tot timpul execuţiei este desigur afară din discuţie atât din punct de vedere al eficienţei cât şi a eleganţei şi stabilităţii codului.

5.1.4.1 Variabile locale

Aceste variabile nu au importanţă prea mare în contextul întregii aplicaţii, ele servind la rezolvarea unor probleme locale. Variabilele locale sunt declarate, rezervate în memorie şi utilizate doar în interiorul unor blocuri de instrucţiuni, fiind distruse automat la ieşirea din aceste blocuri. Aceste variabile sunt vizibile doar în interiorul blocului în care au fost create şi în subblocurile acestuia.

5.1.4.2 Variabile statice

Variabilele statice sunt în general legate de funcţionalitatea anumitor clase de obiecte ale căror instanţe folosesc în comun aceste variabile. Variabilele statice sunt create atunci când codul specific clasei în care au fost declarate este încărcat în memorie şi nu sunt distruse decât atunci când acest cod este eliminat din memorie.

Valorile memorate în variabile statice au importanţă mult mai mare în aplicaţie decât cele locale, ele păstrând informaţii care nu trebuie să se piardă la dispariţia unei instanţe a clasei. De exemplu, variabila în care este memorat numărul de picioare al obiectelor din clasa Om nu trebuie să fie distrusă la dispariţia unei instanţe din această clasă. Aceasta din cauză că şi celelalte instanţe ale clasei folosesc aceeaşi valoare. Şi chiar dacă la un moment dat nu mai există nici o instanţă a acestei clase, numărul de picioare ale unui Om trebuie să fie accesibil în continuare pentru interogare de către celelalte clase.

Variabilele statice nu se pot declara decât ca variabile ale unor clase şi conţin în declaraţie cuvântul rezervat static. Din cauza faptului că ele aparţin clasei şi nu unei anumite instanţe a clasei, variabilele statice se mai numesc uneori şi variabile de clasă.

5.1.4.3 Variabile dinamice

Un alt tip de variabile sunt variabilele a căror perioadă de existenţă este stabilită de către programator. Aceste variabile pot fi alocate la cerere, dinamic, în orice moment al execuţiei programului. Ele vor fi distruse doar atunci când nu mai sunt referite de nicăieri.

La alocarea unei variabile dinamice, este obligatoriu să păstrăm o referinţă către ea într-o variabilă de tip referinţă. Altfel, nu vom putea accesa în viitor variabila dinamică. În momentul în care nici o referinţă nu mai trimite către variabila dinamică, de exemplu pentru că referinţa a fost o variabilă locală şi blocul în care a fost declarată şi-a terminat execuţia, variabila dinamică este distrusă automat de către sistem printr-un mecanism numit colector de gunoaie.

Colectorul de gunoaie poate porni din iniţiativa sistemului sau din iniţiativa programatorului la momente bine precizate ale execuţiei.

Pentru a rezerva spaţiu pentru o variabilă dinamică este nevoie să apelăm la o expresie de alocare care foloseşte cuvântul rezervat new. Această expresie alocă spaţiul necesar pentru un anumit tip de valoare. De exemplu, pentru a rezerva spaţiul necesar unui obiect de tip Minge, putem apela la sintaxa:

Minge mingeaMea = new Minge();

iar pentru a rezerva spaţiul necesar unui tablou de referinţe către obiecte de tip Minge putem folosi declaraţia:

Minge echipament[] = new Minge[5];

Am alocat astfel spaţiu pentru un tablou care conţine 5 referinţe către obiecte de tip Minge. Pentru alocarea tablourilor conţinând tipuri primitive se foloseşte aceeaşi sintaxă. De exemplu, următoarea linie de program alocă spaţiul necesar unui tablou cu 10 întregi, creând în acelaşi timp şi o variabilă referinţă spre acest tablou, numită numere:

int numere[] = new int[10]; 

5.1.5 Tablouri de variabile

Tablourile servesc, după cum spuneam, la memorarea secvenţelor de elemente de acelaşi tip. Tablourile unidimensionale au semnificaţia vectorilor de elemente. Se poate întâmpla să lucrăm şi cu tablouri de referinţe către tablouri, în acest caz modelul fiind acela al unei matrici bidimensionale. În fine, putem extinde definiţia şi pentru mai mult de două dimensiuni.

5.1.5.1 Declaraţia variabilelor de tip tablou

Pentru a declara variabile de tip tablou, trebuie să specificăm tipul elementelor care vor umple tabloul şi un nume pentru variabila referinţă care va păstra trimiterea către zona de memorie în care sunt memorate elementele tabloului.

Deşi putem declara variabile referinţă către tablou şi separat, de obicei declaraţia este făcută în acelaşi timp cu alocarea spaţiului ca în exemplele din paragraful anterior.

Sintaxa Java permite plasarea parantezelor drepte care specifică tipul tablou înainte sau după numele variabilei. Astfel, următoarele două declaraţii sunt echivalente:

int[] numere;
int numere[];

Dacă doriţi să folosiţi tablouri cu două dimensiuni ca matricile, puteţi să declaraţi un tablou de referinţe către tablouri cu una dintre următoarele trei sintaxe echivalente:

float[][] matrice;
float[] matrice[];
float matrice[][];

De precizat că şi în cazul dimensiunilor multiple, declaraţiile de mai sus nu fac nimic altceva decât să rezerve loc pentru o referinţă şi să precizeze numărul de dimensiuni. Alocarea spaţiului pentru elementele tabloului trebuie făcută explicit.

Despre rezervarea spaţiului pentru tablourile cu o singură dimensiune am vorbit deja. Pentru tablourile cu mai multe dimensiuni, rezervarea spaţiului se poate face cu următoarea sintaxă:

byte [][]octeti = new byte[23][5];

În expresia de alocare sunt specificate în clar numărul elementelor pentru fiecare dimensiune a tabloului.

5.1.5.2 Iniţializarea tablourilor.

Limbajul Java permite şi o sintaxă pentru iniţializarea elementelor unui tablou. Într-un astfel de caz este rezervat automat şi spaţiul de memorie necesar memorării valorilor iniţiale. Sintaxa folosită în astfel de cazuri este următoarea:

char []caractere = { a, b, c, d };

Acest prim exemplu alocă spaţiu pentru patru elemente de tip caracter şi iniţializează aceste elemente cu valorile dintre acolade. După aceea, creează variabila de tip referinţă numită caractere şi o iniţializează cu referinţa la zona de memorie care păstrează cele patru valori.

Iniţializarea funcţionează şi la tablouri cu mai multe dimensiuni ca în exemplele următoare:

int [][]numere = {
{ 1, 3, 4, 5 },
{ 2, 4, 5 },
{ 1, 2, 3, 4, 5 }
};
double [][][]reali = {
{ { 0.0, -1.0 }, { 4.5 } },
{ { 2.5, 3.0 } }
};

După cum observaţi numărul iniţializatorilor nu trebuie să fie acelaşi pentru fiecare element.

5.1.5.3 Lungimea tablourilor

Tablourile Java sunt alocate dinamic, ceea ce înseamnă că ele îşi pot schimba dimensiunile pe parcursul execuţiei. Pentru a afla numărul de elemente dintr-un tablou, putem apela la următoarea sintaxă:

float []tablou = new float[25];
int dimensiune = tablou.length;
// dimensiune primeşte valoarea 25

sau

float [][]multiTablou = new float[3][4];
int dimensiune1 = multiTablou[2].length;
// dimensiune1 primeşte valoarea 4
int dimensiune2 = multiTablou.length;
// dimensiune2 primeşte valoarea 3 ^

5.1.5.4 Referirea elementelor din tablou

Elementele unui tablou se pot referi prin numele referinţei tabloului şi indexul elementului pe care dorim să-l referim. În Java, primul element din tablou este elementul cu numărul 0, al doilea este elementul numărul 1 şi aşa mai departe.

Sintaxa de referire foloseşte parantezele pătrate [ şi ]. Între ele trebuie specificat indexul elementului pe care dorim să-l referim. Indexul nu trebuie să fie constant, el putând fi o expresie de complexitate oarecare.

Iată câteva exemple:

int []tablou = new int[10];
tablou[3] = 1;
// al patrulea element primeşte valoarea 1
float [][]reali = new float[3][4];
reali[2][3] = 1.0f;
// al patrulea element din al treilea tablou
// primeşte valoarea 1

În cazul tablourilor cu mai multe dimensiuni, avem în realitate tablouri de referinţe la tablouri. Asta înseamnă că dacă considerăm următoarea declaraţie:

char [][]caractere = new char [5][];

Figura 5.1 Elementele tabloului sunt de tip referinţă, iniţializate implicit la valoarea null.

Variabila referinţă numită caractere conţine deocamdată un tablou de 5 referinţe la tablouri de caractere. Cele cinci referinţe sunt iniţializate cu null. Putem iniţializa aceste tablouri prin atribuiri de expresii de alocare:

caractere[0] = new char [3];
caractere[4] = new char [5];

Figura 5.2 Noile tablouri sunt referite din interiorul tabloului original. Elementele noilor tablouri sunt caractere.

La fel, putem scrie:

char []tablouDeCaractere = caractere[0];

Figura 5.3 Variabilele de tip referinţă caractere[0] şi tablouDeCaractere trimit spre acelaşi tablou rezervat în memorie.

Variabila tablouDeCaractere trimite către acelaşi tablou de caractere ca şi cel referit de primul element al tabloului referit de variabila caractere.

Să mai precizăm că referirea unui element de tablou printr-un index mai mare sau egal cu lungimea tabloului duce la oprirea execuţiei programului cu un mesaj de eroare de execuţie corespunzător.

5.1.5.5 Alocarea şi eliberarea tablourilor

Despre alocarea tablourilor am spus deja destul de multe. În cazul în care nu avem iniţializatori, variabilele sunt iniţializate cu valorile implicite definite de limbaj pentru tipul corespunzător. Aceasta înseamnă că, pentru tablourile cu mai multe dimensiuni, referinţele sunt iniţializate cu null.

Pentru eliberarea memoriei ocupate de un tablou, este suficient să tăiem toate referinţele către tablou. Sistemul va sesiza automat că tabloul nu mai este referit şi mecanismul colector de gunoaie va elibera zona. Pentru a tăia o referinţă către un tablou dăm o altă valoare variabilei care referă tabloul. Valoarea poate fi null sau o referinţă către un alt tablou.

De exemplu:

float []reali = new float[10];
?
reali = null; // eliberarea tabloului
sau
reali = new float[15]; // eliberarea în alt fel
sau
{
float []reali = new float[10];
?
}// eliberare automată, variabila reali a fost
// distrusă la ieşirea din blocul în care a
// fost declarată, iar tabloul de 10 flotanţi
// nu mai este referit ^

5.1.6 Conversii

Operaţiile definite în limbajul Java au un tip bine precizat de argumente. Din păcate, există situaţii în care nu putem transmite la apelul acestora exact tipul pe care compilatorul Java îl aşteaptă. În asemenea situaţii, compilatorul are două alternative: fie respinge orice operaţie cu argumente greşite, fie încearcă să convertească argumentele către tipurile necesare. Desigur, în cazul în care conversia nu este posibilă, singura alternativă rămâne prima.

În multe situaţii însă, conversia este posibilă. Să luăm de exemplu tipurile întregi. Putem să convertim întotdeauna un întreg scurt la un întreg. Valoarea rezultată va fi exact aceeaşi. Conversia inversă însă, poate pune probleme dacă valoarea memorată în întreg depăşeşte capacitatea de memorare a unui întreg scurt.

În afară de conversiile implicite, pe care compilatorul le hotărăşte de unul singur, există şi conversii explicite, pe care programatorul le poate forţa la nevoie. Aceste conversii efectuează de obicei operaţii în care există pericolul să se piardă o parte din informaţii. Compilatorul nu poate hotărî de unul singur în aceste situaţii.

Conversiile implicite pot fi un pericol pentru stabilitatea aplicaţiei dacă pot să ducă la pierderi de informaţii fără avertizarea programatorului. Aceste erori sunt de obicei extrem de greu de depistat.

În fiecare limbaj care lucrează cu tipuri fixe pentru datele sale există conversii imposibile, conversii periculoase şi conversii sigure. Conversiile imposibile sunt conversiile pe care limbajul nu le permite pentru că nu ştie cum să le execute sau pentru că operaţia este prea periculoasă. De exemplu, Java refuză să convertească un tip primitiv către un tip referinţă. Deşi s-ar putea imagina o astfel de conversie bazată pe faptul că o adresă este în cele din urmă un număr natural, acest tip de conversii

sunt extrem de periculoase, chiar şi atunci când programatorul cere explicit această conversie.

5.1.6.1 Conversii de extindere a valorii

În aceste conversii valoarea se reprezintă într-o zonă mai mare fără să se piardă nici un fel de informaţii. Iată conversiile de extindere pe tipuri primitive:

• byte la short, int, long, float sau double
• short la int, long, float sau double
• char la int, long, float sau double
• int la long, float sau double
• long la float sau double
• float la double

Să mai precizăm totuşi că, într-o parte din aceste cazuri, putem pierde din precizie. Această situaţie apare de exemplu la conversia unui long într-un float, caz în care se pierd o parte din cifrele semnificative păstrându-se însă ordinul de mărime. De altfel această observaţie este evidentă dacă ţinem cont de faptul că un long este reprezentat pe 64 de biţi în timp ce un float este reprezentat doar pe 32 de biţi.

Precizia se pierde chiar şi în cazul conversiei long la double sau int la float pentru că, deşi dimensiunea zonei alocată pentru cele două tipuri este aceeaşi, numerele flotante au nevoie de o parte din această zonă pentru a reprezenta exponentul.

În aceste situaţii, se va produce o rotunjire a numerelor reprezentate.

5.1.6.2 Conversii de trunchiere a valorii

Convenţiile de trunchiere a valorii pot produce pierderi de informaţie pentru că ele convertesc tipuri mai bogate în informaţii către tipuri mai sărace. Conversiile de trunchiere pe tipurile elementare sunt următoarele:

• byte la char
• short la byte sau char
• char la byte sau short
• int la byte, short sau char
• long la byte, short char, sau int
• float la byte, short, char, int sau long
• double la byte, short, char, int, long sau float.

În cazul conversiilor de trunchiere la numerele cu semn, este posibil să se schimbe semnul pentru că, în timpul conversiei, se îndepărtează pur şi simplu octeţii care nu mai încap şi poate rămâne primul bit diferit de vechiul prim bit. Copierea se face începând cu octeţii mai puţin semnificativi iar trunchierea se face la octeţii cei mai semnificativi.

Prin octeţii cei mai semnificativi ne referim la octeţii în care sunt reprezentate cifrele cele mai semnificative. Cifrele cele mai semnificative sunt cifrele care dau ordinul de mărime al numărului. De exemplu, la numărul 123456, cifrele cele mai semnificative sunt primele, adică: 1, 2, etc. La acelaşi număr, cifrele cele mai puţin semnificative sunt ultimele, adică: 6, 5, etc.

5.1.6.3 Conversii pe tipuri referinţă

Conversiile tipurilor referinţă nu pun probleme pentru modul în care trebuie executată operaţia din cauză că, referinţa fiind o adresă, în timpul conversiei nu trebuie afectată în nici un fel această adresă. În schimb, se pun probleme legate de corectitudinea logică a conversiei. De exemplu, dacă avem o referinţă la un obiect care nu este tablou, este absurd să încercăm să convertim această referinţă la o referinţă de tablou.

Limbajul Java defineşte extrem de strict conversiile posibile în cazul tipurilor referinţă pentru a salva programatorul de eventualele necazuri care pot apare în timpul execuţiei. Iată conversiile posibile:

• O referinţă către un obiect aparţinând unei clase C poate fi convertit la o referinţă către un obiect aparţinând clasei S doar în cazul în care C este chiar S sau C este derivată direct sau indirect din S.
• O referinţă către un obiect aparţinând unei clase C poate fi convertit către o referinţă de interfaţă I numai dacă clasa C implementează interfaţa I.
• O referinţă către un tablou poate fi convertită la o referinţă către o clasă numai dacă clasa respectivă este clasa Object.
• O referinţă către un tablou de elemente ale cărui elemente sunt de tipul T1 poate fi convertită la o referinţă către un tablou de elemente de tip T2 numai dacă T1 şi T2 reprezintă acelaşi tip primitiv sau T2 este un tip referinţă şi T1 poate fi convertit către T2.

5.1.6.4 Conversii la operaţia de atribuire

Conversiile pe care limbajul Java le execută implicit la atribuire sunt foarte puţine. Mai exact, sunt executate doar acele conversii care nu necesită validare în timpul execuţiei şi care nu pot pierde informaţii în cazul tipurilor primitive.

În cazul valorilor aparţinând tipurilor primitive, următorul tabel arată conversiile posibile. Pe coloane avem tipul de valoare care se atribuie iar pe linii avem tipurile de variabile la care se atribuie:

Tabloul 5.1 Conversiile posibile într-o operaţie de atribuire cu tipuri primitive. Coloanele reprezintă tipurile care se atribuie iar liniile reprezintă tipul de variabilă către care se face atribuirea.

După cum observaţi, tipul boolean nu poate fi atribuit la o variabilă de alt tip.

Valorile de tip primitiv nu pot fi atribuite variabilelor de tip referinţă. La fel, valorile de tip referinţă nu pot fi memorate în variabile de tip primitiv. În ceea ce priveşte tipurile referinţă între ele, următorul tabel defineşte situaţiile în care conversiile sunt posibile la atribuirea unei valori de tipul T la o variabilă de tipul S:

Tabloul 5.2 Conversiile posibile la atribuirea unei valori de tipul T la o variabilă de tipul S.

5.1.6.5 Conversii explicite

Conversiile de tip cast, sau casturile, sunt apelate de către programator în mod explicit. Sintaxa pentru construcţia unui cast este scrierea tipului către care dorim să convertim în paranteze în faţa valorii pe care dorim să o convertim. Forma generală este:

( Tip ) Valoare

Conversiile posibile în acest caz sunt mai multe decât conversiile implicite la atribuire pentru că în acest caz programatorul este prevenit de eventuale pierderi de date el trebuind să apeleze conversia explicit.

Dar, continuă să existe conversii care nu se pot apela nici măcar în mod explicit, după cum am explicat înainte.

În cazul conversiilor de tip cast, orice valoare numerică poate fi convertită la orice valoare numerică.

În continuare, valorile de tip boolean nu pot fi convertite la nici un alt tip.

Nu există conversii între valorile de tip referinţă şi valorile de tip primitiv.

În cazul conversiilor dintr-un tip referinţă într-altul putem separa două cazuri. Dacă compilatorul poate decide în timpul compilării dacă conversia este corectă sau nu, o va decide. În cazul în care compilatorul nu poate decide pe loc, se va efectua o verificare a conversiei în timpul execuţiei. Dacă conversia se dovedeşte greşită, va apare o eroare de execuţie şi programul va fi întrerupt.

Iată un exemplu de situaţie în care compilatorul nu poate decide dacă conversia este posibilă sau nu:

Minge mingeaMea;
?
MingeDeBaschet mingeaMeaDeBaschet;
// MingeDeBaschet este o clasă
// derivată din clasa Minge
mingeaMeaDeBaschet=(MingeDeBaschet)mingeaMea;

În acest caz, compilatorul nu poate fi sigur dacă referinţa memorată în variabila mingeaMea este de tip MingeDeBaschet sau nu pentru că variabilei de tip Minge i se pot atribui şi referinţe către instanţe de tip Minge în general, care nu respectă întru totul definiţia clasei MingeDeBaschet sau chiar referinţă către alte tipuri de minge derivate din clasa Minge, de exemplu MingeDePolo care implementează proprietăţi şi operaţii diferite faţă de clasa MingeDeBaschet.

Iată şi un exemplu de conversie care poate fi decisă în timpul compilării:

Minge mingeaMea;
MingeDeBaschet mingeaMeaDeBaschet;
?
mingeaMea = ( Minge ) mingeaMeaDeBaschet;

În următorul exemplu însă, se poate decide în timpul compilării imposibilitatea conversiei:

MingeDeBaschet mingeaMeaDeBaschet;
MingeDePolo mingeaMeaDePolo;
?
mingeaMeaDePolo = ( MingeDePolo ) mingeaMeaDeBaschet;

În fine, tabelul următor arată conversiile de tip cast a căror corectitudine poate fi stabilită în timpul compilării. Conversia încearcă să transforme printr-un cast o referinţă de tip T într-o referinţă de tip S.

Tabloul 5.3 Cazurile posibile la convertirea unei referinţe de tip T într-o referinţă de tip S.

5.1.6.6 Conversii de promovare aritmetică

Promovarea aritmetică se aplică în cazul unor formule în care operanzii pe care se aplică un operator sunt de tipuri diferite. În aceste cazuri,

compilatorul încearcă să promoveze unul sau chiar amândoi operanzii la acelaşi tip pentru a putea fi executată operaţia.

Există două tipuri de promovare, promovare aritmetică unară şi binară.

În cazul promovării aritmetice unare, există un singur operand care în cazul că este byte sau short este transformat la int altfel rămâne nemodificat.

La promovarea aritmetică binară se aplică următorul algoritm:

1. Dacă un operand este double, celălalt este convertit la double.
2. Altfel, dacă un operand este de tip float, celălalt operand este convertit la float.
3. Altfel, dacă un operand este de tip long, celălalt este convertit la long
4. Altfel, amândoi operanzii sunt convertiţi la int.

De exemplu, în următoarea operaţie amândoi operanzii vor fi convertiţi la float prin promovare aritmetică binară:

float f;
double i = f + 3;

După efectuarea operaţiei, valoarea obţinută va fi convertită implicit la double.

În următorul exemplu, se produce o promovare unară la int de la short.

short s, r;
?
int min = ( r < -s ) ? r : s;

În expresia condiţională, operandul -s se traduce de fapt prin aplicarea operatorului unar - la variabila s care este de tip short. În acest caz, se va produce automat promovarea aritmetică unară de la short la int, apoi se va continua evaluarea expresiei.