Tipuri de date

Tipurile primitive
Valoare
Tip Dimensiune Valori
implicita

byte 0 8 b cu semn [-128,127] ∩ N

short 0 16 b cu semn [-32768,32767] ∩ N
int 0 32 b cu semn [-231,231-1] ∩ N
long 0L 64 b [0,264-1] ∩ N
float 0.0f 32 b v.m. s.p. m:24,e:8
double 0.0d 64 v.m. d.p m:53, e:11

char '\u0000' 16 b Unicode

boolean false 1b true, false

 Masive
Declarare referinta:
[public|protected|private] [static] [transient] [volatile] [final] <tip>[][[]..]
<variabila>[=<initializare>][,<variabila>[=<initializare>] … ]

Alocare:
<variabila> = new <tip>[n1][[n2]..]

double[][] x={{1,2,3},{1,2},{1,2,3,4}};
double[][] y=new double[][]{{1,2,3},{23,45,67,89}};

Object[][] o = {{"Liviu","Diana"},{23,56,90},{3.14}};
for(Object linie[]:o){
System.out.println();
for(Object e:linie){
System.out.print(e+" ");
}
}
Object[][] v = {new String[]{"Liviu","Diana"},new Integer[]{23,56,90},new
Double[]{3.14}};
 Tipul Enum
• Tipul Enum este un tip special de clasa utilizat pentru definirea de constante cu o
structura complexa
• Sintaxa:
[public|protected|private] enum numeEnum {
CONSTANTA_1,CONSTANTA_2,...,CONSTANTA_N;
[numeEnum(lista_parametrii){...}]
[ Campuri_si_metode ]
}
• Modificatorii protected și private pot apărea doar când enumerarea este interna
unei clase
• Compilatorul adaugă la crearea enumerării o metoda statică values() care întoarce
intr-un vector constantele definite prin enumerare
• Enumerările nu pot fi instantiate. Constructorul permite asocierea de valori
constantelor din enumerare.
 Metode Enum
Ca orice clasă, Enum conține metode statice și de instanță care permit o
gestionare flexibilă a conținutului:
public final String name(); // Numele de tip String al enumerării
public final int ordinal(); // Numărul de ordine în cadrul enumerării
public static T valueOf(String name); //Întoarce valoarea
corespunzătoare șirului specificat prin name
 public enum Cartier {
AVIATIEI(2),DRUMUL_TABEREI(2),UNIRII(0);
private final int zona;
Cartier(int zona){ this.zona=zona; } public class Imobil {
public int getZona() { return zona; } public Cartier cartier;
} public double valoare;
public Cartier getCartier() { return cartier; }
public void setCartier(Cartier cartier) {
public static void main(String[] args) { this.cartier = cartier; }
Imobil i1=new Imobil(); public double getValoare() { return valoare; }
i1.setValoare(100000); public void setValoare(double valoare) {
i1.setCartier(Cartier.AVIATIEI); this.valoare = valoare;
System.out.println("Impozit:"+i1.impozit()); }
System.out.println("Cartierul Aviatiei:"+ public double impozit() {
Cartier.AVIATIEI.name()); switch (cartier.getZona()) {
System.out.println("Cartiere:"); case 0:
for(Cartier c:Cartier.values()){ return valoare * 0.2;
System.out.print(c+" "); case 1:
} return valoare * 0.1;
Cartier cartier=Cartier.valueOf("AVIATIEI"); default:
System.out.println("\nConstanta pentru Aviatiei:" return valoare * 0.05;
+cartier); }
} }
}
 Obiecte immutable

Sunt obiecte a căror stare (conținut) nu poate fi modificată.

Clase immutable: String, Integer, Long, Short, Double, Float, Character,
Byte, Boolean.
Reguli pentru crearea unei clase immutable:
1. Nu sunt furnizate metode de scriere pentru câmpuri ("setter" methods)
2. Câmpurile sunt declarate cu modificatorii final și private
3. Clasele immutable nu pot fi extinse fiind declarate final
4. Câmpurile de tip referință trebuie să fie referințe la clase care sunt la
rândul lor immutable
Module Java
 Ce este un modul?

