Sintaxa oricărui limbaj reprezintă un set de reguli pe care utilizatorul

trebuie să le respecte pentru ca ceilalți utilizatori ai aceluiași limbaj să-l

înțeleagă. Cu alte cuvinte, o sintaxă este un set de reguli pe care toți
utilizatorii sunt de acord să le respecte pentru a putea să comunice.
Dacă încălcați una dintre ele, e posibil ca alți participanți la comunicare
să nu vă înțeleagă. La fel ca toate limbajele, și cele de programare au
sintaxa lor.

Limbajul de programare Java, la fel ca majoritatea limbajelor de

programare moderne, preia o mare parte a sintaxei din limbajul C++.
C++ preia o mare parte a sintaxei sale din C. Cei care au creat Java au
folosit C++ ca model, deoarece acest limbaj era foarte răspândit în
acel moment, ceea ce ușura învățarea lui de către ceilalți
programatori. De aceea, dacă credeţi că, odată ce aţi învăţat Java, aţi
învăţat şi o mare parte a acestor două limbaje - aveţi dreptate. Aceste
limbaje sunt foarte asemănătoare din punct de vedere sintactic. Totuşi,
Java permite o libertate mai mare în ceea ce priveşte scrierea. Mai
precis, nu ne obligă să ne ocupăm de lucruri care nu se află în
contextul proiectului, dar trebuie respectate pentru ca programul să
funcţioneze, cum ar fi gestionarea memoriei şi altele.

Fiecare program din Java este alcătuit din elementele următoare:

linii,

blocuri,

identificatori,

comentarii,

spații albe/goale.

Liniile (declarațiile)
O linie reprezintă cea mai mică parte independentă a unui program.
Fiecare program Java este alcătuit din linii de cod. Dimensiunea unui
cod se măsoară în linii (100 de linii de cod, 1245 de linii de cod etc.). O
regulă frecvent întâlnită a sintaxei de program este că fiecare linie de
cod (mai exact, fiecare declaraţie) trebuie să se termine cu marcajul ;.

int x=1; //fiecare declaraţie trebuie să se termine cu semnul ;

Regula aceasta este valabilă în totalitate şi pentru Java. O linie scrisă

fără acest marcaj de fapt nici nu este considerată declaraţie încheiată
şi programul va aştepta continuarea logicii până când apare marcajul
respectiv. În acest sens, spaţiul gol nu este luat în considerare, astfel
încât declaraţia următoare va fi complet validă:

int x = 1 // afirmaţie validă...

însă, aceasta nu:

int x = 1 // afirmaţie nevalidă (lipseşte ; la sfârşit)

Există cazuri în care marcajul ; nu apare la capătul liniei, ceea ce

înseamnă că "ideea" nu este încheiată şi că programul aşteaptă
continuarea logicii pentru a completa această unitate. Acest caz se
întâlneşte cel mai frecvent la folosirea condiţiilor (controlul fluxului).

De exemplu:

if(x<10) // nu are ; la sfârşitul acestei linii deoarece aceasta este condiţia

System.out.println("Linia de mai sus nu are marcajul ; dar funcţionează");

Exemplul de mai sus arată adeseori ca şi cum n-ar avea doar o singură
linie sub condiţie (linia fără marcajul ;), cazuri în care se folosesc
blocurile de cod.

Blocurile

Un bloc este un grup de linii, cu alte cuvinte, declarații cuprinse între

paranteze acolade {}.

Acest grup de linii dintr-un bloc este considerat o singură unitate.

De exemplu, dacă am avea codul următor:

int a=1;
int b=2;
int c=a+b;
System.out.println(c);

am putea, pur şi simplu, să declarăm liniile 3 şi 4 ale codului ca un bloc

care calculează şi emite valoarea c.

Pentru ca şi traducătorul să poată înregistra un cod ca un bloc separat,

acest bloc trebuie mărginit de paranteze acolade:

{
acesta este un bloc
}

adică

int a = 1;
 int b = 2;

// blocul de cod
{
int c = a + b;
System.out.println(c);
}

Blocul de cod din exemplul precedent, cu excepţia prezentării, nu are

nicio altă funcţie, deoarece codul care se află în interiorul blocului va fi
întotdeauna executat.

Pentru ca un bloc să aibă sens în interiorul programului, este necesar

ca executarea conţinutului său să fie condiţionată:

condiție
{
acesta este un bloc
}

de exemplu:

int a = 1;
int b = 2;

if(b != 0) // condiţie
{
int c = a / b;
System.out.println(c);
} // aici nu trebuie ;
Marcajul punct și virgulă trebuie să fie plasat la finalul blocului.

Identificatorii

Blocurile lingvistice, precum clasele sau metodele, trebuie denumite

pentru a putea fi utilizate în cod. De aceea, în limbajul de programare
Java există identificatorii.

Un identificator poate conține caractere literale, numere, caractere de

legătură (precum underscore) și simboluri ale valutelor (de exemplu $).
Un identificator nu poate începe cu un număr, iar lungimea sa trebuie
să fie mai mică decât linia în care apare.

Anumite cuvinte nu pot fi utilizate ca identificatori, deoarece au un

sens special în limbaj și se numesc cuvinte rezervate. Java recunoaște
următoarele cuvinte rezervate: abstract, assert, boolean, break, byte,
case, catch, char, class, const, continue, default, do, double, enum,
else, extends, false, final, finally, float, for, goto, if, implements, import,
instanceof, int, interface, long, native, new, null, package, private,
protected, public, return, short, static, strictfp, super, switch,
synchronized, this, throw, throws, transient, true, try, void, volatile,
while.

class JavaClass // corect

{
void method_name() // corect
{

}
void method$() // corect
{

}
}

