Lucrarea nr.

1. Pachete

Scopul lucrării

Această lucrare are ca scop prezentarea noţiunii de pachet în vederea folosirii bibliotecilor de
clase precum şi dezvoltării sistematice de aplicaţii mari.

1.1. Noţiunea de pachet.

Un concept important în Java este acela de package (pachet). Spre deosebire de C, aici nu
există directive preprocesor de nici un fel. Rolul directivei #include este preluat de instrucţiunea
import. Un pachet este o colecţie de clase care devin accesibile în fişierul sursă care le importă. Spre
deosebire de C, aici declaraţiile şi definiţiile nu sunt separate în fişiere separate (.h pentru headere şi .c
respectiv .cpp pentru implementare). O clasă este declarată şi definită în acelaşi loc.
De asemenea s-a eliminat un alt neajuns al limbajului C: acela de a recompila toate sursele
care includ un header modificat. Aici sursa pachetelor nu se inserează în textul sursă, ci se încarcă
clasele necesare din pachetul corespunzător. Regăsirea claselor şi a metodelor se face pe baza numelui
şi nu a adresei, astfel că se pot modifica pachetele fără a fi necesară recompilarea surselor ce le
importă (cu condiţia ca acestea să ofere clase şi metode cu acelaşi nume şi semnătură ca în varianta
anterioară).
Referitor la denumirea pachetelor s-a propus o schemă de denumire unitară, în care fiecare
pachet poate fi identificat în mod unic pornind de la adresa Internet a proiectantului pachetului.
Fie spre exemplu următoarea adresă de e-mail: atoth@cs.uoradea.ro. Pe sistemul de fişiere
local fişierul Test.class se află în directorul /ro/uoradea/cs/atoth. Denumirea fişierului este:
ro.uoradea.cs.atoth.Test. Se observă ordonarea inversă a domeniilor: întâi ro, apoi uoradea ş.a.m.d.
Limbajul Java dispune de o puternică bibliotecă de pachete elaborată de firma Sun. În Tabelul
1 se prezintă câteva dintre acestea:

Denumire Descriere
java.applet clase folosite pentru implementarea
appleturilor
java.lang clase pentru nucleul limbajului
java.math clase folosite în calcule aritmetice
java.net clase pentru lucrul în reţea
java.util diferite clase implementând tipuri des
folosite
Tabelul 1
Instrucţiunea import permite accesul la anumite clase aparţinând unui pachet. Fie
exemplul următor:
import java.util.Hashtable;
import java.math.*;

Prima instrucţiune importă o singură clasă (Hashtable) din pachetul specificat (java.util). A
doua importă toate clasele aparţinând pachetului java.math.
După ce au fost importate, clasele se pot referi în felul următor:

java.util.Hashtable ht;
Exemplul de mai sus declară o instanţă a clasei java.util.Hashtable. Se observă
specificarea completă a clasei, cu numele pachetului urmat de numele clasei. Uzual se
preferă forma prescurtată (în caz că nu există ambiguităţi) :

Hashtable oTabela;

1.2. Pachetul java.lang

Pachetul java.lang este cel mai important pachet Java. El este importat implicit în toate
programele şi conţine clase vitale pentru funcţionarea maşinii virtuale şi interfaţa sa cu sistemul de
operare. Printre acestea se numără clase însărcinate cu implementarea sistemului de securitate, cu
încărcarea claselor (din fişiere, reţea), legătura cu resurse sistem de tipul proceselor, firelor de execuţie
(threads).

1.2.1. Clasa java.lang.System

Una dintre cele mai importante clase ale pachetului java.lang este java.lang.System. Aceasta
nu poate fi instanţiată, dar conţine o serie de metode şi câmpuri statice, printre care se numără fluxurile
standard de intrare, ieşire şi fluxul de eroare. Printre metode se aminteşte în special exit, care serveşte
la terminarea aplicaţiei curente (a se observa diferenţa între aplicaţie şi applet).
În aproape toate exemplele de până acum s-a folosit metoda print :

System.out.print(“Hello” + “\n”);
System.out.println(“Bye”);

1.2.2. Clasele java.lang.String şi java.lang.StringBuffer

O altă clasă esenţială, întâlnită deja (vezi paragraful Error: Reference source not found) este
String. Această clasă foloseşte la lucrul cu entităţi de tip şir de caractere constante. Clasa String are o
mare varietate de constructori pentru iniţializarea din alt şir de caractere, din tablouri de caractere
şamd.
Printre metodele clasei String se amintesc:
 compareTo şi compareToIgnoreCase pentru compararea cu un alt şir de caractere sau
