În general vorbind, structura ierarhică se foloseşte pentru a organiza

anumite elemente în raport cu relaţiile şi legăturile ce există între

aceste elemente. Un bun exemplu pentru aceasta este file system. Cu
toţi ştim că file system sau sistemul de fişiere reprezintă organizarea
ierarhică a folderelor din cadrul unui depozit de date. În acest mod, ne
este simplificată navigarea atunci când lucrăm cu o mare cantitate de
date.

În acelaşi mod putem percepe şi pachetele în Java. Acestea reprezintă

un sistem pentru clasificarea standardizată a bibliotecilor claselor sau,
cu alte cuvinte, ne permite să introducem toate clasele, despre care
credem că au acelaşi context, într-un anumit pachet pentru a le găsi
mai uşor. În afară de o navigare simplificată, pachetele ne asigură şi
existenţa claselor cu aceeaşi denumire în cadrul aceluiaşi proiect.

În Java, un pachet reprezintă un spaţiu de nume unic, care poate

conţine o combinaţie de clase, interfeţe şi alte pachete. Doar tipurile
declarate cu cuvântul cheie public pot fi vizibile în afara pachetului. În
acelaşi mod, fiecare constantă, constructor, metodă sau tip imbricat
trebuie să fie declarat cu cuvântul cheie public pentru a fi vizibili şi în
afara unui pachet.

Java susţine două tipuri de pachete:

Pachetele încorporate

Pachetele definite de utilizator

Imaginea 19.1 Clasificarea pachetelor în Java

Pachete standard încorporate în limbajul Java

Pachetele standard, încorporate în limbajul de programare Java, sunt

organizate într-o structură ierarhică la fel ca în imaginea de mai jos:

Imaginea 19.2 Structura pachetelor încorporate

Termenul "încorporat" poate fi neclar. La ce ne referim atunci când

spunem că ceva este încorporat în limbajul de programare Java? Când
spunem încorporare, ne referim la toate funcţionalităţile care ne sunt
disponibile în mod automat în timpul scrierii unui program. Desigur,
aceste funcţionalităţi trebuie create de cineva pentru ca noi să le
putem folosi. Vom lua ca exemplu funcţia matematică încorporată pow.

double result = Math.pow(4, 2);

În codul de mai sus am declarat o variabilă de tip double cu denumirea
result, în care vom introduce valoarea calculului din partea dreaptă a
semnului egal. În partea dreaptă folosim funcţia încorporată pow a
clasei Math. Îi transmitem două valori, iar calculul complet este realizat
în mod automat de această funcţie. Rezultatul calculării va fi 16,
fiindcă 4 la puterea 2 este egal cu 16. În acest mod am folosit o
metodă încorporată, care există în cadrul clasei încorporate Math.
Fiecare clasă încorporată în limbajul de programare Java se găseşte
într-un pachet, ceea ce este în concordanţă cu cele menţionate, şi
anume că fiecare clasă trebuie să facă parte dintr-un pachet din
motive de ierarhie şi organizare.

De asemenea, în imaginea de mai sus putem vedea că pachetele

încorporate în Java pot începe cu java sau cu javax. O regulă generală
este aceea că pachetele care încep cu java sunt pachete de bază, în
timp ce pachetele care încep cu javax reprezintă upgrade-uri. De
asemenea, probabil aţi obervat că pachetele încorporate au la rândul
lor subpachete. De exemplu, un subpachet al pachetului java ar fi awt,
în timp ce şi awt are subpachetul său event. Acest lucru este normal şi
am menţionat deja că pachetele, pe lângă clase şi interfeţe, mai pot
conţine şi alte pachete.

Haideţi să vedem acum ce pachete de bază există în limbajul de

programare Java:

Denumirea pachetului Descriere

java.lang funcţionalităţi de bază ale

limbajului Java, precum tipurile
integrate
java.util colecţii, evenimente,
internaţionalizare
java.io lucrul cu fluxurile de date de
intrare şi de ieşire
java.math BigInteger, BigDecimal
 java.nio lucrul cu buffer-ele
java.net suport pentru reţea, URL, socket
programming, adrese IP
java.security suport pentru securitate, criptare,
decriptarea, generarea cheilor
java.sql suport pentru lucrul cu bazele de
date
java.awt set integrat de clase pentru
crearea interfeţei de utilizator
java.applet suport pentru crearea applet-ului
java.time gestionarea datei şi a timpului

Singurul pachet care nu necesită un import precedent este java.lang.

Acest pachet este importat în mod automat în fiecare program Java.
Toate celelalte pachete necesită importarea, respectiv referenţierea în
cadrul clasei în care se folosesc. Importarea unui pachet necesar se
realizează în felul următor:

