Cuvinte cheie
In limbajul Java cuvintele cheie sunt termeni rezervati care nu pot fi utilizati ca si identificatori. Termenii const si goto sunt rezervati chiar daca nu sunt folositi in momentul de fata.
abstract continue for new switch assert*** default goto* package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum**** instanceof return transient catch extends int short try char final interface static void class finally long strictfp** volatile const* float native super while * neutilizat ** adaugat in versiunea 1.2 *** adaugat in versiunea 1.4 **** adaugat in versiunea 5.0
Identificatorii sunt expresii alese de catre programatori pentru a reprezenta nume de clase, obiecte, variabile, constante sau metode.
// corect x X myvar MyVar MYVAR _myvar $myvar i i1 i123 i_123
In limbajul Java identificatorii trebuie sa inceapa cu o litera, dupa care pot urma atat litere cat si cifre. De asemenea, in identificatori se face distinctie intre literele mari si cele mici.
// incorect my var 1i my-var a+b a&b
Comentarii
Comentariile reprezinta o parte importanta a unui program. Ele permit descrierea zonelor de program, pentru o mai buna intelegere in cazul unei viitoare utilizari.
Limbajul Java recunoaste trei tipuri de comentarii: comentarii pe o singura linie, comentarii pe mai multe linii si comentarii pentru generarea de documentatie.
Comentarii pe o singura linie (stilul C++) incep cu // si se termina la incheierea liniei de program. Sunt utile in descrierea liniilor de program.
// Aplicatia BunaJava - exemplu comentariu pe o linie | |
class BunaJava { | |
public static void main(String[] args) { | |
// Afisare mesaj de bun venit | |
System.out.println("Bun venit in lumea Java!"); | |
} | |
} |
Comentarii pe mai multe linii (comentariile traditionale) sunt delimitate de sirurile de caractere /*, */.
// Aplicatia BunaJava - exemplu comentariu pe mai multe linii | |
class BunaJava { | |
public static void main(String[] args) { | |
/* | |
* Afisare mesaj de bun venit Este utilizat un flux standard de iesire | |
*/ | |
System.out.println("Bun venit in lumea Java!"); | |
} | |
} |
Comentarii pentru generarea de documentatie sunt introduse prin intermediul caracterelor /** si se inchid prin */. Programatorul poate include comentarii de documentare in codul sursa, inaintea declaratiei unei clase, interfete, metode, constructor sau atribut.
/** | |
* Clasa BunVenit exemplifica afisarea unui mesaj de bun venit | |
* | |
* @author airman | |
* @version 1.0 | |
*/ | |
public class BunVenit { | |
/** | |
* @param nume sir de caractere folosit pentru transmiterea numelui | |
* @return returneaza un mesaj de bun venit personalizat | |
* | |
* <pre> | |
* {@code | |
* public static String mesaj(String nume) { | |
* String mesaj = "Bun venit in lumea Java " + nume; | |
* return mesaj; | |
* } | |
* } | |
* </pre> | |
*/ | |
public static String mesaj(String nume) { | |
String mesaj = "Bun venit in lumea Java " + nume; | |
return mesaj; | |
} | |
/** | |
* Metoda main()<br> | |
* Utilizeaza {@link #mesaj(String)} pentru a personaliza mesajul | |
* | |
* @param args tablou care contine parametri din linia de comanda | |
*/ | |
public static void main(String args[]) { | |
System.out.println(mesaj("Popescu Vlad")); | |
} | |
} |
Tipuri de date primitive si referinte
Java pune la dispozitia programatorilor opt tipuri de date primitive. Un tip de date primitiv este predefinit, iar denumirea sa este un cuvant rezervat. Cele opt tipuri de date primitive suportate de limbajul de programare Java sunt: byte, short, int, long, float, double, boolean, char.
In afara tipurilor de date primitive, Java ofera suport special pentru sirurile de caractere prin intermediul clasei java.lang.String.
public class TestString { | |
public static void main(String[] args) { | |
String nickname = "airman"; | |
String prenume = new String("Vasile"); | |
java.lang.String nume = new java.lang.String("Popescu"); | |
System.out.print("Numele meu este " + nume + " " + prenume); | |
System.out.print(" si folosesc porecla " + nickname + '.'); | |
} | |
} |
Tip date | Semnificatie |
---|---|
byte | numere intregi pe 8 biti, avand valori cuprinse intre –128 si 127 |
short | numere intregi pe 16 biti, avand valori cuprinse intre –32768 si 32767 |
int | numere intregi pe 32 biti, avand valori cuprinse intre –2147483648 si 2147483647 |
long | numere intregi pe 64 biti, avand valori cuprinse intre – 9223372036854775808 si 9223372036854775807 |
float | numere in virgula mobila si simpla precizie pe 32 biti |
double | numere in virgula mobila si dubla precizie pe 64 biti |
boolean | true, false |
char | caractere UNICODE pe 16 biti |
Numele meu este Popescu Vasile si folosesc porecla airman.
Tipuri de date speciale sunt referintele; din aceasta categorie fac parte tablourile, clasele si interfetele. O variabila de acest tip este o adresa de memorie catre o valoare sau multime de valori.
Declararea variabilelor
O variabila are un nume, un tip, o valoare. Declararea unei variabile specifica numele si tipul variabilei; optional poate specifica si o valoare initiala.
In limbajul Java sunt definite patru tipuri de variabile: variabile instanta, variabile clasa, variabile locale si parametri.
Variabile instanta (atribute non-statice) sunt utilizate pentru a salva starea obiectelor. Se numesc variabile instanta deoarece valorile lor sunt unice pentru fiecare instanta a clasei. Variabile clasa (atribute statice) se declara prin intermediul modificatorului static. Acestea detin o valoare unitara pentru toate instantele clasei. Variabile locale reprezinta variabilele declarate in interiorul unei metode.
Pentru a defini variabile finale sau constante trebuie utilizat modificatorul final, inaintea denumirii constantei.
public class Tipuri { | |
// variabila clasa | |
static int nrObj = 0; | |
// variabile instanta | |
byte nByte; | |
short nShort; | |
int nInt; | |
long nLong; | |
float nFloat; | |
double nDouble; | |
boolean bLogic; | |
char cChar; | |
public Tipuri() { | |
nrObj++; | |
} | |
@Override | |
public String toString() { | |
// variabila locala | |
String mesaj; | |
mesaj = "Tipuri " + nrObj + "\n" + " [nByte=" + nByte + ", nShort=" + nShort + ", nInt=" + nInt + ", nLong=" | |
+ nLong + ", nFloat=" + nFloat + ", nDouble=" + nDouble + ", bLogic=" + bLogic + ", cChar=" + cChar | |
+ "]"; | |
return mesaj; | |
} | |
public static void main(String args[]) { | |
Tipuri t1 = new Tipuri(); | |
t1.nByte = 127; | |
t1.nShort = 32; | |
t1.nInt = 143; | |
t1.nLong = 143L; | |
t1.nFloat = 143.24F; | |
t1.nDouble = 143.24; | |
t1.bLogic = false; | |
t1.cChar = 'X'; | |
System.out.println(t1); | |
Tipuri t2 = new Tipuri(); | |
System.out.println(t2); | |
} | |
} |
Tipuri 1 [nByte=127, nShort=32, nInt=143, nLong=143, nFloat=143.24, nDouble=143.24, bLogic=false, cChar=X] Tipuri 2 [nByte=0, nShort=0, nInt=0, nLong=0, nFloat=0.0, nDouble=0.0, bLogic=false, cChar= ]
Operatorii si precedenta lor
Operatorii sunt simboluri speciale care permit implementarea operatiilor dintre operanzi. Dupa tipul lor operatorii Java pot fi clasificati dupa cum urmeaza.
Categorie | Lista operatori |
---|---|
operatori de asignare | =, +=, –=, *=, /=, %= |
operatori relationali | ==, !=, <, >, <=, >= |
operatori logici | &&, ||, ^, ! |
operatori logici pe biti | &, |, ^ |
operatori aritmetici | +, –, *, /, % |
operatori de translatie | <<, >>, >>> |
operatori de incrementare / decrementare | ++, –– |
operator conditional | (expresie_logica) ? valoare_adevarat: valoare_fals |
operator de concatenare a sirurilor | + |
operatori pentru modificare tip (cast) | (tip_data) |
Operatorii de atribuire aritmetica (+= –= *= /= %=) ofera o modalitate mai simpla de atribuire a unei valori. De exemplu, urmatoarele doua linii au acelasi rezultat.
a = a + 1; a += 1;
Java include un operator special care poate inlocui instructiuni conditionale if-else. Acest operator poarta numele de operator conditional si are urmatorul format:
expresie1 ? expresie2 : expresie3
Daca in urma evaluarii expresiei1 rezulatatul este adevarat, atunci se evalueaza expresie2 si rezultatul acesteia devine rezultatul operatiei. In caz contrar, se evalueaza expresie3 si rezultatul acesteia devine rezultatul operatiei.
class OpCond { | |
public static void main(String[] args) { | |
int varsta = 15; | |
String tipPersoana; | |
tipPersoana = (varsta < 18) ? "adolescent" : "tanar"; | |
System.out.println("Varsta " + varsta + " ani corespunde unui " + tipPersoana + "."); | |
} | |
} |
Varsta 15 ani corespunde unui adolescent.
In evaluarea expresiilor un rol important poarta precedenta operatorilor. Operatorii cu precedenta mai mare sunt evaluati inaintea operatorilor cu precedenta mai scazuta.
Schimbarea de tip se poate realiza implicit, prin intermediul compilatorului, sau explicit, in cazul in care utilizatorul precizeaza conversia dorita. Trebuie avut in vedere faptul ca aceasta conversie poate provoca pierderea preciziei.
class Casting { | |
public static void main(String[] args) { | |
// conversie implicita | |
double media; | |
int a = 43; | |
short b = 15; | |
media = (a + b) / 2; | |
System.out.println("Media = " + media); | |
// conversie explicita | |
char c = 'a'; | |
int d = 99; | |
System.out.println("Conversie de la char la int: " + (int) c); | |
System.out.println("Conversie tip de la int la char: " + (char) d); | |
} | |
} |
Media = 29.0 Conversie tip de la char la int: 97 Conversie tip de la int la char: c