În lecţiile precedente am menţionat câteva noţiuni care au rămas

neexplicate. Una dintre ele este variabila. Variabilele sunt una dintre
noţiunile de bază ale programării şi, pur şi simplu, nici nu am putea
începe să lucrăm fără să le folosim. În lecţia de faţă vom explica mai
detaliat cum funcţionează variabilele în Java.

Variabilele sunt nişte containere temporare în care se stochează nişte

valori. După ce valoarea a fost stocată în memorie, este reprezentată
prin variabilă.

În lecţia precedentă am menţionat, de asemenea, şi că Java nu poate

să transforme în mod automat un tip de dată în altul, în funcţie de
operaţia efectuată asupra acestui tip de dată. Cu alte cuvinte, nu
putem scrie:

int a = "Hello"; /* incopatible types: String cannot be converted to int */

Această caracteristică a limbajului se mai numeşte Strong Typed

(există și Loosely Typed). Aceasta înseamnă că trebuie să avem grijă
cum declarăm un anumit tip şi să ne adresăm acestui tip în mod
corespunzător.

Declarație, inițializare și instanțiere

Înainte de a ne familiariza cu diferitele tipuri de variabile, trebuie mai

întâi să învățăm despre anumite concepte de bază: declarație,
inițializare și instanțiere. Este foarte important să facem diferența între
acești termeni și să-i adoptăm acum, deoarece vor fi utilizați în mod
activ în timpul întregului curs.

Dacă vrem ca o variabilă să existe, mai întâi trebuie să o creăm.

Procesul de creare a unei variabile se numește declarație. Următoarea
linie de cod reprezintă declarația unei variabile întregi:
int variableA; // tipDată denumire Variabilă;

Declarația este alcătuită din două părți. Prima parte este tipul de dată
pe care îl va reprezenta variabila, iar a doua este numele variabilei.
Când dăm nume variabilelor, există câteva reguli pe care trebuie să le
respectăm: variabilele nu trebuie să înceapă cu un număr, nu conţin
caractere speciale și sunt sensibile la majuscule și minuscule (adică
variabilele name și Name sunt diferite), şi numele variabilelor nu poate
fi un cuvânt cheie. Bineînțeles, denumirea unei variabile trebuie să fie
într-un singur cuvânt. De exemplu, myVariable este corect, dar my
Variable nu.

Deşi la numirea variabilelor nu trebuie să respectăm niciun fel de reguli

lingvistice, este de dorit să folosim una dintre convenţiile de scriere.
Una dintre cele mai populare este notaţia Camel Case, care
subînţelege o literă majusculă la începutul fiecărui cuvânt din variabilă.

De exemplu:

MyVariable sau myFirstVariable

De asemenea, se recomandă numirea intuitivă a variabilelor. Această

recomandare trebuie luată în serios chiar şi la construirea celor mai
mici programe, deoarece şi astfel de programe se măresc foarte
repede, iar memorarea informaţiilor despre variabile poate scăpa uşor
de sub control.

int variableA; //declaration

variableA=10; //initialization

int variableA = 10; // declaration and initialization

Conceptul de instanțiere se referă la obiecte, nu la tipuri primitive.
Instanțierea este un proces de creare a unui obiect și de rezervare a
memorie. Îl vom ilustra printr-un exemplu. Dacă avem clasa definită de
utilizator MyClass și vrem să creăm un obiect al acestei clase, adică să
instanțiem această clasă, mai întâi trebuie să creăm o variabilă în care
va fi localizat obiectul pe care vrem să-l creăm. Acest proces se
numește declarație.

MyClass obj; // declaraţie

Apoi, atribuim un obiect variabilei create în procesul de instanțiere a

clasei MyClass cu cuvântul cheie new:

obj = new MyClass(); // instanţiere

Putem să efectuăm declarația și instanțierea într-o singură linie, la fel

ca și în cazul variabilelor de tip primitiv, astfel:

MyClass obj = new MyClass(); // declaraţie şi instanţiere

Procesul de creare a obiectelor va fi explicat în detaliu în modulul OOP
în Java.

Domeniul de vizibilitate a variabilelor

Fiindcă limbajul Java este un limbaj de programare orientat pe obiecte,