import java.awt;

Astfel am executat importarea întregului pachet pentru crearea

mediului de utilizator awt. Haideţi să vedem acest lucru pe un exemplu
practic.
 Imaginea 19.3 Importarea clasei Rectangle

În codul de mai sus am instanţiat un obiect al clasei Rectangle, care se

foloseşte pentru schiţarea unui dreptunghi în cadrul ferestrei aplicaţiei.
Mediul a semnalat o eroare, fiindcă în cadrul clasei noastre nu este
specificată referinţa la clasa pe care vrem să o instanţiem. De aceea,
putem alege prima opţiune oferită, iar mediul va adăuga pentru noi
următoarea referinţă:

import java.awt.Rectangle;

Pachetele definite de utilizator

În afară de pachetele încorporate cu care ne-am familiarizat în capitolul

precedent, în Java există şi pachete definite de utilizator. Acestea sunt
pachetele pe care le creează utilizatorul, respectiv programatorul. Am
menţionat deja de mai multe ori că fiecare clasă trebuie să facă parte
dintr-un pachet. Pachetele definite de utilizator ne permit definirea
claselor cu aceeaşi denumire, atâta timp cât aceste clase se găsesc în
pachete separate. Haideţi să vedem cum arată o ierarhie a pachetelor
definite de utilizator:
 Imaginea 19.4 Structura pachetelor definite de utilizator

Reprezentarea fizică nu este nimic altceva decât fişiere .java obişnuite,

clasificate în foldere. Conform acestei logici, schema precedentă în file
system ar fi arătat astfel:

Project(folder)
Package 1(folder)
MyClass.java
Package 2(folder)
MyClass.java

Respectiv:

Path/Project/Package1/MyClass.java
Path/Project/Package2/MyClass.java

Crearea pachetelor

Haideţi să vedem acum cum se creează pachetele în cadrul mediului

de dezvoltare NetBeans. În NetBeans pachetul se creează simplu, în
aşa fel încât dăm clic dreapta pe proiect şi alegem opţiunea New, apoi
opţiunea JavaPackage.

Imaginea 19.5 Crearea pachetelor Java

În noua fereastră deschisă se poate introduce denumirea pachetului.

Ca denumire putem alege orice, chiar şi un cuvânt cheie al limbajului,
atâta timp cât respectăm aceleaşi convenţii ca şi la denumirea
variabilelor. De asemenea, există o convenţie despre denumirea
pachetelor conform căreia aceasta trebuie să înceapă cu literă mică
pentru a deosebi pachetele de clase. Location reprezintă locaţia în
cadrul proiectului. Cele două locaţii oferite sunt Source şi Test
Packages. Test Packages conţine clase de testare, în timp ce proiectul
complet se găseşte în secţiunea Source Packages. Această secţiune
este selectată în mod implicit.

Imaginea 19.6 Denumirea pachetelor Java

După creare, pachetul va apărea în folderul locaţiei alese sub formă de

subfolder şi toate clasele create cu acest pachet se vor găsi în folderul
locaţiei respective. Totuşi, aceasta nu înseamnă că, dacă am vom crea
o clasă file şi dacă o vom pune în folderul pachetului, clasa va fi în mod
automat vizibilă. Clasa (adică fişierul în care se găseşte aceasta) va fi
disponibilă în cadrul unui pachet doar atunci când se adaugă directiva
package. De exemplu:

package mypackage;
În cadrul unui fişier se poate găsi o singură directivă package. Mai
multe directive package într-un fişier vor semnala o eroare în timpul
interpretării.

Următorul exemplu ilustrează o directivă corectă a pachetului de clase:

package mypackage;
public class MyClass {
}

În cazul în care directiva nu este specificată, se consideră că clasa se

găseşte în pachetul implicit (Default Package). În sistemul de fişiere,
acest pachet este de fapt folderul de bază al claselor (src), adică
folderul root al tuturor claselor. Nu se recomandă localizarea
bibliotecilor de clase în acest spaţiu.

Manipularea pachetelor

Toate clasele găsite în pachetul cu aceeaşi denumire sunt vizibile

reciproc, fără o evidenţiere explicită, însă nu pot să vadă clasele
membre ale altor pachete. Dacă vrem să specificăm că dorim o clasă
dintr-un pachet în care nu ne găsim momentan, acest lucru
trebuie specificat explicit.

În capitolul precedent am creat pachetul mypackage. Vom repeta

acum procesul de creare a pachetului în aşa fel încât vom crea încă un
pachet cu denumirea yourpackage. Structura proiectului nostru va
arăta astfel:
 Imaginea 19.7 Structura pachetelor

Haideţi să creăm acum câte o clasă în fiecare pachet. În pachetul