• Un modul este un nou nivel de organizare a codului, aflat peste nivelul pachetelor
• Fiecare modul descrie ce pachete sunt expuse și de ce pachete ale altor module depinde aplicația
• Într-un modul pot fi utilizate numai clasele publice exportate de alte module
• Un modul poate fi considerat un container de pachete
Necesitate
• JDK este prea mare pentru dispozitive mici. Fișierele JAR, cum ar fi rt.jar, sunt prea mari pentru a
fi utilizate pe dispozitive și aplicații mici.
• Prin modularizare se permite accesul numai la clasele pe care dorim să le folosească alții
 Descrierea modulelor
• Fiecare modul conține un fișier descriptor care descrie structura modulului cu numele module-
info.java. În fișierul descriptor sunt definite mai multe aspecte ale modulului cum ar fi numele
modulului, o lista modulelor de care depinde acest modul sau o lista cu toate pachetele pe care le
dorim accesibile din afara modulului. Aceste elemente sunt inserate prin directive precum:
• requires - permite declararea dependințelor
module my.module {
requires module.name;
}
• exports - permite exportarea pachetelor. În mod implicit, un modul nu expune nici un pachet al
său altor module.
module my.module {
exports com.my.package.name;
}
module my.module {
export com.my.package.name to com.specific.package;
}
 Tipuri de module

• Module de sistem - Acestea sunt modulele standard ale distribuției Java, enumerate atunci când
rulăm comanda java --list-modules. Acestea includ modulele Java SE și JDK.
• Module de aplicație - Acestea sunt modulele de utilizator. Sunt specificate în fișierul descriptor.
• Module automate - Modulele atașate din fișierele JAR asociate. Numele modulului va fi furnizat
de JAR.
• Modul fără nume - Sunt module asociate fișierelor JAR din versiuni anterioare.
Conversii
 Conversii de tip (type casting)

 Conversiile tipurilor primitive

 Conversii implicite
 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

 Conversii explicite (cast)

 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

 Conversii de referințe – upcasting, downcasting

Depind de legătura dintre clase/interfețe in cadrul ierarhiei. Conversiile intre referințe

sunt permise atâta timp cat tipul la care se face conversia este un tip valid. Tipuri de
referințe valide pentru un obiect dintr-o clasa oarecare, S:
• referință de tip T, daca T este o superclasa a lui S
• referință de tip I, daca I este o interfață implementata de S
Conversii implicite:
• de la referință de tip S la orice referință de tip T, unde S este o clasă derivată din T
• de la referință de tip S la orice referință de tip I, unde I este o interfață implementată
de S
• de la referință de tip J la orice referință de tip I unde J este o interfață derivată din I
Conversii explicite (cast):
• de la referință de tip I la orice referință de tip J unde I si J sunt implementate de
aceeași clasă
• de la referință de tip T la orice referință de tip S, unde S este derivată din T, dacă
referința de tip S este o referință validă pentru obiectul referit prin T
• de la referință de tip I la orice referință de tip J unde J este derivată din I, dacă
referința de tip J este valida pentru obiectul referit

Exp (E_Conversii)
Upcasting – Conversia către referințe ale
superclaselor/superinterfețelor. Este implicit
Downcasting - Conversia către referințe ale
superclaselor/superinterfețelor. Este explicit
 Conversiile de tip boxing

Sunt specifice conversiilor de la tipurile primitive la referințe ale claselor de acoperire

• boolean -> Boolean
• byte -> Byte
• short -> Short
• char -> Character
• int -> Integer
• long -> Long
• float -> Float
• double -> Double
 Conversii de tip unboxing
Sunt conversiile implicite de la referințe ale claselor la acoperire si tipurile primitive
corespunzătoare
• Boolean -> boolean
• Byte -> byte
• Short -> short
• Character -> char
• Integer -> int
• Long -> long
• Float -> float
• Double -> double