există anumite reguli care se respectă şi în acest context. Este vorba
despre domeniul de vizibilitate, respectiv, tratarea şi adresarea lor în
funcţie de contextul în care se află. Variabilele despre care vorbim
sunt: variabile de instanţă, variabile de clasă, variabile locale şi
variabile parametrice (parametri). Acestea rămân în continuare cele
mai obişnuite variabile şi comportamentul lor nu diferă, ci doar modul
în care le accesăm.

Variabilele de instanță

Variabile de instanţă sunt acele variabile care reprezintă atributele

unei instanţe a unei clase. Acestea sunt variabilele care apar doar în
contextul obiectului şi care nu pot fi accesate fără instanţierea
prealabilă a clasei respective:

//class definition
class MyClass
{
public int myVariable;
}
public class Test {
public static void main(String[] args)
{
// object instantiation
MyClass mClass = new MyClass();
// initialization of field
mClass.myVariable = 10;

// display field value

System.out.println(mClass.myVariable);
 }
}

În codul de mai sus, myVariable reprezintă o variabilă de instanță care

nu poate fi accesată până când nu instanțiem un obiect al clasei
MyClass. Despre clase și obiecte vom vorbi în detaliu în modulul OOP în
Java, după ce toate acestea vă vor fi mai clare.

Variabilele de clasă (statice)

Variabilele de clasă, de asemenea, se află în contextul clasei, dar nu

este necesară instanţierea pentru a fi accesate. Acest fel de variabile
se mai numesc şi câmpuri statice sau atribute statice ale clasei și se
declară cu cuvântul cheie static.

//class definition
class MyClass
{
public static int myVariable;
}

public class Test {

public static void main(String[] args)

{
//initialization of field
MyClass.myVariable = 10;

//display field value

System.out.println(MyClass.myVariable);
}
}
În codul de mai sus vedem că variabila myClass a fost accesată fără o
instanțiere anterioară a obiectului.

Variabile locale

Variabile locale sunt variabilele create în interiorul unui bloc şi, dacă nu
accentuăm explicit, nu sunt vizibile în afara blocului. Când spunem
bloc, nu ne referim la toate tipurile de bloc, ci numai la blocurile
încapsulate, cum ar fi funcțiile. Fiindcă funcţiile în Java sunt, de fapt,
metode (datorită orientării pe obiecte), variabilele locale sunt acelea
care există în cadrul metodelor.

Următorul exemplu ilustrează încercarea de a apela o variabilă

declarată în cadrul metodei. Mediul va raporta o eroare, deoarece nu
putem vedea variabila din partea codului din care încercăm să o
accesăm.

Imaginea 8.1 Variabilă locală

Variabila locală myVariable, pe care am declarat-o în metoda

testMethod, va fi vizibilă în cadrul acelei metode.
Variabilele parametrice

Variabile parametrice sunt parametrii de intrare şi ieşire ai

funcţionalităţii (ai metodelor) limbajului. Inconştient, deja am folosit
astfel de variabile în fiecare program scris până acum. Este partea
dintre paranteze a metodei main: String[] args.

public static void main(String[] args)

Valorile implicite

Uneori variabilele care nu au fost inițializate în timpul interpretării

primesc valori implicite. Variabilele de clasă și de instanță pot primi
valori implicite, în timp ce altele trebuie inițializate. Valoarea implicită
va fi 0 sau null, în funcție de tipul de variabilă. A ne baza pe valorile
implicite atribuite de compilator se consideră o practică proastă. Vom
ilustra utilizarea valorilor implicite prin următorul exemplu:

public class TestClass {

static int variableA; // variabila de clasă

// variabile de instanţă
int variableB;
String variableC;
boolean variableD;

public static void main(String[] args)

{
TestClass class1 = new TestClass();

System.out.println(variableA);
System.out.println(class1.variableB);
System.out.println(class1.variableC);
System.out.println(class1.variableD);
}
}

Acest exemplu este un exemplu standard modificat utilizat în primul

modul. Am definit o clasă cu patru variabile. Prima variabilă este o
variabilă de clasă, deoarece a fost declarată cu cuvântul cheie static.
Pentru a utiliza această variabilă, nu trebuie să creăm un obiect.
Celelalte trei variabile sunt variabile de instanță care pot fi accesate
doar dacă creăm în prealabil un obiect.