mypackage vom crea clasa MyClass, iar în pachetul yourpackage vom
crea clasa YourClass.

Dacă acum dorim ca din clasa MyClass să accesăm clasa YourClass,

aflată în pachetul yourpackage, trebuie să facem în felul următor:

package mypackage;
public class MyClass {
yourpackage.YourClass class1 = new yourpackage.YourClass();
}

O astfel de soluţie, deşi funcţională, nu este foarte elegantă, în special

dacă dorim să instanţiem clasa de mai multe ori. În loc de aceasta,
pachetul se implementează, în cele mai frecvente cazuri, o singură
dată în pagină, după care acesta este tratat ca parte componentă a sa.
Implementarea pachetului în cadrul unei pagini se execută cu cuvântul
cheie import şi de obicei se găseşte în vârful documentului actual.
Pentru exemplul de mai devreme, directiva import ar arăta astfel:

import yourpackage.YourClass;
După această directivă, am putea să ne adresăm clasei ca şi cum
aceasta s-ar afla în pachetul curent, aşadar, instanţierea ar arăta astfel:

YourClass class1 = new YourClass();

Uneori, pachetul pe care vrem să-l implementăm poate avea mai mult
de o singură clasă de care avem nevoie. În acest caz, putem
implementa toate clasele necesare, folosind acelaşi procedeu:

import yourpackage.YourClass;
import yourpackage.YourClass1;
import yourpackage.YourClass2;

Din cele menţionat mai sus putem ajunge uşor la concluzia că pe

pagină se pot găsi mai multe directive import.

Dacă dorim să implementăm toate clasele unui pachet, aceasta o

putem face cu semnul *.

De exemplu, următoarea directivă implementează toate clasele

pachetului yourpackage:

import yourpackage.*;

Atunci când importăm pachete, trebuie să fim atenţi, fiindcă poate

avea loc o suprapunere a claselor. Dacă două pachete importate au
două clase cu aceeaşi denumire, atunci, chiar dacă pachetul este
importat, nu vom putea să folosim clasele cu aceeaşi denumire doar
prin introducerea denumiri, ci trebuie să specificăm explicit şi
denumirea pachetului. De exemplu, dacă pachetele mypackage şi
yourpackage conţin clasele MyClass, următorul cod va semnala o
eroare, fiindcă clasa MyClass se găseşte în ambele pachete.
import yourpackage.*;
import mypackage.*;
...
MyClass mc = new MyClass();

În acest caz, clasa MyClass trebuie instanţiată cu ajutorul căii

complete:

yourpackage.MyClass mc1 = new yourpackage.MyClass();

şi

mypackage.MyClass mc2 = new mypackage.MyClass();

Am spus deja că, pe lângă clase şi interfeţe, pachetele mai pot conţine şi alte
pachete, aşadar se poate crea o structură de pachete mai adâncă decât un singur nivel.
De exemplu:

Subpachetul se creează la fel ca şi pachetul, numai că, în loc să

poziţionăm mouse-ul pe Source Packages, îl vom poziţiona pe pachetul
propriu-zis:
 Imaginea 19.8 Crearea subpachetelor

După ce subpachetul este creat, acesta trebuie implementat la fel ca şi

pachetele. Aşadar, dacă implementăm pachetul în felul următor:

import mypackage.*;

aceasta nu înseamnă că am implementat în mod automat şi toate

clasele subpachetului din pachetul mypackage, ci pentru aceasta
trebuie să scriem următoarele:

import mypackage.*;
import mypackage.mysubpackage.*;
JAR (Java Archive)

Java Archive (sau prescurtat - JAR) reprezintă un format de fişier care

permite expedierea automată a unui număr mai mare de fişiere în
cadrul unei arhive. JAR este o arhivă ZIP care conţine clase binare cu
extensia .class şi anumite meta fişiere care ne spun cum se foloseşte
arhiva JAR. Fişierele JAR sunt foarte utile pentru distribuirea unui număr
mai mare de clase, motiv pentru care trebuie să deţină o portabilitate
şi o securitate pronunţată.

După interpretarea (şi construirea) proiectului, interpreterul va

transfera întreaga structură a pachetelor în proiectul construit, adică în
folderul build. De asemenea (dacă setările NetBeans sunt cele
implicite), în folderul dist va fi creat fişierul .jar cu denumirea
proiectului ca nume propriu. Opţiunea pentru crearea fişierelor JAR se
poate dezactiva prin opţiunea Build JAR After Compiling. Această
opţiune se găseşte în opţiunile proiectului (clic dreapta pe proiect şi
alegeţi opţiunea Properties), subopţiunea Build, subopţiunea
Packaging:

Imaginea 19.9 Opţiunea destinată creării fişierelor JAR