
Pachetele în Java (packages) sunt grupuri de clase înrudite, organizate în foldere, care îți țin proiectul ordonat și evită conflictele de nume. Declari pachetul cu package ro.magazin.produse; pe prima linie a fișierului și folosești clasele din alte pachete cu import. Structura de foldere trebuie să corespundă exact numelui pachetului.
Dacă vrei să înveți practic, curs Java online are primele lecții gratuite, cu exerciții verificate direct în browser.
În ultima lecție din seria de bază Java vezi cum declari și importi pachete, cum se leagă ele de foldere, ce înseamnă accesul package-private, cum alegi între organizarea pe straturi și pe funcționalități și cum arată structura unui proiect Maven sau Spring Boot.
Ce sunt pachetele în Java?
Un pachet este un spațiu de nume care grupează clase, interfețe și enum-uri cu o responsabilitate comună. Îl poți vedea ca pe dosarele dintr-un birou de contabilitate: facturile într-un dosar, contractele în altul, statele de plată în al treilea. Totul ar încăpea și într-un singur sertar, dar nu ai mai găsi nimic.
Pachetele rezolvă trei probleme concrete:
- ordinea: un proiect real are sute de clase, iar pachetele le grupează după rol;
- conflictele de nume: poți avea două clase
Comanda, una înro.magazin.vanzariși una înro.magazin.furnizori, fără să se încurce; - controlul accesului: o clasă poate fi vizibilă doar în pachetul ei, ascunsă de restul aplicației.
Folosești pachete din prima zi, chiar dacă nu ai observat. String stă în java.lang, ArrayList și Scanner în java.util. De aceea scrii import java.util.Scanner; la începutul programelor care citesc de la tastatură.
Cum declari un pachet în Java?
Declarația package trebuie să fie prima instrucțiune din fișier, înaintea oricărui import, iar fișierul trebuie să stea într-un folder cu aceeași cale. Clasa Produs din pachetul ro.magazin.produse stă în ro/magazin/produse/Produs.java:
package ro.magazin.produse;
public class Produs {
private final String nume;
private final double pret;
public Produs(String nume, double pret) {
this.nume = nume;
this.pret = pret;
}
public String getNume() { return nume; }
public double getPret() { return pret; }
} Dacă fișierul stă în alt folder decât spune declarația, compilatorul sau IDE-ul te avertizează, iar clasa nu va fi găsită la rulare. În IntelliJ IDEA sau Eclipse nu creezi folderele de mână: alegi „New Package”, iar IDE-ul face și folderele, și declarația.
Cum folosești import în Java?
import îți permite să folosești o clasă din alt pachet doar cu numele ei scurt. Fără import, ar trebui să scrii de fiecare dată numele complet, de exemplu ro.magazin.produse.Produs.
package ro.magazin.comenzi;
import java.util.ArrayList;
import java.util.List;
import ro.magazin.produse.Produs;
public class Comanda {
private final List<Produs> produse = new ArrayList<>();
public void adauga(Produs produs) {
produse.add(produs);
}
public double total() {
double total = 0;
for (Produs p : produse) {
total += p.getPret();
}
return total;
}
} Există trei forme de import, iar fiecare are locul ei:
| Forma | Exemplu | Ce aduce | Când o folosești |
|---|---|---|---|
| Import de clasă | import java.util.List; | o singură clasă | mereu, ca regulă |
| Import wildcard | import java.util.*; | toate clasele din pachet, fără subpachete | rar; ascunde ce folosești de fapt |
| Import static | import static java.lang.Math.max; | un membru static, folosit fără numele clasei | constante și metode utilitare folosite des |
Două lucruri pe care le întreabă toți începătorii. Clasele din java.lang (String, Math, Integer, System) sunt importate automat. Iar import nu copiază cod și nu încetinește programul: e doar o scurtătură de nume pentru compilator.
Cum compilezi și rulezi un proiect cu pachete?
Din linia de comandă, compilezi toate fișierele și rulezi clasa principală după numele ei complet. Pentru un proiect cu sursele în folderul src:
src/
└── ro/magazin/
├── App.java
├── comenzi/Comanda.java
└── produse/Produs.java
javac -d out $(find src -name "*.java")
java -cp out ro.magazin.App Opțiunea -d out pune fișierele .class în folderul out, cu aceeași structură de pachete, iar -cp out îi spune JVM-ului unde să le caute. Clasa principală arată așa:
package ro.magazin;
import ro.magazin.comenzi.Comanda;
import ro.magazin.produse.Produs;
public class App {
public static void main(String[] args) {
Comanda comanda = new Comanda();
comanda.adauga(new Produs("Carte Java", 59.90));
comanda.adauga(new Produs("Cană", 25.00));
System.out.println("Total: " + comanda.total() + " lei"); // Total: 84.9 lei
}
} În practică, IDE-ul și Maven fac acești pași pentru tine. Merită totuși să îi rulezi o dată de mână, ca să înțelegi ce se întâmplă când apasă cineva „Run”. Dacă te interesează ce face JVM-ul cu fișierele .class, revezi prima lecție din serie, despre cum funcționează Java, JVM și bytecode.
Ce înseamnă package-private?
Package-private este nivelul de acces implicit, când nu scrii niciun modificator: clasa sau membrul e vizibil doar în interiorul aceluiași pachet. E un instrument bun pentru a ascunde detaliile de implementare.
package ro.magazin.produse;
class CalculStoc { // fără public: package-private
static int rezerva(int stoc, int bucati) {
return stoc - bucati;
}
} Orice clasă din ro.magazin.produse poate folosi CalculStoc. Din ro.magazin.comenzi, compilatorul refuză cu „CalculStoc is not public in ro.magazin.produse; cannot be accessed from outside package”. Exact asta vrei: restul aplicației lucrează cu Produs, nu cu detaliile din spatele lui.
Recapitularea celor patru niveluri de acces, pe care acum le ai pe toate:
| Modificator | Aceeași clasă | Același pachet | Subclasă din alt pachet | Oriunde |
|---|---|---|---|---|
public | da | da | da | da |
protected | da | da | da | nu |
| fără modificator | da | da | nu | nu |
private | da | nu | nu | nu |
Un detaliu care surprinde: subpachetele nu au acces special la pachetul părinte. Pentru Java, ro.magazin.produse și ro.magazin.produse.reduceri sunt două pachete complet separate, chiar dacă unul stă în folderul celuilalt.
Cum se numesc pachetele corect?
Numele de pachete se scriu cu litere mici, fără spații sau cratime, și pornesc de la domeniul firmei scris invers. Un proiect al unei firme cu domeniul magazin.ro va avea pachete de forma ro.magazin.produse, ro.magazin.comenzi. Convenția vine din recomandările Oracle pentru denumirea pachetelor și garantează că două biblioteci de la firme diferite nu ajung să aibă aceleași nume.
Pentru proiectele personale, poți folosi ro.numeleTau.proiect sau com.github.utilizator.proiect. Evită diacriticele, cuvintele rezervate (int, class) și numele prea generale ca diverse sau chestii.
Cum organizezi un proiect Java: pe straturi sau pe funcționalități?
Ai două variante de organizare, iar pentru proiectele mici și medii, organizarea pe funcționalități e de obicei mai ușor de întreținut. Pentru un începător, oricare dintre ele e mult mai bună decât toate clasele într-un singur pachet.
// Pe straturi (după rolul tehnic)
ro.magazin.controller → ProdusController, ComandaController
ro.magazin.service → ProdusService, ComandaService
ro.magazin.repository → ProdusRepository, ComandaRepository
ro.magazin.model → Produs, Comanda
// Pe funcționalități (după domeniu)
ro.magazin.produse → Produs, ProdusService, ProdusRepository
ro.magazin.comenzi → Comanda, ComandaService, ComandaRepository
ro.magazin.plati → Plata, PlataCard, ServiciuPlati Organizarea pe straturi e cea pe care o vei vedea în multe tutoriale de Spring Boot. E ușor de înțeles la început, dar când lucrezi la comenzi, sari între patru pachete. Organizarea pe funcționalități ține tot ce ține de comenzi într-un singur loc și îți permite să faci package-private clasele interne ale fiecărei funcționalități. Ce contează mai mult decât varianta aleasă: echipa o respectă consecvent.
Cum arată structura unui proiect Maven sau Spring Boot?
Maven, unealta de build folosită în majoritatea proiectelor Java, impune o structură standard de foldere, iar Spring Boot o preia ca atare:
magazin/
├── pom.xml ← dependențele și configurarea build-ului
└── src/
├── main/
│ ├── java/ro/magazin/ ← codul aplicației, pe pachete
│ │ ├── MagazinApplication.java
│ │ ├── produse/
│ │ └── comenzi/
│ └── resources/ ← fișiere de configurare, șabloane
└── test/
└── java/ro/magazin/ ← testele, cu aceleași pachete Testele stau în aceleași pachete ca și codul testat, dar în folderul test. Așa pot accesa și clasele package-private. În Spring Boot, clasa principală (MagazinApplication) stă în pachetul rădăcină, deasupra tuturor celorlalte, pentru că Spring caută componentele doar în pachetul ei și în subpachete. O clasă pusă în afara acestui arbore nu va fi găsită.
Ce greșeli fac începătorii cu pachetele?
Greșelile cu pachete apar mai ales când proiectul crește peste zece-cincisprezece clase.
- Toate clasele în pachetul implicit. Fără nicio declarație
package, clasele stau în „default package”, din care nu pot fi importate de nicăieri. E în regulă pentru un exercițiu, nu pentru un proiect. - Prea multe pachete de la început. Un proiect cu șase clase nu are nevoie de opt pachete. Împarte când apare nevoia.
- Folderul nu corespunde cu declarația. Mută fișierele din IDE (Refactor → Move), nu din Finder sau Explorer.
- Totul
public. Clasele ajutătoare pot rămâne package-private. Cu cât expui mai puțin, cu atât poți schimba mai liber. - Un pachet
utiluriaș. Dacă tot ce nu știi unde să pui ajunge înutil, pachetul devine un sertar de vechituri. Caută-i fiecărei clase locul după domeniu. - Dependențe circulare. Dacă
produsefoloseștecomenzișicomenzifoloseșteproduse, cele două nu mai pot fi înțelese separat. Una dintre ele ar trebui să depindă de cealaltă, nu amândouă.
Exercițiu: organizează platforma de cursuri
Ia exercițiile din lecțiile anterioare (Cursant, Curs, Lectie, ServiciuNotificari, NotificatorEmail) și pune-le într-un proiect cu pachetele ro.platforma.cursuri, ro.platforma.cursanti și ro.platforma.notificari, plus o clasă App în ro.platforma. Compilează-l o dată din linia de comandă, cu javac -d, și rulează-l cu java -cp.
Apoi fă package-private tot ce nu trebuie folosit din afara pachetului și verifică dacă proiectul mai compilează. Fiecare eroare îți arată o dependență între pachete pe care poate nici nu știai că o ai.
Întrebări frecvente
Ce este un package în Java?
Este un spațiu de nume care grupează clase înrudite și corespunde unui folder pe disc. Se declară cu package pe prima linie a fișierului.
Este obligatoriu să folosesc pachete?
Nu, pentru programe mici poți lucra fără, în pachetul implicit. Pentru orice proiect cu mai multe clase sau care va fi folosit de alții, pachetele sunt practic obligatorii.
Care este diferența dintre package și import?
package spune în ce pachet stă clasa curentă și apare o singură dată. import spune ce clase din alte pachete folosește fișierul și pot fi oricâte.
Pot exista două clase cu același nume?
Da, dacă sunt în pachete diferite. Exemplul clasic e java.util.Date și java.sql.Date. Dacă ai nevoie de amândouă în același fișier, imporți una și pe cealaltă o scrii cu numele complet.
Importul wildcard include subpachetele?
Nu. import java.util.*; aduce clasele din java.util, dar nu și pe cele din java.util.function sau java.util.stream, care trebuie importate separat.
Primul pas: mută-ți exercițiile în pachete
Creează azi un proiect nou în IDE, adaugă trei pachete după domeniu și mută acolo clasele scrise în lecțiile de OOP. Vei folosi aceeași structură în orice proiect Java din portofoliu, iar un recrutor tehnic care deschide repository-ul tău o observă repede.
Cu lecția asta ai terminat seria de bază: de la JVM și variabile până la clase, moștenire, polimorfism și organizarea proiectului. Pasul următor e să le exersezi pe proiecte reale, cu exerciții verificate automat. Primele lecții ale cursului de Java sunt gratuite, scrii codul direct în browser, iar Profu’, tutorele AI din lecții, îți dă indicii când te blochezi. Dacă vrei să vezi ce mai urmează după Java până la primul job (Git, SQL, Docker), uită-te la traseul de Java Developer.
Lecția anterioară: constante și final în Java. Lecția următoare: continui cu cursul complet de Java, cu 350 de lecții și certificat la final.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