chiar obiect;
 startsWith, endsWith, substring, lastIndexOf, indexOf, replace pentru căutarea
/modificarea de subşiruri de caractere;
 valueOf pentru convertirea tipurilor primitive uzuale în şir de caractere;
toUpperCase, toLowerCase, trim implementează funcţii uzuale de schimbare a literelor mici /
mari şi de eliminare a spaţiilor.
În secvenţele de program de până acum s-a putut observa concatenarea la şiruri de caractere a
unor variabile de alt tip. Acest lucru este posibil datorită faptului că în clasa Object (care este strămoşul
direct sau indirect al oricărei clase) este definită metoda toString, care realizează o conversie spre tipul
String. Se recomandă redefinirea acestei metode de către programatori.

class Orice {
int i;
String sir;

public Orice(int unInt, String unSir) {

i = unInt;
sir = unSir;
}

/** Rulati cu şi fără comentariul de mai jos! */

 /*public String toString( ) {
return “ ” + i + “ “ + sir ;
}*/
}

public class SirApp {

public static void main(String argv[ ]) {

Orice o = new Orice (10, “zece” );

System.out.println(o);
}
}

Spre deosebire de clasa String care manipulează şiruri constante, clasa StringBuffer este
destinată şirurilor de caractere variabile. Metodele sale permit adăugarea, inserarea şi înlocuirea unor
caractere sau sub-şiruri dintr-o instanţă. Următorul exemplu ilustrează folosirea clasei StringBuffer:

class StrBufApp {
public static void main(String argv[ ]) {
/** Constructia dintr-un String */
StringBuffer buf = new StringBuffer("ABC");
/** Adaugare cu metoda append */
buf.append("DEF");
System.out.println(buf);

/** Cu metoda reverse se obtine un nou obiect

care va contine sirul initial inversat */

StringBuffer rev = buf.reverse();

System.out.println(buf);

/** Folosirea de obiecte temporare si

adaugarea de obiecte de diferite tipuri
(nu neaparat primitive) */
String unSir =
new StringBuffer().append("x").append('=').append(20).toString();
System.out.println(unSir);
}
}

1.2.3. Clasa java.lang.Number

În continuare se vor prezenta câteva metode ale clasei Integer. Aceasta este o clasă derivată
din clasa Number, de la care moşteneşte metode abstracte pentru transformarea din / în şir de caractere.
Exemplul de mai jos poate fi uşor adaptat la restul claselor denumite “type wrappers”: Byte, Float etc.

class IntApp {
public static void main(String argv[ ]) {
String unSir = new String("123");

try {

/** Constructori */
Integer unInt = new Integer("1234");
/**Atenţie la secvenţele escape: \" şi \t ! */
System.out.println("Integer(\"1234\") : \t\t" + unInt.intValue() );
unInt = new Integer(12);
System.out.println("Integer(12) : \t\t\t" + unInt.intValue() );

/** Metoda statica parseInt */

int i = Integer.parseInt(unSir);
System.out.println("Integer.parseInt(" + unSir + ") : \t" + i);

/** Se va crea un nou obiect de tip Integer */

 /** Atenţie la semnul "-" !*/
unInt = Integer.valueOf("-" + unSir);
/** Metoda IntValue */
i = unInt.intValue();
System.out.println("Integer.valueOf(-" + unSir + ") : \t" + i);

/** Se poate specifica baza de numeratie */

unSir = "FF";
/** Atentie la obtinerea valorii "-FF" prin concatenare! */
unInt = Integer.valueOf("-" + unSir, 16);
i = unInt.intValue();
System.out.println("Integer.valueOf(-" + unSir + ") : \t\t" + i);

/** Metoda statica toString */

System.out.println("Integer.toString(17) : \t\t" +
Integer.toString(17) );

/** Metoda statica toHexString */

System.out.println("Integer.toHexString(17) : \t" +
Integer.toHexString(17) );

} catch (Exception e) {
System.out.println("A aparut urmatoarea exceptie:" + e);
System.exit(-1);
}
}
}

1.2.4. Clasa java.lang.Math

În această clasă sunt grupate echivalentul funcţiilor C care se află în fişierul math.h. Pentru a
se asigura deplina portabilitate, implementarea respectă standardul IEEE 754. Toate metodele sunt
statice, la fel ca şi constantele double E şi PI. Se atrage atenţia asupra faptului că marea majoritate a
acestor metode folosesc reprezentarea numerelor în virgulă mobilă în dublă precizie (double) şi nu
float. Exemplul următor prezintă câteva dintre metodele clasei Math.