class 5Class // incorect

Comentariile

Dacă dorim ca un conţinut să fie memorat în codul sursă, dar să nu

afecteze în niciun fel executarea programului, folosim comentarea
codului.

Nu există niciun limbaj de programare în care să nu existe opţiunea de

comentare a codului, așa că nici Java nu face excepţie.

Există multe cazuri în care comentarea codului reprezintă o necesitate

practică.

Luarea unor notiţe despre dezvoltarea codului. O caracteristică

a codurilor voluminoase este că ne putem "pierde" uşor în ele.
De aceea, întotdeauna trebuie să lăsăm comentarii pe unităţile
logice ale codului, ca să ne putem aminti în orice moment care
este scopul unor anumite părţi ale codului.

Un cod bine comentat uşurează munca programatorului care

moşteneşte acest cod. De aceea, când lucrăm în echipă, se
recomandă folosirea comentariilor în cod.
 Gestionarea uşoară şi rapidă a funcţionalităţii codului. În acest
sens, putem să dezactivăm unele porţiuni de cod
(transformându-le în comentariu) sau să le activăm (când
scoatem comentariul). Dacă programul nostru, de exemplu,
conţine 100 de linii de cod pe care dorim să le dezactivăm
pentru un moment (fără a le şterge), cel mai simplu mod este
să le comentăm.

În Java, putem comenta codul folosind liniile înclinate (Slash). De

exemplu, dacă adăugăm codului nostru o linie de comentariu:

//acesta este un comentariu uniliniar

int a=1;

Dacă am începe aşa, programul s-ar executa fără probleme şi ar atribui

o valoare variabilei a.

Prin comentariu înțelegem o linie completă care urmează după

marcajul comentariului (//). Dacă dorim să comentăm mai multe linii
(un bloc), putem să:

- comentăm fiecare linie în parte:

//prima linie a comentariului

//a doua linie a comentariului

- sau să creăm aşa-numitul bloc de comentariu:

/* tot ce este între

aceste paranteze
un bloc de comentariu

*/

unde marcajul /* începe blocul de cometariu şi marcajul */ părăseşte

blocul de comentariu. Fiecare text care se află între aceste două
marcaje va fi tratat ca un comentariu.

Comentariul se poate adăuga şi după o linie de cod, ca de exemplu:

System.out.println("hello"); //comentariul meu după linia de cod

Dacă dorim să introducem comentariul în cod, dar să continuăm codul

în aceeaşi linie, folosim un bloc de comentariu:

System.out./*comentariu în cadrul liniei de cod

funcționează*/println("hello");

Acest exemplu, deşi extrem, ilustrează bine cât este de flexibil

traducătorul în ignorarea comentariilor.

Javadoc

Java are un mecanism încorporat de generare a documentației despre

clase și interfețe. Acest mecanism se numește Javadoc și aparține unui
tip special de comentariu, și de aceea i s-a dedicat un capitol separat.
Acest tip de comentariu este menit să fie citit atât de oameni, cât și de
mașini. Comentariile Javadoc încep cu un slash, urmat de două
asteriscuri (/**) și se încheie cu un asterisc și un slash (*/). Acest lucru
este aproape identic cu comentariile standard, diferența fiind că în
Javadoc, va apărea un asterisc adițional de fiecare dată când
deschideți comentariul. De obicei, fiecare clasă menită publicului ar
trebui să conțină comentarii Javadoc, precum și comentarii ale fiecărei
metode planificate să fie făcută publică. Atunci când inițializați
instrumentul Javadoc, acesta verifică toate clasele și interfețele și
creează un set de pagini HTML cu titluri și subtitluri care corespund
ierarhiei programului creat.

/**
* aşa arată
* comentariu javadoc
*/

Dacă știți că veți lucra singuri la o aplicație Java, nu e nevoie să

introduceți comentarii Javadoc și nici să generați documentația. Însă,
dacă lucrați la un proiect open-source sau de echipă, probabil vi se va
cere să introduceți acest tip de comentariu și să creați documentație.
Vom discuta mai multe despre documentație în următoarea lecție -
NetBeans.

Spațiul gol

Când începem un nou rând în programul Java, nu înseamnă că am

început în mod automat o linie nouă, respectiv, o declaraţie nouă. De
asemenea, putem scrie oricâte declaraţii dorim într-un singur rând,
atâta timp cât le separăm în mod corespunzător cu marcajul ; (punct și
virgulă).

Următorul exemplu dă un rezultat valid (deoarece nu trebuie să fie

scrisă fiecare afirmaţie în rând nou):

int a=1; int b=2; int c=a+b; System.out.println(c);

însă, exemplul următor va semnala o eroare (deoarece declaraţiile nu
sunt separate cu ;):

int a=1
int b=2
int c=a+b
System.out.println(c)

Case Sensitivity

Java este limbaj de programare Case Sensitive, ceea ce înseamnă că

va trata în mod diferit elementele scrise cu litere minuscule şi
majuscule:

int A=10;

nu este acelaşi lucru cu:

int a=10; // A şi a nu sunt aceleaşi variabile

Pe baza acestei caracteristici, avem posibilitatea să folosim diferite

sisteme de notaţie, respectiv de introducere a variabilelor. În general,
toţi au dreptul să folosească orice modalitate de denumire a
variabilelor, dar cea mai frecvent folosită combinaţie este Camel
Case şi Hungarian Notation. Când spunem că folosim notaţia Camel
Case, de fapt, subînţelegem că în variabile scriem fiecare literă iniţială
cu majusculă (VariabilaMea), iar în notaţia Hungarian, întâi descriem
variabila şi apoi îi dăm numele (prmVariabilaMea).