Variabile și tipuri primitive în Java

tip nume = valoare;
int varsta = 20;
double pret = 19.99;
boolean activ = true;
char litera = 'A';

Ce face Variabile și tipuri primitive

O variabilă este o cutie cu nume în care păstrezi o valoare. În Java fiecare variabilă are un tip, stabilit la declarare și care nu se mai schimbă: int varsta = 20;. Compilatorul verifică tipurile, deci varsta = "douăzeci"; nu compilează.

Cele 8 tipuri primitive păstrează direct valoarea: întregi (byte, short, int, long), numere cu virgulă (float, double), caractere (char) și valori logice (boolean). Restul tipurilor (String, array-uri, clasele tale) sunt tipuri referință: variabila păstrează o referință către un obiect.

Variabilele locale (din metode) trebuie inițializate înainte de folosire, altfel compilatorul dă eroare. Câmpurile unei clase primesc automat valoarea implicită: 0, false, '\u0000' sau null.

Parametri

Parametru	Descriere
byte / short / int / long	Întregi pe 8, 16, 32 și 64 de biți. int este alegerea obișnuită.
float / double	Numere cu virgulă pe 32 și 64 de biți. double este alegerea obișnuită.
char	Un caracter Unicode pe 16 biți, între apostrofuri: 'ș'.
boolean	true sau false.

Exemple

Exemplul 1: Cele opt tipuri primitive

Sufixul L marchează un literal long, iar f unul float. Liniuța de jos din 1_500_000 doar ajută la citire.

public class Main {
    public static void main(String[] args) {
        byte etaj = 4;
        short an = 2026;
        int locuitoriIasi = 271_692;
        long populatieMondiala = 8_100_000_000L;
        float temperatura = 21.5f;
        double pret = 1_499.99;
        char nota = 'A';
        boolean promovat = true;

        System.out.println("etaj: " + etaj + ", an: " + an);
        System.out.println("Iași: " + locuitoriIasi + " locuitori");
        System.out.println("Lume: " + populatieMondiala);
        System.out.println("temperatură: " + temperatura + " °C");
        System.out.println("preț: " + pret + " lei");
        System.out.println("calificativ: " + nota + ", promovat: " + promovat);
    }
}

Rezultat

etaj: 4, an: 2026
Iași: 271692 locuitori
Lume: 8100000000
temperatură: 21.5 °C
preț: 1499.99 lei
calificativ: A, promovat: true

Exemplul 2: Limitele tipurilor și conversiile

Conversia spre un tip mai mare (int → long, int → double) este automată. Spre un tip mai mic trebuie un cast explicit, iar valoarea se poate pierde: 300 nu încape într-un byte și devine 44.

public class Main {
    public static void main(String[] args) {
        System.out.println("int: " + Integer.MIN_VALUE + " .. " + Integer.MAX_VALUE);
        System.out.println("byte: " + Byte.MIN_VALUE + " .. " + Byte.MAX_VALUE);

        int puncte = 85;
        long mare = puncte;        // automat
        double cuVirgula = puncte; // automat
        System.out.println(mare + " " + cuVirgula);

        double medie = 9.75;
        int rotunjitInJos = (int) medie; // cast: se taie zecimalele
        System.out.println("(int) 9.75 = " + rotunjitInJos);

        int prea = 300;
        byte mic = (byte) prea;          // nu încape, se pierd biți
        System.out.println("(byte) 300 = " + mic);
    }
}

Rezultat

int: -2147483648 .. 2147483647
byte: -128 .. 127
85 85.0
(int) 9.75 = 9
(byte) 300 = 44

Exemplul 3: Primitive și referințe

La primitive se copiază valoarea. La un array (tip referință) se copiază referința, deci ambele variabile văd același obiect.

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = a;   // copie a valorii
        b = 20;
        System.out.println("a = " + a + ", b = " + b);

        int[] note = {7, 8, 9};
        int[] aceleasiNote = note; // copie a referinței
        aceleasiNote[0] = 10;
        System.out.println("note[0] = " + note[0]);
    }
}

Rezultat

a = 10, b = 20
note[0] = 10

Greșeli frecvente

• Folosirea unei variabile locale neinițializate: error: variable x might not have been initialized.
• Un literal întreg prea mare fără L: long n = 8000000000; dă integer number too large.
• Așteptarea ca (int) 9.99 să rotunjească: cast-ul taie zecimalele (rezultă 9). Pentru rotunjire folosește Math.round.

Comenzi înrudite

• int, long, short și byte: Tipurile întregi din Java: int (32 de biți) pentru aproape orice, long pentru valori mari, short și byte pentru economie de memorie.
• double și float: Tipurile pentru numere cu virgulă: double (64 de biți, implicit) și float (32 de biți, literal cu sufixul f).
• boolean: Tipul pentru valori logice: true sau false. Condițiile din if, while și for trebuie să fie boolean.
• char: Tipul pentru un singur caracter Unicode (16 biți), scris între apostrofuri: ‘a’, ‘Ș’, ‘\n’.
• var: Declară o variabilă locală al cărei tip este dedus de compilator din valoarea inițială; tipul rămâne fix.
• Tipuri wrapper și autoboxing: Fiecare primitiv are o clasă „înveliș” (Integer, Double, Character…); conversia automată între ele se numește autoboxing.
• final (și static final): final interzice schimbarea: o variabilă primește valoare o singură dată, o metodă nu poate fi rescrisă, o clasă nu poate fi extinsă.