În cadrul clasei TestClass, am definit metoda main(), din care sunt

scrise valorile tuturor celor patru variabile. Codul va avea drept
rezultat următoarea ieșire:

0
0
null
false

De aici rezultă următoarele: compilatorul pentru valori implicite a

atribuit valoarea 0 (zero) variabilelor întregi. Deoarece String nu
reprezintă o dată primitivă, ci un obiect, valoarea sa implicită este null.
Valoarea implicită a unui tip de date boolean este false.

Dacă acum am încerca să declarăm o variabilă în cadrul metodei

principale, fără să o inițializăm, ar apărea o eroare în interpretarea
codului sursă.

Dacă folosiţi mediul de dezvoltare NetBeans, editorul nu vă va permite

pornirea compilării şi va arăta clar eroarea (variabila nu este
iniţializată).
 Imaginea 8.2 Valori implicite ale variabilelor

Constante

Când este vorba de valori definite de utilizator, pe lângă variabile mai

există şi un tip care, odată iniţializat, păstrează o valoare fixă. Astfel de
tipuri de purtători de valoare se numesc constante. Folosim constante
atunci când ştim sigur că valoarea iniţializată nu se va schimba în
timpul execuţiei programului. Cel mai bun exemplu pentru valoarea
unei constante ar fi 3.14 (respectiv, PI).

Dacă am vorbi despre limbajul Java fără să luăm în considerare

convenţiile de programare generale, nici nu am menţiona constantele,
pentru că acestea nici nu există în Java ca noţiune explicită. Pur şi
simplu, nu există un mod în care să accentuăm că o variabilă este
constantă. În schimb, folosim un mic truc bazat pe reguli obiectuale.

Configurăm un câmp public şi static sigilat într-o clasă care poartă

valoarea atribuită. Prin sigilat înțelegem că valoarea acestei constante
nu poate fi schimbată. Realizăm acest lucru utilizând cuvântul cheie
final. Un asemenea câmp va fi vizibil în cadrul întregului program:

public class Test {

public static final double PI = 3.14;

public static void main(String[] args)

{
System.out.println(PI);
}
}

Astfel, am creat o constantă care conține valoarea constantei

matematice PI.

Denumirea variabilelor și a constantelor

În acest moment ştim tot ceea ce este tehnic necesar pentru a crea
variabile şi constante. Ceea ce, de asemenea, trebuie să ştim, sunt
convenţiile numirii lor.

Numele variabilelor nu trebuie să înceapă niciodată cu un număr.

double 1variable = 15.757; //incorrect

double variable = 15.757; //correct

De asemenea, numele de variabile nu trebuie să înceapă niciodată cu

un caracter special. Toate exemplele de mai jos ilustrează lucruri care
nu sunt permise în ceea ce privește denumirea variabilelor.

// denumirea incorectă a variabilelor

double .variable = 15.757;
double ,variable = 15.757;
double <variable = 15.757;
double /variable = 15.757;
double *variable = 15.757;

Practica este ca niciodată să nu numim variabilele cu nume neintuitive.

Deşi, în acest curs, vor fi multe nume de variabile, precum
variabilaMea sau vm şi altele, în practică nu trebuie să procedăm
niciodată aşa.

De exemplu, următoarele nume de variabile nu sunt bune:

String i; // username holder

int number; // holder of a number
float p1; // holder of certain values
double a; // holder of a operand

Acestea ar fi denumirile corecte ale aceloraşi variabile:

String userName;
int usersNumber;
float birthYear;
double firstOperand;

Pe lângă faptul că numele variabilelor trebuie să fie intuitive, totuşi nu

trebuie să fie prea lungi, ci atât de lungi încât să ilustreze valoarea
purtată.

De exemplu, denumirea următoare este bună:

String userName1;

dar următoarea denumire este puţin prea lungă:

String variableFirstUsersName;

Deşi nu există limitări de lungime la variabile, este recomandat ca

denumirea variabilelor să nu depăşească 15 caractere.

Bineînţeles, pe lângă confortul personal, adesea trebuie să avem în

vedere şi mediul, din cauza căruia trebuie să acordăm atenţie numirii şi
să respectăm standarde prescrise.