class MathApp {
public static void main(String argv[ ]) {
double d = Math.sin(0.2456);
d = Math.sqrt(2453);
d = Math.max(23434, Math.exp(7));
/** functia putere */
d = Math.pow(13.543456, -6.65245);
/** Conversii radiani <-> grade */
d = Math.toDegrees(Math.PI/4);
}
}

1.3. Pachetul java.util

Un alt pachet destinat dezvoltării rapide de programe este java.util. Printre clasele sale se
numără: vectori, stive, tabele de dispersie (hashtables). Noţiunea de vector este des întâlnită în ultimul
timp în cadrul diferitelor limbaje de programare. Un vector reprezintă un tablou de elemente oarecare,
acest tablou având însă capacitate variabilă. Creşterea capacităţii se face prin simpla adăugare a unui
nou element. Alocarea memoriei se face în mod transparent. Deobicei vectorii oferă posibilitatea
declarării unei capacităţi iniţiale şi a unui increment (cu câte unităţi va creşte capacitatea atunci când se
mai adaugă un element care “nu mai încape” ).
În următorul exemplu se va folosi un vector de elemente aparţinând clasei Nota (s-ar fi putut
folosi şi elemente de tipuri primitive: int, String). Se observă cei doi constructori ai clasei Nota. Clasa
VectorApp conţine metoda main. Din cauză că această metodă este statică, ea poate apela / accesa doar
funcţii / câmpuri statice, lucru ce explică prezenţa modificatorului de acces.

import java.util.Vector;

class Nota {
public String disciplina;
public int nota;

public Nota( ) {
nota = 1;
}

public Nota(String oDispiclina, int oNota) {

disciplina = oDispiclina;
nota = oNota;
}
}

public class VectorApp {

static final int N = 4;

static Vector vector;

/** Iniţializator static */
static {
vector = new Vector( );
}

static void init( ) {

/** Metoda va iniţia vectorul cu elemente */
String unSir;
for (int i = 1; i < N; i++) {
unSir = "Materia_" + i;
vector.addElement(new Nota(unSir, i));
}
}

static void maiAdauga(int num) {

/** Se vor mai adăuga noi elemente */
String unSir;
for (int i = 0; i < num; i++) {
unSir = "Materia " + (vector.size() + 1);
vector.addElement(new Nota(unSir, 10));
}
}

static void afis() {

Nota oNota;
for (int i = 0; i < vector.size(); i++) {
/** operatorul cast din Object -> Nota */
oNota = (Nota) vector.elementAt(i);
System.out.println(oNota.disciplina + " " + oNota.nota);
}
}

static void cauta(Nota nota) {

if (nota != null) {
int poz = vector.indexOf(nota);
if (poz != -1) {
System.out.println("Am gasit!");
} else {
System.out.println("Nu am gasit!");
}
}
}

public static void main(String argv[ ]) {

init( );
afis( );
maiAdauga(3);
System.out.println("Se mai adauga...");
afis( );
/** caut ultimul element */
cauta( (Nota) vector.lastElement() );

/** caut un obiect nou */

cauta(new Nota("Test", 122) );

/** eliminare nota */

System.out.println("Se mai sterge...");
vector.remove(0);
afis( );
 vector.removeAllElements();
}
}

1.4. Tema practică

 Să se scrie un program care preia argumentele liniei de comandă şi le copiază pe cele de
ordin par respectiv impar în două şiruri de caractere separate, pe care apoi le afişează.
 Să se scrie un program care crează şi afişează o matrice triunghiulară de forma:

1111…11
2222…2
…
N

 Să se scrie un program care adună două matrici pătrate de ordin N. Matricile vor fi
iniţializate folosind funcţia math.random(), care întoarce un număr double ce ia valori în
intervalul (0..1).

 Să se implementeze o clasă care să aibă un membru static contor care să numere

instanţierile clasei.
 Să se completeze constructorii din exemplul DerivApp.
 Să se implementeze o ierarhie de clase în jurul noţiunilor persoană … absolvent de liceu
… student. Se va implementa o clasă abstractă şi cel puţin una finală.

 Se dă un vector de N cuvinte. Să se afişeze vectorul în ordine inversă, cu fiecare cuvânt

inversat.
 Să se implementeze o listă de întregi folosind referinţe în loc de pointeri în câmpul de
legătură.
 Căutaţi în documentaţia aferentă JDK clasele Date, Stack, Hashtable, BitSet.
 Implementaţi adunarea matricilor rare (sparse matrices) prin folosirea unei Hashtable
care să lege indicele (ex: [1, 2]) de element (ex: -2.3455).