Conversii catre String. Apar in expresii ca urmare a supraîncărcării operatorului "+" pentru clasa
String
Blocuri de initializare
 Blocuri de inițializare statice

• Un bloc de inițializare static este un bloc de cod cuprins intre o pereche de paranteze si precedat
de cuvântul cheie static:
static {
// cod inițializare
}
• Este executat la momentul primei încărcări a clasei si este in general utilizat pentru inițializarea
câmpurilor statice
• Pot fi oricâte si in orice ordine, mediul de execuție asigurând execuția lor in ordinea apariției in
cadrul clasei
 Blocuri de inițializare de instanță

• Au aceeași sintaxă dar fără cuvântul cheie static

{
// cod inițializare
}
• Este executat la momentul instanțierii clasei si este in general utilizat pentru inițializarea
câmpurilor de instanță
• Compilatorul asigura copierea codului in fiecare constructor pentru a fi executat la instanțiere
public class A {
public A() { System.out.println("Constructor A"); }
static { System.out.println("Bloc initializare static clasa A"); }
{ System.out.println("Bloc initializare instanta clasa A"); }
}
public class B extends A{
public B() { System.out.println("Constructor B"); }
static { System.out.println("Bloc initializare static clasa B"); }
{ System.out.println("Bloc initializare instanta clasa B"); }
}

public static void main(String[] args) {

B b=new B();
} Output generat:

Bloc initializare static clasa A

Exp (E_BlocuriInitializare) Bloc initializare static clasa B
Bloc initializare instanta clasa A
Constructor A
Bloc initializare instanta clasa B
Constructor B
Structura alocării memoriei
Structurarea memoriei unei aplicații: Stiva, Heap, Method Area
 Stiva. Este împărțită pe thread-uri astfel:
 Program Counter Register memorează adresa instrucțiunii curente de executat
 JVM Stack - variabile locale, parametrii de metode, valori returnate si rezultate parțiale
 Native Method Stack este zona alocată pentru stivele asociate metodelor native din
cadrul unui Thread
 Heap este zona de memorie în care au loc alocările de spațiu pentru obiecte și masive.
Este comună pentru toate thread-urile procesului. Este gestionată în sensul eliberării
spațiului ocupat de către obiecte care nu mai sunt folosite de către GC
 Method Area este o zonă structurată per clasă și este echivalentă zonei de cod asociată
unei aplicații clasice C, C++. Este partajată în comun de toate threadurile procesului.
Stochează definiții de clase și interfețe, codul constructorilor și metodelor, constantele și
variabilele statice.
 Runtime Constant Pool este zona de memorie din Method Area in care sunt încărcate
toate constantele simbolice ale claselor. Acestea reprezintă datele asociate codului de
octeți al claselor. Datele din Constant Pool sunt memorate sub forma unei tabele de
simboluri.
 Ciclul de viată al unei clase

Se referă la existenta clasei in memorie

 Încărcare – Load - Încărcarea codului de octeți al clasei (byte code)
 Legare – Link
 Verificare – Verify - Verificarea codului de octeti
 Alocare – Prepare - Alocarea spațiului de memorie pentru clasa in Memory Area
 Rezolvarea referințelor simbolice din Constant Pool – Resolve – Transformarea
referințelor simbolice in referințe de memorie
 Inițializare – Initialize - Inițializarea variabilelor statice si executarea blocurilor statice
de inițializare
 Instanțiile – Instantiation - Instanțierea obiectelor
 Eliberarea spațiului ocupat de obiecte – Collection
 Finalizarea obiectelor - Finalize
 Eliberarea spațiului ocupat de clasă - Unload
 Colectarea

Mecanism prin care JVM își realizează managementul memoriei

Lansarea voluntara a colectării se poate realiza prin metodele statice ale clasei
utilitare System:

public static void gc(); // Lansarea voluntara a GC in incercarea de colectare a

tuturor obiectelor fără referință

public static void runFinalization(); // lansarea metodei finalize() pt. obiectele

colectate pentru care nu s-a rulat finalize(). Redă controlul apelatorului după
finalizare

Exp (E_GC)