Pe lângă acest standard general pentru numirea elementelor, există şi

standardul legat de fiecare element în parte, astfel încât vom numi în
mod diferit variabilele, constantele, clasele, metodele etc.

Constantele se numesc de obicei cu litere majuscule, cum se poate

vedea în exemplul de mai sus (PI). În constante, cuvintele sunt
separate prin liniuţa de jos pentru că toate literele sunt majuscule.

De exemplu:

public static final String APPLICATION_PATH = "c:/myApplication/";

În acest fel, orice alt programator va şti că este vorba de o constantă.

Şi acesta nu este sfârşitul poveştii despre denumire. Există o mulţime

de componente diferite care au propriile convenţii de numire. Dar ne
vom ocupa de majoritatea acestor convenţii pe parcurs, atunci când
ajungem să discutăm despre ele. Ar mai trebui precizat că variabilele
nu pot conţine caractere speciale. Pe de altă parte se admite ca o
variabilă să conţină caractere cu diacritice, sau având nume ce conţine
caractere speciale din altă limbă. De exemplu, nu se admit declaraţiile:
int !i;
int i/j;
int ()i;
însă declaraţia int număr; este admisă.

Practica cea mai comună este să adoptăm regulile de denumire pentru

toate elementele codului din cadrul unei echipe de programare, adică
dintr-o organizație, și apoi toată lumea să le aplice, pentru a întreține
mai ușor codul.

Afişarea variabilelor la ieșire

După ce ne-am familiarizat cu tipurile de date și variabile, haideți să

vedem cum putem afişa ceva la ieșire în limbajul de programare Java.
Am învățat deja despre metoda println care îndeplinește această
funcție. Dacă vrem să afișăm valoarea unei variabile cu această
metodă, putem scrie:

int x = 5;
System.out.println(x);

Vom obține valoarea variabilei x, care este 5, afişată la ieșire. Metoda

println afişează un mesaj la ieșire și trece pe linia următoare. Vom
primi o confirmare a acestui fapt dacă scriem următorul cod:

int x = 5;
int y = 10;
System.out.println(x);
System.out.println(y);

Valorile variabilelor vor fi scrise una sub alta.

Dacă vrem să afişăm valorile pe aceeași linie, folosim metoda print, iar
în acest caz valorile vor apărea pe același rând, scrise una după alta.
Dar, dacă vrem să îmbogățim ieșirea noastră, adăugând la ieșire un
mesaj, pe lângă valoarea variabilei, folosim metoda printf (pentru cei
familiarizați cu limbajul C, există ceva similar și în acest limbaj).

int x = 5;
System.out.printf("The value of variable x is %d", x);

Dacă pornim codul, ieșirea va fi:

The value of variable x is 5

În codul de mai sus, am folosit metoda printf pentru afişare. În afişarea
textuală (între ghilimele) există o secvență de caractere %d. Vedem că
această secvență a fost înlocuită de valoarea variabilei x în cadrul
afişării la ieșire. Secvența de caractere %d semnifică faptul că în locul
în care apare, afişarea la ieșire va conține valoarea zecimală a
variabilei specificate după ghilimele.

Dacă vrem să afișăm mai multe variabile, le specificăm una după alta,
separate prin virgulă, iar apoi vor fi interpretate în ordinea în care au
fost menționate în cadrul afişării textuale.

int x = 5;
double y = 12.1313467445;
System.out.printf("The value of variable x is %d%nThe value of variable y is %.4f", x, y);

În codul de mai sus, am definit două variabile, una de tip int și alta de
tip double. Cu metoda printf, le-am afişat la ieșire. Pentru a prezenta
aceste variabile în cadrul unei afişări textuale, am folosit secvențele
%d și %f. Cu sensul primei secvențe suntem familiarizați, în timp ce în
czaul celei de-a doua, caracterul f se folosește pentru a reprezenta
tipurile cu virgulă mobilă. În cadrul acestei secvențe, am adăugat un
caracter care va defini faptul că vrem să rotunjim valoarea la patru
zecimale în fața caracterului f. De asemenea, în timpul afişării, am
folosit caracterul %n, care semnifică trecerea pe o linie nouă (la fel ca
și secvența de caractere \n).