Curs Java PDF

UNIVERSITATEA TEHNICĂ “GH.
ASACHI” DIN IAŞI

FACULTATEA DE ELECTRONICĂ, TELECOMUNICAŢII ŞI TEHNOLOGIA INFORMAŢIEI
Programare Java
II. Elementele de bază ale

limbajului Java
2016
Elementele de bază ale limbajului Java
Cuprins
1. Structura lexicală a limbajului Java
2. Tipuri de date și variabile
3. Tablouri
UNIVERSITATEA TEHNICĂ “GH. ASACHI” DIN IAŞI
4. Structuri de control
5. Clase și obiecte
6. Pachete Java
7. Interfețe Java
8. Excepții
Unități lexicale:
 spații libere
 identificatori
 comentarii
 separatori
 literali
 cuvinte cheie
 operatori
Spațiile libere
- caracterul spațiu: ‘ ’
- caracterul tabulator orizontal: ‘\t’

- terminatori de linie:
CR (carrriage return), ‘\r’
LF (linefeed), ‘\n’
CR LF
Identificatorii – reprezintă nume pentru variabile, metode, clase
Condiții asupra numelui:

- numele este o secvență de litere, cifre, caracterele $ sau _ , dar care nu
începe cu o cifră;
- numele trebuie să fie diferit de orice cuvânt cheie;
- numele trebuie să fie diferit de null, false, true;
- limbajul Java este case-sensitive, adică face diferențierea între literele mari și
mici; de ex: suma, Suma, SUMA sunt trei identificatori diferiți.

Convenții de nume:
- numele claselor încep cu majusculă, fiecare cuvânt distinct din identificator

începând cu majusculă; ex: StringBuffer
- numele variabilelor și ale metodelor încep cu literă mică, fiecare cuvânt ce
urmează începând cu majusculă; ex: name, setName( )

-numele constantelor conțin doar majuscule, cuvintele fiind separate prin
caracterul underscore _ ; ex: DIM_MAX
Exemplu cu identificatori:
class StudentEtti
{
public static void main ( String [] args )
{
System.out.println(“Sunt student la ETTI”);
}
}
 Comentariile - utilizate pentru a explica și pentru a documenta

programul
În Java există trei tipuri de comentarii:
 clasic
/* Acesta este un comentariu clasic. El poate fi scris pe mai multe rânduri. Este
ignorat de compilator. */
 de linie
// această linie este comentată

 de documentare – specific Java, folosind utilitarul javadoc.
/**
* Clasa PlasareVapoare citește informațiile introduse de utilizator și stabilește
* pozițiile obiectelor Vapor
*
* @version 1.0
* @author Alex
*/
 Separatorii - caractere care separă unitățile lexicale Java unele de altele

() {} [] ; , .
 Literalii – reprezintă valori constante ale unui tip de dată primitiv, tipul
String sau tipul null.

Tipuri de literali:
 întregi - pot fi exprimați în zecimal, hexazecimal (literalul începe cu 0x), octal
(literalul începe cu cifra 0)sau binar. Pentru tipul long se adaugă sufixul l sau L.
Ex :100, 10247860, 2000L, 0261, 0x7, 0xBA12, 065l
Literalii întregi sunt implicit de tip int.
 flotanți - corespund numerelor în virgulă mobilă. Pentru valori de tip float se
adaugă sufixul f sau F, iar pentru valori de tip double se adaugă sufixul d sau D.
Ex: 3.14, 63f, 134e-3, 98.21d
Literalii flotanți sunt implicit de tip double.
 logici - pot lua doar două valori: true sau false.

Observație. Spre deosebire de limbajul C++, valorile 0 și 1 nu mai au

semnificația de fals, respectiv adevărat.
Literalii logici sunt de tip boolean.

 caracter - este un caracter Unicode sau o secvență escape reprezentate între
apostrofuri.
Setul de caractere Unicode este reprezentabil pe 16 biți și oferă suport pentru
toate limbile scrise. Primele 128 caractere din Unicode sunt cele ale codului
ASCII. Secvența \u urmată de 4 caractere hexa reprezintă un caracter în format
Unicode.
Ex: ‘a’, ‘F’, ‘\t’ (tabulator orizontal), ‘\n’ (linie nouă), ‘\\’, ‘\u040a’, ‘\141’, ‘u00e3’
(caracterul ă)
 șir de caractere – este o secvență de zero sau mai multe caractere

Unicode cuprinsă între ghilimele.
Ex: “ Acesta este un șir de caractere”, “ ” (șirul vid)
Observație. În Java orice șir de caractere este o instanță a clasei String,

definită în pachetul java.lang.
Un șir de caractere poate fi scris ca o concatenare de subșiruri folosind
operatorul + între subșiruri.
Ex: “Welcome” + “ to Java.”
Cuvintele cheie – sunt cuvinte rezervate, care au un sens special în
limbajul Java. Sunt cuvintele care însoțesc variabilele, metodele, clasele.

abstract boolean break byte case catch
char class const continue default do
double else extends final finally float

for goto if implements import instanceof
int interface long native new package
private protected public return short static
strictfp super switch synchronized this throw
throws transient try void volatile while
Operatorii - descriu operațiile ce se aplică asupra variabilelor din
program
Clasificare:
 atribuire: =
int a;
a=7;
Carte A, B;
A=B; unari: + - ++ --
 aritmetici:
binari: + - * / %
byte b1, b2 = -1;
int a = 35/4;
b1= ++ b2;
 relaționali - compară operanzii pentru a determina relația dintre ei,
rezultatul comparării fiind de tip boolean:

== != > >= < <=
condiționali: && (și)

|| (sau)
 logici
booleeni: ! (negare)
& ( și)
| (sau)
^ (sau exclusiv)
Operatorii logici se pot aplica numai operanzilor de tip boolean.
 pe biți: - se aplică numai operanzilor de tip primitiv întregi
& și
| sau
^ sau exclusiv
~ complementare
<< deplasare stânga cu semn
>> deplasare dreapta cu semn
>>> deplasare dreapta fără semn
 condițional: ? :
expresie ? val1 : val2
Ex: max = ( a>b) ? a : b;
 de concatenare șiruri de caractere: +
sir_caractere+var_tipT sau var_tipT+sir_caractere

Exemplu:
String sir1 = “ Afișare: “ , sirRez;
int a = 12;
float x = 12.5;
boolean c = true;
Object obj = new Object ( );
sirRez = sir1 + a; // Afișare: 12
sirRez = sir1 + x; // Afișare: 12.5
sirRez = sir1 + c; // Afișare: true
sirRez = sir1 + obj; // Afișare: Object@12123
 de atribuire combinați:
+=, -=, *=, /=, %= x += y; echivalent cu x = x + y;

&=, |=, ~= x &= y; echivalent cu x = x & y;
<<=, >>=, >>>= x <<= n; echivalent cu x = x << n;
 operatorul cast - este utilizat pentru a converti o valoare dintr-un tip

de date numeric într-o valoare similară, însă de alt tip de date numeric.
(tipNumericDorit) operandAltTipNumeric
Obs. Tipul boolean nu poate fi convertit în nici un alt tip și invers.

 operatorul instanceOf
- testează dacă un obiect este de o anumită clasă

obj instanceOf numeClasa
-returnează true dacă obiectul obj este de clasă numeClasa sau de o
clasă derivată din aceasta și false în caz contrar.
 operatorul virgulă: ,
-este folosit pentru evaluarea secvențială a operațiilor
Exemplu:
int a=1, b=2, c=3;
Obs. În Java nu există operatorul sizeof din C++.
Tipurile de date se împart în:
 primitive
Dimensiunea Valoarea minimă a Valoarea maximă a
Tip reprezentării (în biți) domeniului domeniului
byte 8 -27=-128 27-1=127
short 16 -215=-32768 215-1=32767
int 32 -231 231-1
long 64 -263 263-1
char 16 ‘\u0000’=0 ‘\uffff’=65535
float 32 1.4e-045 3.4e+038
double 64 4.9e-324 1.8e+308
boolean false true
referințe:
tablouri, clase, interfețe
Variabilele - reprezintă identificatori ai unor referințe de memorie
[ lista _modificatori] tip_data numeVariabila;

Exemple:
int x;
x=10;
final float PI=3.1415;
String sir=”Acesta este un sir de caractere”;
char k=’F’;
lista _modificatori :
public, private, static, final, protected, transient, volatile
Variabila – este definită într-un domeniu de vizibilitate (scope)
class Scope {
int classScope; // vizibilă în toată clasa Scope
Scope ( int param) { // param este vizibil doar în acest constructor

int localVar = 0; // vizibilă doar în acest constructor
}
void oMetoda ( ) {
int local = 10; // vizibilă doar în această metodă
if ( local >0) {
boolean poz = true; //vizibilă doar în acest bloc
} else {
// aici variabila poz nu mai există
}
}
}
Inițializarea unei variabile
 variabilele locale – nu primesc valori prestabilite.

class Clasa {
public void go ( ) {
int x;
int z = x + 3; // Eroare la compilare! Variabila x trebuie
//inițializată înainte de a fi folosită
}
}
 variabilele de instanță – sunt inițializate implicit cu o valoare, astfel:
întregi 0
nr în virgulă mobilă 0.0
booleene false
referințe null
class Carte {
private int nrPag;
private String titlu; Rezultat:

public int getNr ( ) {
Cartea are un nr de pag: 0
return nrPag; Cartea are titlul: null
}
public int getTitlu ( ) {

return titlu;
}
}
Class TestCarte {
public static void main ( String [ ] args) {
Carte una = new Carte ( ) ;
System.out.println(“ Cartea are un nr de pag: “ + una.getNr( ) );
System.out.println(“ Cartea are titlul: “ + una.getTitlu( ) );
}
}
 variabilele statice dintr-o clasă – sunt inițializate înainte de a putea
fi creat vreun obiect al clasei

class Jucator {
static int nrJucatori;
private String nume;
public Jucator ( String s) {

nume = s;
nrJucatori++;
}
}
public class TestJucator {
public static void main (String [ ] args) {
System.out.println (Jucator.nrJucatori);
Jucator unu = new Jucator (“Alex”); Rezultat:
System.out.println (Jucator.nrJucatori); 0
1
}
}
Variabile statice finale
Exemplu: variabile PI din clasa Math

public static final double PI = 3.141592653589793;
public – să fie accesibilă din orice cod

static – să nu fie necesară o instanță a clasei Math

final – pentru a nu modifica valoarea lui PI
O variabilă statică finală trebuie inițializată în momentul declarării sau într-un
bloc de inițializare statică:
public class Numar
public static final double NR_ALEATOR;
static {
NR_ALEATOR = (double) Math.random( ); }
}
3. Tablouri
-conțin elemente de același tip stocate într-o zonă continuă de memorie, care
pot fi accesate utilizând un nume comun

Declarare tablou:
tip_elemente numeTablou [ ];
sau
tip_elemente [ ] numeTablou;
Exemple:
int [ ] tablouInt=new int [20];
char tablouCar[ ] ={‘t’, ‘a’, ‘b’, ‘l’, ‘o’, ‘u’};
float tablouReal [ ] = new float[5];
3. Tablouri
Exemple:
int [ ] [ ] tabMultidim; //declarare tablou bidimensional

tabMultidim = new int [2] [3]; // creare tablou
int tabMultidim [ ] [ ] = { {1, 2, 3}, {4, 5, 6} };
în Java un tablou este întotdeauna un obiect.
 Accesul la elementul de pe poziția i: tablou [i]
 Indicele este cuprins între 0 și length-1
 În Java este verificat accesul la elementele tabloului, dacă se depășește

dimensiunea tabloului, se va arunca o excepție ArrayIndexOutOfBoundsException.
3. Tablouri
.
Copierea conținutului unui tablou în alt tablou:

- folosind metoda arraycopy( ) din clasa System, din pachetul java.lang sau
folosind copierea element cu element
public static native void arraycopy( Object sursă, int poziție_sursă, Object dest,
int poziție_dest, int lung)
Exemple:
int a [ ] = { 1,2,3 };
int b [ ] = new int [3];
// varianta cu arraycopy
System. arraycopy(a, 0, b, 0, a.length);
//varianta element cu element
for( int i=0; i<a.lenght; i++)
b[i]=a[i];
 Instrucțiuni de selecție : if, if-else, if-else-if, switch
- oferă posibilitatea execuției selective a unor secvențe de cod în funcție de valoarea unei
expresii.
class IfElse {
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
grade = 'C';
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade = " +
grade);
}
class SwitchDemo {
int luna = 8;
switch (luna) {
case 1: System.out.println(“Ianuarie"); break;
case 2: System.out.println("Februarie"); break;

case 3: System.out.println("Martie"); break;
case 4: System.out.println("Aprilie"); break;
case 5: System.out.println("Mai"); break;
case 6: System.out.println(“Iunie"); break;
case 7: System.out.println(“Iulie"); break;
case 8: System.out.println("August"); break;
case 9: System.out.println("Septembrie"); break;
case 10: System.out.println("Octombrie"); break;
case 11: System.out.println("Noiembrie"); break;
case 12: System.out.println("Decembri"); break;
default: System.out.println(“Luna invalida");break;
}
}
}
Instrucțiuni repetitive: while, do-while, for
- execuția repetată a unei părți din program până când o anumită condiție nu
este îndeplinită.
Instrucțiuni repetitive: while, do-while, for
Instrucțiuni de salt: break, continue, return
- permit întreruperea necondiționată a unei secvențe de program și

continuarea programului dintr-un alt punct.
Class Name: Circle A class template
Data Fields:
radius is _______
Methods:
getArea
Circle Object 1 Circle Object 2 Circle Object 3 Three objects of

the Circle class
Data Fields: Data Fields: Data Fields:
radius is 10 radius is 25 radius is 125
O clasă este schița (modelul) unui obiect.

Clasa spune mașini virtuale Java cum să construiască un obiect de
tipul respectiv.
Lucrurile pe care le știe un obiect despre el însuși se numesc variabile de

instanță. Acestea reprezintă starea unui obiect. Lucrurile pe care le face un
obiect se numesc metode. Acestea reprezintă comportamentul unui
obiect.
Definiția unei clase :
[modificatori_clasă] class NumeClasă [extends SuperClasa]

[implements ListaInterfețe]
{
// corp_clasă
modificatori_clasă: public, abstract, final

public – clasa poate fi folosită din exteriorul pachetului în care a fost definită
abstract - declară o clasă abstractă, adică o clasă ce nu poate fi instanțiată, fiind
folosită doar ca model pentru o serie de subclase
final - specifică faptul că acea clasă nu poate avea subclase
Implicit, o clasă poate fi folosită doar de clasele aflate în același pachet, se spune că e
clasă prietenă (friend). Pentru a putea fi însă instanțiată, clasa trebuie să aibă și
constructorul declarat public.
Variabile de instanță
[modificatori] tip_dată lista_variabile;
modificatori: public, protected, private, final, static, transient și volatile

 Metode
[modificatori] tip_returnat numeMetoda([lista_parametrii]) [throws lista_excepții]

{
// corp metodă
}
modificatori: public, protected, private, abstract, final, static, synchronized și

native
public - membrul clasei ( metodă, atribut, constructor) poate fi accesat de
oriunde, fie din interiorul, fie din exteriorul pachetului în care este definită clasa
respectivă. În cazul în care nu se utilizează nici un modificator de acces, accesul la

membru este de tip friendly, adică poate fi accesat doar din interiorul pachetului.
protected - accesul este permis de oriunde din interiorul pachetului și în plus din
clasele derivate.
private - accesul se face doar din interiorul clasei.
static - impune apartenența membrului respectiv la clasă și nu la un obiect. De

aceea, un astfel de membru poate fi accesat atât prin numele clasei cât și prin
numele unui obiect din acea clasă.
Un atribut static este comun mai multor obiecte ale clasei și este inițializat o
singură dată la prima instanțiere a clasei.
O metodă statică poate fi accesată prin numele clasei și nu poate utiliza alte
atribute și metode ale clasei care nu sunt statice.
Constructori - metode speciale ce au numele identic cu numele clasei
în care sunt definiți și nu returnează nici un tip de date, nici măcar void.
class Cerc {
int raza, x,y;
public Cerc( ) { //constructor fără parametri

raza=1;
x=0;
y=0;
}
public Cerc( int r, int a, int b) { // constructor cu parametri
raza=r;
x=a;
y=b;
}
}
Constructori
Pentru a apela un constructor în interiorul altui constructor se poate folosi

cuvântul cheie this.
public class Carte {

public Carte( String autor) { } //primul constructor
public Carte( String autor, String carte) { // alt constructor
this(autor); // apelul primului constructor
}
}
this reprezintă referința la obiectul curent.

Constructori
public class Carte {

String autor; // atribut al clasei
String carte;
public Carte( String autor, String carte) { // autor este parametru
// formal al metodei
this.autor=autor; // this.autor referențiază variabila de instanță
// iar autor parametrul formal
this.carte=carte;
}
}
this reprezintă referința la obiectul curent, numele obiectului nefiind

vizibil din interiorul lui.
Obiecte
Tipul de date creat prin definirea unei clase poate fi folosit prin declararea
de obiecte de acest tip. Crearea unui obiect presupune declararea și
instanțierea sa.
Declararea unui obiect:

numeClasa numeOobiect;
Instanțierea unui obiect se face prin intermediul operatorului new
urmat de numele clasei și lista parametrilor de apel ai constructorului
clasei între paranteze.
numeObiect = new constructor();
Obiecte
1) se declară o variabilă referință

Carte oCarte = new Carte( );
Această instrucțiune cere mașinii Java să aloce spațiu pentru o variabilă referință
și o numește oCarte.
2) se creează un obiect
Această instrucțiune cere mașinii Java să aloce spațiu pentru noul obiect Carte în
zona heap.
3) se leagă obiectul de referință
Noul obiect Carte este atribuit variabilei referință oCarte..
Colectorul de gunoaie
- obiectele se găsesc în zona heap cu colectarea gunoiului

- eliberarea memoriei alocată unui obiect prin new se face automat de
către Garbage Collector (colector de gunoaie) după ce nu mai există nici o
referință la obiectul respectiv.

6. Pachete Java
-reprezintă o colecție de clase și interfețe înrudite
Există trei motive pentru a utiliza pachete:

1. asigură structurarea aplicațiilor complexe ce conțin foarte multe
clase
2. se pot rezolva eventualele conflicte ce pot apărea datorită existenței

a două clase cu același nume. Pachetele permit existența în cadrul
aceleași aplicații a două sau mai multe clase având același nume dar
organizate în pachete diferite.
3. asigură protejarea claselor prin faptul că membrii protected ai
claselor sunt accesibili doar claselor din același pachet, nu și claselor
din exterior.
6. Pachete Java
Orice clasă din Java face parte dintr-un pachet.

Pachete standard:
java.lang – conține clasele de bază ale limbajului Java
java.io – conține clasele pentru intrări/ieșiri, lucrul cu fișiere
java.util – clase și interfețe utile: Vector, Stack, Random, Date, Timer etc.
java.applet – dezvoltarea de appleturi
java.awt – conține clasele pentru interfața grafică cu utilizatorul (Abstract
Windowing Toolkit)
java.awt.event - tratare evenimente

6. Pachete Java
java.beans – conține clasele necesare scrierii de componente reutilizabile
java.net - programare de rețea

java.sql - lucrul cu baze de date
java.rmi –conține clasele care asigură execuție la distanță (Remote Message
Interface)
java.security – conține clase care asigură mecanisme de securitate: criptare,
autentificare
java.math – conține clasele în care sunt definite operații matematice
java.text – oferă support pentru formatarea textelor
java.lang.reflect – introspecție
javax.swing – conține clasele pentru interfața grafică cu utilizatorul, extinde
funcționalitatea claselor din pachetul java.awt.
6. Pachete Java
 utilizarea unei clase ( excepție: java.lang) din alt pachet impune specificarea
pachetului folosind cuvântul cheie import.
 există trei posibilități de utilizare a unei clase din alt pachet:

1) importul întregului pachet în care se găsește clasa și utilizarea numelui scurt
al clasei (fără numele pachetului)
import java.util.*;
Vector v=new Vector( );

6. Pachete Java
2) importul clasei respective și utilizarea numelui clasei

import java.util.Vector;

3) specificarea numelui complet al clasei (ce include numele pachetului)
Java.util.Vector v= new java.util.Vector( );
Această soluție este utilă în cazul în care se dorește utilizarea unui clase cu
același nume din pachete diferite.
pachetulMeu.Vector u= new pachetulMeu.Vector( );

6. Pachete Java
Crearea unui pachet:
-se folosește cuvântul cheie package urmat de numele pachetului
package numePachet;
-acest lucru se face obligatoriu în prima linie de cod a programului

Exemplu:
package pachetulMeu;
public class Vector {
…
}
Obs. Există clasa cu numele Vector și în pachetul java.util
Prezentarea limbajului Java
Exercițiul 1: fii compilator
Verifică dacă următoarele secvențe de cod pot fi compilate . Dacă nu, cum
le poți corecta?
Exercițiul 1: fii compilator

Exercițiul 2: Referințe+Obiecte
Pentru codul de mai jos stabiliți ce obiect referă fiecare variabilă referință.
Nu toate referințele sunt folosite, iar unele obiecte sunt referite de mai
multe variabile. Conectează prn linii referințele cu obiectele
corespunzătoare
6. Interfețe Java
 Despre moștenire și polimorfism
-subclasa moștenește (extinde) superclasa.

-subclasa poate adăuga propriile metode sau variabile de instanță și poate
suprascrie metodele moștenite de la superclasă.
- nu se moștenesc membrii privați ai superclasei

-dacă într-o subclasă vrem să folosim atât versiunea din superclasă, cât și
versiunea suprascrisă a unei metode, vom folosi cuvântul cheie super pentru a
apela versiunea superclasei. ( ex: super.metoda( ) )
Exemplu: proiectarea arborelui de moștenire pentru un simulator de animale
1) Proiectăm o clasă care reprezintă starea și comportamentul pe care le au în
comun toate animalele. Vom crea superclasa Animal și punem în ea
metodele și variabilele de instanță care ar putea fi necesare pentru toate
animalele.
6. Interfețe Java
6. Interfețe Java
2) Decidem dacă o subclasă are nevoie de comportamente specifice subclasei

respective (metodele faceZgomot( ) și mananca( ) )
3) Identificăm alte posibilități de folosire a abstractizării, căutând două sau mai
multe subclase care ar putea avea nevoie de un comportament comun.
4) Completăm ierarhia de clase: clasa Canine, clasa Feline.

6. Interfețe Java
6. Interfețe Java
Putem scrie:
Lup unLup = new Lup(); // referința și obiectul sunt de același tip (Lup)
sau
Animal unHipopotam = new Hipopotam( ); // referința și obiectul sunt de

//tipuri diferite
Ce se întâmplă în următorul caz:
Animal unAnimal = new Animal( ); //cum ar arăta un obiect Animal?
Soluția: declarăm clasa abstractă folosind cuvântul cheie abstract înaintea

definiției clasei, pentru a împiedica instanțierea clasei respective (nu se
poate folosi operatorul new).
Ex: abstract class Canine extends Animal {
public void seMisca( ) { }
}
6. Interfețe Java
 O clasă care nu este abstractă se numește clasă concretă.
În exemplul prezentat:
Clase abstracte: Animal, Canine, Feline
Clase concrete: Hipopotam, Lup, Caine, Tigru, Leu, Pisica.
 Clasă abstractă- clasă care trebuie extinsă.

 Metodă abstractă- metodă care trebuie să fie suprascrisă:
public abstract void mananca( ) ; // o metodă abstractă nu are corp
 dacă o clasă are cel puțin o metodă abstractă, trebuie să o declarăm

abstractă și clasa.
 nu putem declara o metodă abstractă într-o clasă concretă
6. Interfețe Java
 Orice clasă Java extinde clasa Object.
public class Caine extends Object { }

 Orice clasă care nu extinde explicit o altă clasă extinde implicit clasa Object.
Object obj = new Hipopotam( );

obj. mananca( ); // ilegal!
 Compilatorul decide dacă putem apela o anumită metodă în funcție de tipul

referinței, nu al obiectului propriu-zis.
6. Interfețe Java
Revenim la clasa Animal:
-Cum putem modifica clasa Caine astfel încât să includă și câteva metode
specifice animalelor de companie?
O solutie posibilă: adăugăm noile metode în clasa Caine, dar în acest caz nu
mai putem folosi clasa Caine pentru câini sălbatici de exemplu.

Alte soluții:
1) adăugăm metodele specifice animalelor de companie în clasa Animal.
Care sunt avantajele și dezavantajele acestei metode?
2) Adăugăm toate metodele specifice animalelor de companie în clasa Animal,
dar declarăm aceste metode ca abstracte și forțăm astfel toate subclasele
Animal să le suprascrie.
6. Interfețe Java
3) Adăugăm metodele specifice animalelor de companie numai în clasele
cărora le aparțin.
În concluzie, avem nevoie de:
 O modalitate de a avea comportamentul specific animalelor de companie

numai în clasele respective
 O modalitate prin care să garantăm că toate clasele pentru animale de
companie au definite aceleași metode (cu aceeași semnătură)
O soluție: folosirea a două superclase (AnimalDeCompanie și Animal)

Dezavantaj: problema moștenirii multiple (problema diamantului fatal)
6. Interfețe Java
6. Interfețe Java
 Interfețe
- O interfață Java rezolvă problema moștenirii multiple, ocolind problema

diamantului fatal astfel: conțin numai metode abstracte.
- Astfel subclasele trebuie să implementeze metodele iar mașina JVM știe

care dintre versiunile moștenite să o apeleze.
- O interfață Java este similară cu o clasă abstractă.
- toate metodele unei interfețe sunt implicit publice și abstracte.
AnimalDe Companie
abstract void estePrietenos( );

abstract void seJoaca( );
6. Interfețe Java
 Definirea unei interfețe
public interface AnimalDeCompanie {

public abstract void estePrietenos( ); //metodele abstracte nu au corp
public abstract void seJoaca( ) ;
}
 Implementarea unei interfețe
public class Caine extends Canine implements AnimalDeCompanie {
public void estePrietenos( ) {…} //trebuie implementate metodele interfeței
public void seJoaca( ) ;
public void seMisca( ) {…} // acestea sunt suprascrieri obișnuite ale
//metodelor moștenite
public void mananca( ) {…}
}
6. Interfețe Java
 clase din structuri diferite de moștenire pot implementa aceeași
interfață.
 O clasă poate implementa interfețe multiple.
Programare Java
II. Elementele de bază ale

limbajului Java
- continuare-
2016
Cuprins
3. Tablouri
6. Pachete Java
7. Interfețe Java
8. Excepții
6. Pachete Java
Pachetele - reprezintă o colecție de clase și interfețe înrudite
Avantajele utilizării pachetelor :

1. asigură structurarea aplicațiilor complexe ce conțin foarte multe
clase;
2. se pot rezolva eventualele conflicte ce pot apărea datorită

existenței a două clase cu același nume. Pachetele permit existența
în cadrul aceleiași aplicații a două sau mai multe clase având același
nume dar organizate în pachete diferite;
3. asigură protejarea claselor prin faptul că membrii protected ai
claselor sunt accesibili doar claselor din același pachet, nu și
claselor din exteriorul pachetului respectiv.
6. Pachete Java
Orice clasă din Java face parte dintr-un pachet.
Pachete standard:
java.lang – conține clasele de bază ale limbajului Java
java.io – conține clasele pentru intrări/ieșiri, lucrul cu fișiere
java.util – clase și interfețe utile: Vector, Stack, Random, Date, Timer etc.
java.applet – dezvoltarea de appleturi
java.awt – conține clasele pentru interfața grafică cu utilizatorul (Abstract
Windowing Toolkit)
java.awt.event - tratare evenimente

6. Pachete Java
java.beans – conține clasele necesare scrierii de componente reutilizabile
java.net - programare de rețea

java.sql - lucrul cu baze de date
java.rmi –conține clasele care asigură execuție la distanță (Remote Message
Interface)
java.security – conține clase care asigură mecanisme de securitate: criptare,
autentificare
java.math – conține clasele în care sunt definite operații matematice
java.text – oferă support pentru formatarea textelor
java.lang.reflect – introspecție
javax.swing – conține clasele pentru interfața grafică cu utilizatorul, extinde
funcționalitatea claselor din pachetul java.awt.
6. Pachete Java
 utilizarea unei clase ( excepție: java.lang) din alt pachet impune specificarea
pachetului folosind cuvântul cheie import.
 există trei posibilități de utilizare a unei clase din alt pachet:

1) importul întregului pachet în care se găsește clasa și utilizarea numelui scurt
al clasei (fără numele pachetului)
import java.util.*;

6. Pachete Java
2) importul clasei respective și utilizarea numelui clasei

import java.util.Vector;

3) specificarea numelui complet al clasei (ce include numele pachetului)
java.util.Vector v= new java.util.Vector( );
Această soluție este utilă în cazul în care se dorește utilizarea unui clase cu
același nume din pachete diferite.
pachetulMeu.Vector u= new pachetulMeu.Vector( );

6. Pachete Java
Crearea unui pachet:
-se folosește cuvântul cheie package urmat de numele pachetului
package numePachet;
-Această declaraţie se face obligatoriu în prima linie de cod a programului

Exemplu:
package pachetulMeu;
public class Vector {
…
}
Obs. Există clasa cu numele Vector și în pachetul java.util
6. Interfețe Java
 Despre moștenire și polimorfism
- subclasa moștenește (extinde) superclasa.

- subclasa poate adăuga propriile metode sau variabile de instanță și poate
suprascrie metodele moștenite de la superclasă.
- nu se moștenesc membrii privați ai superclasei

- dacă într-o subclasă vrem să folosim atât versiunea din superclasă, cât și
versiunea suprascrisă a unei metode, vom folosi cuvântul cheie super pentru a
apela versiunea superclasei. ( ex: super.metoda( ) )
1) Proiectăm o clasă care reprezintă starea și comportamentul pe care le au în
comun toate animalele. Vom crea superclasa Animal și punem în ea
metodele și variabilele de instanță care ar putea fi comune tuturor
animalelor.
6. Interfețe Java
6. Interfețe Java
2) Decidem dacă o subclasă are nevoie de comportamente specifice subclasei

respective (metodele faceZgomot( ) și mananca( ) )
3) Identificăm alte posibilități de folosire a abstractizării, căutând două sau mai
multe subclase care ar putea avea nevoie de un comportament comun.
4) Completăm ierarhia de clase: clasa Canine, clasa Feline.

6. Interfețe Java
6. Interfețe Java
Putem scrie:
Lup unLup = new Lup(); // referința și obiectul sunt de același tip (Lup)
sau
Animal unHipopotam = new Hipopotam( ); // referința și obiectul sunt de

//tipuri diferite
Ce se întâmplă în următorul caz:
Animal unAnimal = new Animal( ); //cum ar arăta un obiect Animal?
Soluția: declarăm clasa ca fiind abstractă folosind cuvântul cheie abstract

înaintea definiției clasei, pentru a împiedica instanțierea clasei respective (nu se
va putea folosi operatorul new).
Ex: abstract class Canine extends Animal {
public void seMisca( ) { }
}
6. Interfețe Java
 O clasă care nu este abstractă se numește clasă concretă.
În exemplul prezentat:
Clase abstracte: Animal, Canine, Feline.
Clase concrete: Hipopotam, Lup, Caine, Tigru, Leu, Pisica.
 Clasă abstractă- clasă care trebuie extinsă.

 Metodă abstractă- metodă care trebuie să fie suprascrisă:
public abstract void mananca( ) ; // o metodă abstractă nu are corp
 dacă o clasă are cel puțin o metodă abstractă, atunci şi clasa trebuie să
fie declarată abstractă.
 nu putem declara o metodă abstractă într-o clasă concretă.
6. Interfețe Java
 Orice clasă Java extinde clasa Object.
public class Caine extends Object { }

 Orice clasă care nu extinde explicit o altă clasă extinde implicit clasa Object.
Object obj = new Hipopotam( );

obj. mananca( ); // ilegal!
 Compilatorul decide metoda care se va apela în funcție de tipul referinței, nu

al obiectului propriu-zis.
6. Interfețe Java
Revenim la clasa Animal:
-Cum putem modifica clasa Caine astfel încât să includă și câteva metode
specifice animalelor de companie?
O solutie posibilă: adăugăm noile metode în clasa Caine, dar în acest caz nu
mai putem folosi clasa Caine pentru câini sălbatici de exemplu.

Alte soluții:
1) adăugăm metodele specifice animalelor de companie în clasa Animal.
2) Adăugăm toate metodele specifice animalelor de companie în clasa Animal,
dar declarăm aceste metode ca abstracte și forțăm astfel toate subclasele
Animal să le suprascrie.
6. Interfețe Java
3) Adăugăm metodele specifice animalelor de companie numai în clasele
cărora le aparțin.
În concluzie, avem nevoie de:
 O modalitate de a avea comportamentul specific animalelor de companie

numai în clasele respective;
 O modalitate prin care să garantăm că toate clasele pentru animale de
companie au definite aceleași metode (cu aceeași semnătură).
O soluție: folosirea a două superclase (AnimalDeCompanie și Animal).

Dezavantaj: problema moștenirii multiple (problema diamantului fatal).
6. Interfețe Java
6. Interfețe Java
 Interfețe
- O interfață Java rezolvă problema moștenirii multiple, ocolind problema

diamantului fatal astfel: conțin numai metode abstracte.
- Astfel subclasele trebuie să implementeze metodele iar mașina JVM știe

care dintre versiunile moștenite să o apeleze.
- O interfață Java este similară cu o clasă abstractă.
- toate metodele unei interfețe sunt implicit publice și abstracte.
AnimalDe Companie
abstract void estePrietenos( );

abstract void seJoaca( );
6. Interfețe Java

}
public void seJoaca( ) ;
}
7. Interfețe Java

}
public void seJoaca( ) {…}
}
7. Interfețe Java
 La fel ca și o clasă abstractă, o interfață Java nu poate fi instanțiată.
 O interfață Java poate fi implementată de o clasă utilizând cuvântul

cheie implements.
 clase din structuri diferite de moștenire pot implementa aceeași

interfață.
 O clasă poate implementa interfețe multiple.

8. Excepții
 Excepțiile reprezintă evenimente neașteptate, anormale sau situații

excepționale care pot apare în timpul execuției unui program.
 exemple de astfel de situații: împărțirea la zero (ArithmeticException),
radical de ordinul doi dintr-un număr negativ, accesarea unui element din
afara spațiului alocat unui vector (ArrayIndexOutOfBoundsException),
inversa unei matrici singulare, scoaterea unui element dintr-o stivă goală,
încercarea de a accesa un membru al unui obiect printr-o referință nulă
(NullPointerException) etc.
 Erorile pot fi cauzate și de echipamentul hardware.
8. Excepții
Exemplu:
public class ExempluExceptii {
public static void init(int[ ] a, int n, int v) {

// vectorul a are dimensiunea n
for (int i=0; i != n; i++) {
a[i] = v;
}
}
int[ ] vec = new int[10];
init(vec, 25, -1);
}
}
În urma execuției codului de mai sus va fi generată o excepție, programul se
va opri și se va afișa mesajul de eroare:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
at ExempluExceptii.init(ExempluExceptii.java:5)
at ExempluExceptii.main(ExempluExceptii.java:10
8. Excepții
 Există excepții predefinite ( ca în exemplul anterior) și excepții definite de
utilizator.
 Java implementează un mecanism eficient de lucru cu excepțiile, care
permite programatorului să preia controlul programului în momentul în care
apare o excepţie şi să o trateze.

 În aceste situații programatorul trebuie să creeze un obiect care să conțină
informații despre excepția respectivă și să-l “arunce” utilizând cuvântul
cheie throw. Odată aruncat, obiectul excepție este preluat de mașina Java
care va căuta în program secvența de cod (exception handler – analizor de
excepţie) care să se ocupe de tratarea excepției.
8. Excepții
 Un handler este specificat prin cuvintele cheie try-catch.
 O metodă care poate genera o excepție trebuie să specifice acest lucru în

declarația metodei, utilizând cuvântul cheie throws urmat de tipul excepției.
 Tratarea excepțiilor se realizează prin intermediul blocurilor try-catch-
finally. Blocul try conține secvența de cod care poate genera o excepție. La
apariția unei excepții execuția secvenței din acest bloc este oprită și se caută
blocul catch corespunzător pentru tratarea excepției respective. În cazul în
care la execuție nu apare nici o excepție, secvența de cod din blocul try se
execută până la capăt după care se trece la execuția secvenței din blocul
finally (dacă acesta este prezent) și apoi se va ieși din try-catch-finally.
 Corespunzător unui bloc try pot exista mai multe blocuri catch. Secvența de
cod din blocul finally se execută indiferent dacă apare sau nu o excepție.
8. Excepții
Forma generală de tratare a excepţiilor este:
try {
//instrucţiuni ce pot declanşa excepţii
}
[catch(TipExcepție1 obiectExcepție) {
// instrucţiuni de tratare a excepţiei de clasă TipExcepție

}]
[catch(TipExcepție2 obiectExcepție) {
// instrucţiuni de tratare a excepţiei de clasă TipExcepție
}]
[finally {
//instrucţiuni care se execută necondiţionat la sfârşit
}]
8. Excepții
Excepţiile sunt grupate într-o ierarhie de clase.
Interceptarea unei excepţii se poate face fie la nivelul clasei specifice pentru
acea excepţie fie la nivelul uneia din superclasele sale.
try {
FileReader f = new FileReader("input.dat");
//acest apel poate genera excepţie de tipul FileNotFoundException

//tratarea ei poate fi facută în unul din blocurile catch următoare:
}
catch (FileNotFoundException e) {
//excepţie specifică provocată de absenţa fişierului 'input.dat'
} //sau
catch (IOException e) {
//excepţie generică provocată de o operaţie de intrare/ieşire
} //sau
catch (Exception e) {
//cea mai generica excepţie
}
8. Excepții
Exemplu: public class TestExceptions {
public static void main( String[ ] args) {

String test = "nu";
try {
System.out.println("start try");
doRiscant (test);
System.out.println("sfarsit try");
} catch ( Exception ex) {

System.out.println("o exceptie");
} finally {
System.out.println("finally");
}
System.out.println("sfarsit main");
}
static void doRiscant (String test) throws Exception {
System.out.println("start doRiscant");
if("da".equals(test)) {
throw new Exception();
}
System.out.println("sfarsit doRiscant");
return;
}
}
8. Excepții
Programul anterior are următoarea ieșire:
start try
start doRiscant
sfarsit doRiscant
sfarsit try
finally
sfarsit main
Dacă înlocuim linia String test = “nu”; cu String test = “da”; ieșirea va fi:
start try
start doRiscant
o exceptie
finally
sfarsit main
8. Excepții
 Java pune la dispoziție o ierarhie de clase de tip excepție. La baza ierarhiei
stă clasa Throwable.

 O clasă derivată din Throwable este clasa Error care specifică excepțiile
de tip eroare care duc la terminarea programului. Aceste tipuri de erori provin
în general de la mașina virtuală Java.

 Cele mai utilizate sunt excepțiile de tip Exception, clasă ce va fi derivată
atunci când se dorește crearea unei excepții. Dintre clasele derivate din
Exception se remarcă clasa RuntimeException, ce cuprinde excepții care
pot apărea în execuția unui program în urma unor operații nepermise de
genul: operații aritmetice nepermise (împărţire la zero), accesul nepermis la
un obiect (accesarea membrilor unui obiect cu valoarea null), depășirea
indexului unui tablou etc.
8. Excepții
 Compilatorul verifică toate excepțiile, mai puțin pe cele derivate din clasa
RuntimeException, numite excepții de execuție.
 Excepțiile RuntimeException pot fi lansate oriunde, cu sau fără declarații

throws sau blocuri try/catch.
 Cele mai multe excepții RuntimeException sunt cauzate de o problemă logică
din cod.
Metode moștenite din clasa Throwable:

getMessage( ) – retunează mesajul excepţiei.
toString( ) – returnează numele clasei excepţiei şi mesajul excepţiei.
printStackTrace( ) – afişează numele clasei excepţiei, mesajul excepţiei şi stiva de
apeluri.
8. Excepții
Ierarhia claselor ce descriu excepţii
8. Excepții
Există două tipuri de excepții:
 Verificate :
- Sunt excepții ce trebuie incluse în lista de excepții aruncate de o metodă;
- Compilatorul verifică dacă există blocuri try-catch care tratează aceste excepții.
8. Excepții
 Neverificate :
-Sunt excepții ce nu trebuie neapărat incluse în lista de excepții aruncate de o metodă;
-Compilatorul nu verifică dacă există un bloc catch care tratează aceste excepții.
8. Excepții
Excepţii create de utilizator
– pentru a construi o excepţie verificată de compilator, se moşteneşte clasa Exception

sau orice subclasă a acesteia.
- pentru a construi o excepţie care nu este verificată de compilator, se moşteneşte clasa
RuntimeException sau orice subclasă a acesteia.

- prin convenţie, orice clasă excepţie trebuie să conţină un constructor implicit care nu
are parametri şi un constructor care are ca parametru un şir de caractere.
Exemplu:
public class MyException extends Exception

{
public MyException( ) { }
public MyException( String mesaj ) { super(mesaj); }
}
UNIVERSITATEA TEHNICĂ “GHEORGHE ASACHI” DIN IAŞI
Programare Java
III. Fire de execuție în Java
2016
Fire de execuție în Java
Cuprins
1. Introducere
2. Crearea unui fir de execuție

3. Stările unui fir de execuție
4. Crearea și lansarea a două fire de execuție
5. Prioritatea firelor de execuție
6. Sincronizarea firelor de execuție
7. Întrebări
1. Introducere
 Conceptul de multitasking
- se referă la capacitatea unui calculator de a executa mai multe programe în

același timp
- nu implică neapărat un sistem multiprocesor: SO conține un mecanism de
management al sarcinilor. Astfel, SO alocă fiecărui task o cuantă de timp
pentru execuție, cuantă în care respectivul task este executat de procesor.
Accesul task-urilor la procesor se face periodic. Task-urile care nu se execută își

așteaptă rândul într-o coadă de așteptare. Ordinea în coadă este stabilită pe
baza unui mecanism de priorități.
- rezultă o aparentă execuție simultană a mai multor programe
1. Introducere
 Conceptul de multithreading (fire multiple de execuție)
- reprezintă capacitatea unui program de a executa mai multe secvențe de cod

în același timp (ex: animație imagini, transmiteri simultane de imagini şi
sunete, comunicația cu un server)
- Un fir de execuție (thread) este o succesiune secvențială de instrucțiuni care se
execută în cadrul unui proces.

1. Introducere
 Fire de execuţie în Java
- Limbajul Java suportă multithreading prin clasele disponibile în

pachetul java.lang.
- Un fir de execuție lansat de cod este un fir executat separat, având

propria stivă de apeluri.
- Orice aplicație Java pornește cu un fir de execuție principal - cel care
adaugă metoda main() pe poziția cea mai de jos a stivei.
- Firul de execuție principal este lansat de mașina virtuală Java.
- Putem scrie cod care lansează fire de execuții proprii.
1. Introducere
 Fir de execuție principal. Fir de execuție lansat de cod.
fir de execuție principal un alt fir de execuție

lansat de cod
Mașina JVM apelează metoda main( ). Dacă metoda main( ) lansează un nou fir de
execuție, firul de execuție principal poate fi temporar înghețat și începe rularea
noului fir de execuție. Mașina JVM comută execuția între firul nou și firul principal,
până când sunt executate ambele fire.
Pentru a dezvolta programe multithread, există două clase și o interfață în pachetul
java.lang:
Thread
 clasa Thread
void join( )
 clasa ThreadGroup
void start ( )
 interfața Runnable ...

static void sleep( )
Clasa Thread și interfața Runnable oferă suport pentru lucrul cu threaduri ca
entități separate, iar clasa ThreadGroup permite crearea unor grupuri de thread-uri.
Clasa Thread implementează interfața Runnable, iar un obiect ThreadGroup
conține mai multe obiecte de tip Thread.
Pentru a crea un fir de execuție există două variante:
1) Crearea unei clase derivate din clasa Thread.
2) Crearea unei clase care să implementeze interfața Runnable.
Obs. Este preferată a doua metodă din perspectiva orientării pe obiecte.
Crearea unui fir de execuție prin derivarea clasei Thread
1. Crearea unei clase ce extinde clasa Thread și supradefinirea metodei run ().
public class FirExecutie extends Thread {

@Override
public void run ( ) {
// codul firului de execuție
}
}
FirExecutie fir = new FirExecutie ( );
3. Lansarea în execuție a firului
fir.start( );
Crearea unui fir de execuție prin derivarea clasei Thread

Exemplu:
class FirExecutie extends Thread { // firul de execuție

public void run() {

System.out.println(" acest fir se execută ... ");
}
} // sf. Clasa FirExecutie
class TestFir {
public static void main(String [] args ) {
FirExecutie t = new FirExecutie ();
// datorită extinderii clasei Thread putem apela metoda start ()
// și această metodă va apela metoda run ().
//start() este o metodă a clasei Thread.
t.start();
} // sf. main()
} // sf. clasa TestFir
Crearea unui fir de execuție utilizând interfața Runnable
1. Crearea unui obiect Runnable ( obiectul de activitate a firului de execuție)

Runnable threadJob = new MyRunnable ( );
- un obiect Runnable conține metoda care ajunge în partea de jos a stivei

noului fir de execuție: run( ).
2. Crearea unui obiect Thread și transmiterea obiectului Runnable ca parametru
Thread MyThread = new Thread ( threadJob);
- Constructorul clasei Thread va spune obiectului MyThread ce metodă să

adauge în partea de jos a stivei, adică metoda run( ) a obiectului Runnable.
Crearea unui fir de execuție utilizând interfața Runnable
3. Pornirea firului de execuție

MyThread.start ( );
- Apelarea metodei start( ) a obiectului Thread înseamnă trecerea de la a

avea doar o instanță Thread la a avea un nou fir de execuție.
- Atunci când își începe execuția, noul fir ia metoda run( ) a obiectului
Runnable și o adaugă în partea de jos a stivei de apeluri a noului fir de
execuție.
Interfața Runnable definește o singură metodă:

// cod ce va fi rulat de noul fir de execuție
}
 Crearea unui fir de execuție utilizând interfața Runnable
Exemplu:
public class MyRunnable implements Runnable {

public void run( ) {
go( );
}
public void go( ) {
doMore( );
} 2
public void doMore( ) {
System.out.println(" In varful stivei");
}
}
 Crearea unui fir de execuție utilizând interfața Runnable
class ThreadTest {
public static void main ( String [ ] args) {
Runnable threadJob = new MyRunnable( );
Thread myThread = new Thread(threadJob);
myThread.start( ); // 1
System. out. println("Inapoi in main");
}
}
firul de execuție principal noul fir de execuție
1 2
 Constructori şi metode ale clasei Thread:
Thread() Creează un obiect Thread

Thread(Runnable) Creează un obiect Thread dintr-un obiect care implementează interfaţa

Runnable.
Thread(String) Creează un obiect Thread cu un nume specificat
Thread(Runnable, String) Creează un obiect Thread cu un nume specificat, dintr-un obiect care
implementează interfaţa Runnable.
run() Implementeză metoda run a interfeţei Runnable. Această metodă trebuie suprascrisă
în toate subclasele şi conţine codul ce este executat de firul de execuţie.
start() Trece firul de execuţie în starea EXECUTABIL, astfel poate fi lansat în execuţie de către
planificatorul JVM.
getName() Returnează numele firului de execuţie.
currentThread() Este o metodă statică ce returnează o referinţă la firul curent aflat în execuţie.
sleep(long) Este o metodă statică ce trece firul curent aflat în execuţie în starea BLOCAT pentru un
număr de milisecunde specificat ca parametru, astfel încât alt fir de execuţie să poată
rula.
Interrupt() Întrerupe execuţia unui fir.
isInterrupted() Returnează true dacă firul de execuţie a fost întrerupt.

 Un fir de execuție se poate afla în una din stările:
 nou creat: Thread t = new Thread( r);
 executabil (runnable): t.start( );

 în execuție (running)
 blocat (not-runnable) - temporar neexecutabil
 terminat
De obicei, un fir de execuție comută între stările executabil și în execuție, pe măsură ce

planificatorul JVM al firelor de execuție selectează un fir și apoi îl întrerupe, astfel încât
să ofere o șansa de a fi lansat în execuţie și altui fir de execuție.
Implementările planificatorului sunt diferite de la o mașină la alta și chiar rularea
aceluiași program pe aceeași mașină poate să ducă la rezultate diferite.
Soluția: se poate influența ordinea de execuţie a firelor adormind periodic fiecare fir
folosind metoda sleep( ).
Se apelează constructorul
clasei Thread pentru a crea o
1
nouă instanţă a clasei Thread.
Firul de execuţie poate ajunge în

Se apelează metoda starea BLOCAT din diferite motive (ex:
NOU start() pentru a trece 4 aşteaptă finalizarea unei operaţii I/O)
2 firul în starea executabil. şi nu va rula din nou până nu va reveni
în starea EXECUTABIL.
BLOCAT
Planificatorul JVM de
execuţie a firelor poate
3 decide lansarea în
execuţie a firului.
EXECUTABIL
Firul de execuţie este în starea

TERMINAT odată cu
ÎN AŞTEPTARE
6
terminarea execuţiei metodei
run().
Dacă firul apelează o metodă wait() sau

TERMINAT 5 sleep(), va trece în starea ÎN AŞTEPTARE şi va
rămâne în această stare până când un alt fir
va apela o metodă notify() sau notifyAll() sau
dacă timpul de aşteptare expiră.
 Uneori programul rulează astfel:


 Iar alteori programul rulează astfel:
Ieșiri ale programului anterior:

% java ThreadTest
Inapoi in main
In varful stivei
% java ThreadTest
In varful stivei
Inapoi in main
% java ThreadTest
In varful stivei
Inapoi in main
% java ThreadTest
In varful stivei
Inapoi in main
% java ThreadTest
Inapoi in main
In varful stivei
 “Adormirea” unui fir de execuție:
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {
ex.printStackTrace( );
}
-scoate firul de execuție din starea “ în execuție“ și îl ține în așteptare 2

secunde.
- firul nu poate fi selectat pentru rulare decât după ce au trecut cel puțin 2
secunde
- metoda sleep( ) poate lansa o excepție InterruptedException, care este o
excepție verificată de compilator
-La trezire, firul de execuție ajunge în starea executabil și așteaptă să fie
selectat pentru rulare (nu devine automat fir de execuție curent)
 “Adormirea” unui fir de execuție: % java ThreadTest
public class MyRunnable implements Runnable { Inapoi in main

public void run( ) {
In varful stivei
go( );
}
public void go( ) { % java ThreadTest
try { Inapoi in main
Thread.sleep(2000); In varful stivei
} catch (InterruptedException ex) {

ex.printStackTrace( );
% java ThreadTest
}
doMore( ); Inapoi in main
} In varful stivei
public void doMore( ) {
System.out.println(" In varful stive"); % java ThreadTest
} Inapoi in main
} In varful stivei
class ThreadTest {
public static void main ( String [ ] args) { % java ThreadTest
Runnable threadJob = new MyRunnable( ); Inapoi in main
Thread myThread = new Thread(threadJob); In varful stivei
myThread.start( );
System. out. println("Inapoi in main");
} Apelarea metodei sleep( ) forțează noul fir de execuție să-și întrerupă rularea.
} Firul de execuție principal redevine firul curent și afișează textul “Înapoi in main”.
Programul face apoi o pauză de 2 secunde înainte să ajungă la linia doMore() și
să afișeze textul “In varful stivei”.
 Numele unui fir de execuție
-un fir de execuție poate fi denumit folosind metoda setName( ).

- toate firele de execuție primesc nume prestabilite, dar stabilirea unor nume explicite
poate ajuta la urmărirea firelor de execuție
Exemplu: lansarea a două fire de execuție
-fiecare fir de execuție are același lucru de făcut: execută un ciclu, afișând numele
firului de execuție curent la fiecare iterație.
- se va crea o instanță Runnable.
- se vor crea cele două fire de execuție, folosind același obiect Runnable (aceeași
sarcină de făcut).
- se denumesc firele de execuție.
- fiecare fir de execuție va parcurge ciclul for afișându-și de fiecare dată numele.
public class TwoThreads implements Runnable {

TwoThreads r = new TwoThreads( );
Thread alfa = new Thread ( r);
Thread beta = new Thread ( r);
alfa.setName(“Primul fir”);
beta.setName(“Al doilea fir”);
alfa.start( );
beta.start( );
}

for (int i=0; i<25; i++) {
String numeThread = Thread.currentThread( ). getName( );
System.out.println (“i=“+i+ numeThread + “ruleaza”);
}
}
}
Întrebări:
-Firele de execuție vor fi rulate pe rând?

-Vom vedea alternativ numele celor două fire de execuție?
-Cât de des va trece programul de la un fir de execuție la celălalt?
Răspuns: nu știm! Depinde de planificator.
i= 5 Al doilea fir ruleaza
i= 0 Primul fir ruleaza i= 19 Primul fir ruleaza

i= 0 Al doilea fir ruleaza i= 11 Primul fir ruleaza i= 14 Al doilea fir ruleaza
i= 1 Primul fir ruleaza i= 6 Al doilea fir ruleaza i= 20 Primul fir ruleaza
i= 6 Primul fir ruleaza i= 16 Primul fir ruleaza i= 19 Al doilea fir ruleaza
i= 7 Primul fir ruleaza i= 11 Al doilea fir ruleaza i= 20 Al doilea fir ruleaza
i= 9 Primul fir ruleaza i= 12 Al doilea fir ruleaza i= 22 Al doilea fir ruleaza
i= 13 Al doilea fir ruleaza i= 24 Al doilea fir ruleaza
 Concluzii:
-Două sau mai multe fire de execuție care au acces la același obiect pot duce
la alterarea datelor dacă un fir de execuție, de exemplu, iese din rulare în

mijlocul unei operații de manipulare a stării critice a obiectului.
-Pentru a face obiectele sigure din punct de vedere al firelor de execuție,
trebuie să decidem ce metode trebuie să fie rulate până la sfârșit înainte ca
un alt fir de execuție să poată intra în aceeași metodă a aceluiași obiect.

- Deși aparent firele de execuție sunt executate simultan, la un moment

dat doar un singur fir are acces la resursele sistem. Fiecare fir de execuție
obține o cuantă de timp în care are acces la resurse.
- Managementul accesului firelor de execuție la sistem se face de către

planificatorul (scheduler) firelor de execuție.
- Regulile pe baza cărora planificatorul organizează accesul firelor de
execuție la resurse sunt specifice implementării JVM în funcție de
platformă.
- Totuși un rol în stabilirea acestor reguli îl are mecanismul de priorități.
- fiecărui fir de execuție îî este asociat un nivel de prioritate, ce reprezintă

un număr întreg.
- cu cât acest nivel este mai mare cu atât firul de execuție va avea
prioritate mai mare la resurse, acest lucru este determinat de varianta de
implementare a JVM.
- Java pune la dispoziție trei constante pentru selectarea priorităţilor firelor

de execuţie, definite în clasa Thread:
public final static int MAX_PRIORITY; // valoare implicită 10
public final static int MIN_PRIORITY; // valoare implicită 1
public final static int NORM_PRIORITY; // valoare implicită 5
-prioritatea implicită a unui fir de execuție este NORM_PRIORITY.

- pentru a obține prioritatea unui fir de execuție se poate folosi metoda
getPriority( ).
- pentru a atribui o prioritate unui fir de execuție se folosește metoda:
setPriority (int) din clasa Thread.
- planificatorul va scoate din execuție un fir cu prioritate mai mică dacă un
fir de prioritate mai mare devine executabil.
class Sincro implements Runnable {
private int val;

for (int i =0; i<50;i++) {
increment( );
System.out.println(“valoarea este “ + val);
}
}
public void increment( ) {
int i=val; // partea critică a codului: adăugăm o unitate la valoarea pe care o
val=i+1; // avea în momentul “citirii” ( nu la valoarea curentă)
}
}
public class TestSincro {
Sincro job = new Sincro( ) ;
Thread alfa = new Thread(job);
Thread beta = new Thread(job);
alfa.start( );
beta.start( );
}
}
 problema actualizării pierdute
O posibilă rulare a programului anterior:
1) Firul de execuție alfa rulează un timp

- pune valoarea variabilei de instanță val în variabila i
- val este 0, așa că i este acum 0.
- atribuie variabilei val rezultatul adunării i+1
- acum val este 1

- val este 1, așa că i este acum 1
- acum val este 2
2) Firul de execuție beta rulează un timp

- acum val este 3
În acest moment, firul de execuție beta este trecut în starea executabil,
înainte de a atribui variabilei val valoarea 4!
O posibilă rulare a programului anterior:
1) Firul de execuție alfa rulează din nou, continuând de unde a rămas

- atribuie variabilei val rezultatul adunării cu i+1
- acum val este 4

- acum val este 5
2) Firul de execuție beta rulează din nou, continuând de unde a rămas

- acum val este 4
Firul de execuție alfa actualizase valoarea variabilei la 5, dar apoi a venit

firul de execuție beta, peste ceea ce a făcut alfa, ca și cum actualizarea
făcută de alfa nu s-ar fi produs niciodată.
- soluția este: sincronizarea metodei increment( )

- sincronizarea ne asigură de faptul că după ce un fir de execuție intră în
metodă vor fi parcurse toate etapele metodei înainte ca orice alt fir de
execuție să poată intra în metodă.

public synchronized void increment( ) {
int i=val;
val=i+1;
}
- cuvântul cheie synchronized împiedică folosirea simultană a metodei de
două fire de execuție
- cuvântul cheie synchronized înseamnă că un fir de execuție are nevoie de
o “cheie” pentru accesul la codul sincronizat.
-se poate face sincronizarea la nivelul instrucțiunilor sau grupurilor de instrucțiuni,
nu neapărat la nivelul metodei.

public void go {
met1( );
synchronized (this) {
met2( );
met3( );
}
}
Atunci când folosim cuvântul cheie synchronized în interiorul unei metode, nu în
declarația acesteia, trebuie să-i furnizăm ca argument obiectul a cărui cheie trebuie
să o obțină firul de execuție.
Conceptul de monitor: obiect care permite numai și numai unui singur fir de
execuție să apeleze o metodă a obiectului, la un moment dat.
O posibilă execuție a programului după sincronizarea metodei increment( ):
1) Firul de execuție alfa rulează un timp

- metoda este sincronizată, așa că obține “cheia” pentru acest obiect
- acum val este 1

- returnează cheia ( a terminat metoda increment( ) ).
- Intră din nou în metoda increment( ) și obține cheia.
În acest moment, firul de execuție alfa este trecut în starea executabil, dar
nu returnează cheia, deoarece nu a terminat metoda sincronizată.
2) Firul de execuție beta este selectat pentru rulare

- încearcă să intre în metoda increment( ). Metoda este sincronizată, așa că are
nevoie de cheie.
- cheia nu este disponibilă.
În acest moment, firul de execuție beta trebuie să aștepte până când
cheia devine disponibilă.
3) Firul de execuție alfa rulează din nou, continuând de unde a rămas

- acum val este 2
- returnează cheia
În acest moment, firul de execuție alfa este trecut în starea

executabil, dar nu mai păstrează cheia, deoarece a terminat
metoda increment( ).
4) Firul de execuție beta este selectat pentru rulare

- încearcă să intre în metoda increment( ). Metoda este sincronizată, așa
că are nevoie de cheie.
- cheia este disponibilă, deci o obține.
- pune valoarea variabilei de instanță val în variabila i.
-ș.a.m.d.
 blocajul firelor de execuție
- apare atunci când două fire de execuție dețin fiecare câte o cheie de care are
nevoie celălalt fir.
- Java nu are un mecanism pentru rezolvarea blocajelor.
- este sarcina programatorului să proiecteze corect programele, urmărind ordinea în
care sunt lansate firele de execuție

 alte metode folosite pentru sincronizare
public final void wait( )

public final void wait(long timeout)
public final void wait(long timeout, int nanos )
public final void notify( )
public final void notifyAll( )
Exemplu: problema de tip producător-consumator.

while (coadaComenzi.count() == 0) // dacă nu este nici o comandă, se aşteaptă
{
try
{ wait(); // trece firul in starea ÎN AŞTEPTARE
}
catch (InterruptedException e) { }
}
coadaComenzi.add(comanda); // se adaugă o comandă în coada de comenzi

notifyAll(); // informează celelalte fire de execuţie, astfel firele aflate
// în aşteptare vor trece în starea EXECUTABIL.
- prin apelul unui metode wait( ) a unui obiect, firul de execuție din care se face
acest apel trece în starea ÎN AŞTEPTARE.
- firul rămâne în această stare până când un alt fir de execuție va apela una din
metodele notify( ) pentru același obiect.
- Se poate specifica în metoda wait( ) durata de timp maximă de așteptare, firul de

execuție va rămâne în aşteptare până când timpul expiră sau până alt fir apelează
metoda notify( ).
- Aceste metode pot fi folosite doar în metode sincronizate, în caz contrar se va
arunca o excepţie IllegalMonitorStateException.
7. Întrebări
1. Care este diferenţa între procese şi fire de execuţie?

2. Care sunt modalităţile de creare a unui fir de execuţie? Care metodă este preferată
şi de ce?
3. Care sunt stările unui fir de execuţie?
4. Care este diferenţa între metodele sleep() şi wait()?

5. Care este diferenţa între sincronizarea unei metode şi sincronizarea unui bloc? De ce
este importantă sincronizarea? Care sunt dezavantajele sincronizării?
6. Ce este un fir daemon?
7. Cum comunică între ele firele de execuţie?
8. Ce face metoda join()?
Programare Java
IV. Interfața grafică cu utilizatorul

-AWT-
2016
Interfața grafică cu utilizatorul
Cuprins
1. Introducere
2. AWT – generalități
3. Clasa Component
4. Clasa Container
5. Layout Manager
6. Clasa Panel
7. Evenimente generate de componente
8. Componente de tip ferestre
9. Componente AWT de lucru cu meniuri
10. Componente AWT simple
1. Introducere
Interfața grafică cu utilizatorul (GUI- Graphical User Interface) se referă la

tipurile de comunicare vizuală între un program și utilizator.
GUI – este formată din ferestre, acestea conţin elemente grafice de control
(widgets) care permit interacţiunea cu utilizatorul.

Limbajul Java pune la dispozitia programatorului două biblioteci pentru
realizarea unei interfețe grafice: java.awt și javax.swing.
AWT (Abstract Windows Toolkit) – este pachetul inițial pus la dispoziție
începând cu primele versiuni de Java.
Swing – face parte din Java Foundation Classes (apare cu Java 2) și
introduce noi componente în vederea dezvoltării de interfețe grafice mai
evoluate. De asemenea, Swing oferă independență de platformă.
Abstract Windows Toolkit (AWT)

 este utilă pentru dezvoltarea de interfețe grafice simple.
 componentele grafice din pachetul java.awt sunt în legătură directă cu
așa numitele componente peer create de platforma pe care rulează JVM.

Componenta peer determină forma componentei Java și evenimentele la
care aceasta răspunde.
Corespondența componentă Java - componentă peer are avantajul
conservării aspectului interfeței în funcție de platformă.
Dezavantajul utilizării componentelor peer este legat de viteza scăzută de
reacție a interfeței grafice și imposibilitatea de a crea componente
transparente.
Componentele grafice AWT sunt derivate din clasa Component- o clasă abstractă care
defineşte interfaţa general valabilă pentru toate componentele grafice. Pentru crearea
meniurilor se foloseşte clasa abstractă MenuComponent.

Ierarhia de clase AWT

Pachete:
 java.awt
java.awt.event
Obiectele grafice:
 Component
 MenuComponent
Prin componentă vom înţelege orice obiect care poate avea o reprezentare grafică
şi care poate interacţiona cu utilizatorul. Exemple de componente: ferestre,
butoane, liste, bare de defilare, arii de text etc.

Suprafețe de afișare:
Container - este superclasa tuturor suprafețelor de afișare Java.

Obiectele grafice trebuie plasate pe o suprafață de afișare (fereastră, applet),
devenind vizibile în momentul în care suprafața pe care sunt afișate este vizibilă.
Suprafața se mai numește container.

Exemple de containere:
AWT Swing
• Panel •JPanel
• Frame • JFrame
Gestionari de poziționare: • Applet • JApplet
• Window • JWindow
LayoutManager
De gestionarea ferestrei și plasarea componentelor într-o anumită ordine pe
suprafața ei se ocupă un obiect asociat fiecărui container și care se numește
gestionar de poziționare.
Evenimente:
 AWTEvent
O componentă grafică poate genera evenimente: apăsarea unui buton,

modificarea textului, închiderea unei ferestre etc.
Evenimentele sunt instanțe ale claselor derivate din AWTEvent.
Interceptarea evenimentelor generate de componentele unui program se
realizează prin intermediul unor clase de tip listener (ascultător,
consumator de evenimente). Aceste clase sunt definite în pachetul
java.awt.event.
Exemplu: o fereastră cu un buton
import java.awt.*;
class Interfata extends Frame
{ public Interfata(String s)
{ //creare fereastra
Frame f = new Frame (s);
setBackground(Color.green);
//setare mod de dispunere a componentelor

setLayout(new FlowLayout());
//creare buton
Button buton1 = new Button("apasa-ma");
//adaugare buton
add(buton1);
}
}
public class ExempluGUI
{ public static void main(String[] args)
{ Interfata ecran = new Interfata("Fereastra");
ecran.setSize(500,100);
ecran.setVisible(true);
}
}
3. Clasa Component
Componente grafice
Componentele AWT sunt definite de clase din pachetul java.awt, aceste clase
au ca superclasă clasa Component.

 Button – butoane cu eticheta formată dintr-un text pe o singură linie.
 Canvas – suprafață de desenare.
 Checkbox – căsuţă de opţiuni, componentă ce poate avea două stări (
pentru a grupa mai multe obiecte de acest tip există clasa CheckBoxGroup).
 Choice – liste de opţiuni cu alegere unică.

3. Clasa Component
Componente grafice
Container – superclasa tuturor suprafețelor de afișare.
 Label – etichete simple ce pot conține o singură linie de text needitabil.

 List – liste de opţiuni cu selecție simplă sau multiplă.
 Scrollbar – bare de defilare orizontale sau verticale.
 TextComponent – superclasa componentelor pentru editarea textului.
-TextField – text pe o singură linie. (câmp de text)
-TextArea – text pe mai multe linii. (arie de text)

3. Clasa Component
Metode ale clasei Component
 public String getName( )

 public void setName(String name)
-pentru determinarea/stabilirea numelui componentei.
 public boolean isVisible( )

 public void setVisible (boolean b)
-verifică/setează proprietatea de vizibilitate a unei componente. Componentele de tip
fereastră sunt inițial invizibile, de aceea după crearea unei ferestre e nevoie de apelul
metodei setVisible(true) pentru a o face vizibilă.
public boolean isEnabled( )
 public void setEnabled(boolean b)
-verifică/setează proprietatea legată de activarea componentei. Doar în cazul în care este
activă, o componentă poate răspunde la acțiunile utilizatorului asupra ei și poate genera
evenimente.
3. Clasa Component
public Color getBackground( )

 public void setBackground (Color c)
-Returnează/setează culoarea de fond a componentei. Clasa Color permite lucrul cu
culorile într-un format RGB.

public Color getForeground( )
 public void setForeground (Color c)
-Returnează/setează culoarea cu care se desenează componenta.
public Font getFont( )
 public void setFont (Font f)
- Returnează/setează tipul de font utilizat pentru afișarea caracterelor. Clasa Font este
utilizată pentru lucrul cu diferite tipuri de fonturi utilizate pentru afișare. Un obiect de tip
Font conține o serie de caracteristici ale fontului (dimensiune, stil, bold, italic etc.)
3. Clasa Component
public Point getLocation( )

 public void setLocation( int x, int y)
 public void setLocation(Point p)
-returnează/setează poziția (coordonatele) componentei relativ la coordonatele colțului
stânga-sus a componentei părinte (componenta container în care se află). Clasa Point

este o clasă asociată unui punct.
public Point getLocationOnScreen( )
-Returnează coordonatele componentei relativ la colțul stânga-sus al ecranului.
 public Dimension getSize( )
 public void setSize(int width, int height)
 public void setSize(Dimension d)
-determină/setează dimensiunile componentei. Clasa Dimension grupează dimensiunile
lățime și înălțime într-un singur tip de date și conține două atribute publice width și
height prin care cele două dimensiuni pot fi accesate din exteriorul clasei.
3. Clasa Component
public Rectangle getBounds( )
 public void setBounds(int x, int y, int width, int height)

 public void setBounds(Rectangle r)
-determină/setează marginile componentei. Aceasta implică atât poziția componentei cât și
dimensiunea ei. Clasa Rectangle definește atât dimensiunile (width, height) cât și poziția
colțului stânga sus (x,y) a formei rectangulare. Poziția este relativă la componenta părinte.
 public boolean getCursor( )
 public void setCursor(Cursor c)
-returnează/setează forma cursorului. Java permite o serie de tipuri de cursor, definite prin
constantele din clasa Cursor (DEFAULT_CURSOR, CROSSHAIR_CURSOR, TEXT_CURSOR,
WAIT_CURSOR, HAND_CURSOR)
 public void list( )
 public void list(PrintStream out)
 public void list(PrintWriter out)
- afișează o serie de informații legate de componentă la consola standard sau la alte stream-
uri.
4. Clasa Container
Suprafețe de afișare
- reprezintă suprafețe pe care sunt plasate componentele.

- sunt instanțe ale unor clase derivate din clasa Container.
 Window – superclasa tuturor ferestrelor
Frame – ferestre standard

Dialog – ferestre de dialog modale sau nemodale
 Panel – suprafață fără reprezentare grafică folosită pentru gruparea altor
componente.
Applet – pentru crearea applet-urilor
 ScrollPanel – pentru implementarea automată a derulării pe orizontală sau
verticală a unei componente grafice.
4. Clasa Container
Metode ale clasei Container
 public Component add(Component comp)

 public Component add(Component comp, int index)
-adaugă componenta specificată la sfârșitul container-ului sau în poziția

specificată de index.
 void remove (Component comp)
 void removeAll( )
- șterge de pe container componenta specificată, respectiv șterge toate
componentele de pe container.
4. Clasa Container
Metode ale clasei Container
 public void setLayout(LayoutManager lm)

-stabilește gestionarul de poziționare al containerului.
 public Insets getInsets( )

-determină distanța rezervată pentru marginile suprafeței de afișare.
 public void validate( )
- forțează containerul să repozitioneze toate componentele sale. Această
metodă trebuie apelată explicit atunci când adăugăm sau eliminăm
componente de pe suprafața de afișare după ce aceasta a devenit vizibilă.
5. Layout Manager
 Layout manager = gestionar de poziționare - obiect care controlează
dimensiunea și poziția componentelor unui container.
 fiecare obiect de tip Container (Applet, Frame, Panel etc) are asociat un
obiect care se ocupă de dispunerea componentelor pe suprafața sa și anume
gestionarul său de poziționare.
 clasele pentru gestionarea poziționării implementează interfața
LayoutManager.
 la instanțierea unui container se creează implicit un gestionar de poziționare
asociat acestuia. (Exemplu: ferestre – BorderLayout, panouri: FlowLayout)

5. Layout Manager
Exemplu: poziționarea a cinci butoane
import java . awt .*;

public class TestLayout {
public static void main ( String args []) {
Frame f = new Frame (" Grid Layout ");
f. setLayout (new GridLayout (3, 2)); //gestionar de poziționare GridLayout
Button b1 = new Button (" Buton 1");

Button b2 = new Button ("B 2");
Button b4 = new Button ("Acesta este butonul 4");
f.add(b1); f.add (b2); f. add(b3); f.add(b4); f.add(b5);
f. pack ();
f.setSize(400, 150);
f.setVisible(true);}
}
5. Layout Manager
Exemplu: poziționarea a cinci butoane

Frame f = new Frame (“ Flow Layout ");
f. setLayout (new FlowLayout ( )); //gestionar de poziționare FlowLayout

f. pack ();
f.setSize(400, 150);
}
5. Layout Manager
Gestionari de poziționare AWT:
 FlowLayout
 BorderLayout
 GridLayout
 CardLayout
 GridBagLayout
Unui container i se poate asocia un gestionar de poziționare cu ajutorul metodei
setLayout a clasei Container: public void setLayout(LayoutManager gp).
Pe langa aceşti gestionari, mai există şi cei din modelul Swing care vor fi prezentaţi în
capitolul dedicat dezvoltării de aplicaţii GUI folosind Swing..

5. Layout Manager
Metode utilizate de LayoutManager:
 public Dimension getPrefferedSize( )

 public Dimension getMinimumSize( )
 public Dimension getMaximumSize( )
- Sunt utilizate pentru a calcula poziția și dimensiunea componentelor grafice
pentru afișarea lor în cadrul unui container.

5. Layout Manager
Gestionarul FlowLayout
-Este cel mai simplu layout manager. Aranjează componentele de la stânga la
dreapta și de sus în jos în ordinea adăugării componentelor în container.

-Implicit, componentele sunt centrate pe fiecare linie iar distanța implicită între
componente este de 5 pixeli pe verticală și 5 pixeli pe orizontală.
-Este gestionarul implicit al containerelor derivate din clasa Panel, deci și al
applet-urilor.
5. Layout Manager
Exemplu: gestionarul FlowLayout

Frame f = new Frame ("Flow Layout");
f. setLayout (new FlowLayout ( ));

f. pack ();
}
Redimensionând fereastra astfel încât componentele să nu mai încapă pe o linie,
acestea vor fi afisate pe linia următoare:
5. Layout Manager
Gestionarul BorderLayout
- împarte suprafața de afișare în cinci regiuni: sud, nord, est, vest și centru.
-O componentă poate fi plasată în oricare din cele cinci regiuni, dimensiunea

componentei fiind calculată astfel încât să ocupe întreg spațiul de afișare din regiune.
-Pentru a adăuga mai multe componente grafice într-una din cele cinci regiuni, acestea
trebuie grupate într-un panel, care va fi apoi adăugat în regiunea dorită.
-Adăugarea în container se face cu metoda add:
public void add (Component comp, Object const)
-Parametrul const specifică zona de dispunere a componentei și poate fi oricare din
atributele statice ale clasei BorderLayout: NORTH, SOUTH, EAST, WEST, CENTER.
-este gestionarul implicit pentru containerele derivate din clasa Window.

5. Layout Manager
Exemplu: gestionarul BorderLayout

Frame f = new Frame (" Border Layout ");
// Apelul de mai jos poate sa lipseasca
f. setLayout (new BorderLayout ());

f.add(new Button (" Nord "), BorderLayout . NORTH );
f.add(new Button (" Sud"), BorderLayout . SOUTH );
f.add(new Button (" Est"), BorderLayout . EAST );
f.add(new Button (" Vest "), BorderLayout . WEST );
f.add(new Button (" Centru "), BorderLayout . CENTER );
f. pack ();
f.setVisible(true);
}
}
La redimensionarea ferestrei nordul și sudul se modifică
doar pe orizontală, estul și vestul doar pe verticală, iar
centrul atât pe orizontală cât și pe verticală.
5. Layout Manager
Gestionarul GridLayout
- permite aranjarea componentelor pe linii și coloane, componentele fiind
plasate în celulele tabelului de la stânga la dreapta, începând cu prima linie.

- componentele vor avea aceeași dimensiune.
-Numărul de linii și coloane este specificat prin constructor la crearea obiectului
și poate fi modificat ulterior prin metodele:
public void setRows(int rows)
respectiv
public void setColumns(int cols)

5. Layout Manager
Exemplu: gestionarul GridLayout

Frame f = new Frame (" Grid Layout ");
f. setLayout (new GridLayout (3, 2));
f.add(new Button ("Buton 1"));

f.add(new Button ("Buton 2"));
f.add(new Button ("But 3"));
f.add(new Button ("B4"));
f.add(new Button ("Butonul nr.5"));
f.add(new Button ("6"));
f. pack ();
f.setVisible(true);
}
}
5. Layout Manager
Gestionarul CardLayout
- oferă posibilitatea suprapunerii componentelor una peste alta și afișarea
uneia singure la un moment dat.

-La adăugarea în container se folosește metoda public void add(Component
comp, Object const), prin obiectul const se va asocia un nume componentei
adăugate. Acest nume poate fi folosit pentru a face vizibilă componenta
respectivă utilizând metoda void show(Container parent, String name).
-O altă posibilitate de a schimba componenta vizibilă este folosirea metodelor
void next(Container parent) și void previous(Container parent) din clasa
CardLayout.
5. Layout Manager
Exemplu: gestionarul CardLayout
import java. awt .*;

import java. awt. event .*;
public class TestLayout extends Frame implements ActionListener {
Panel tab;
public TestLayout () {
super (" CardLayout ");

Button card1 = new Button (" Card 1");
Button card2 = new Button (" Card 2");
Panel butoane = new Panel ();
butoane . add( card1 );
butoane . add( card2 );
tab = new Panel ();
tab . setLayout ( new CardLayout ());
TextField tf = new TextField (" Text Field ");
Button btn = new Button (" Button ");
tab .add (" Card 1", tf);
tab .add (" Card 2", btn);
5. Layout Manager
add ( butoane , BorderLayout . NORTH );
add (tab , BorderLayout . CENTER );

pack ();
card1 . addActionListener ( this );

card2 . addActionListener ( this );
}
public void actionPerformed ( ActionEvent e) {
CardLayout gestionar = ( CardLayout ) tab. getLayout ();
gestionar . show (tab , e. getActionCommand ());
}
TestLayout f = new TestLayout ();
f. setVisible (true);
}
}
5. Layout Manager
Gestionarul GridBagLayout
- este cel mai complex și flexibil gestionar de poziționare.
-Suprafața de afișare este un tabel, însă numărul de linii și de coloane sunt determinate
automat, în funcție de componentele amplasate pe suprafață.
-Dimensiunile celulelor pot fi diferite, cu restricția ca pe aceeași linie să aibă aceeași
înălțime, iar pe coloană să aibă aceeași lățime.
-o componentă poate ocupa mai multe celule adiacente.
-Modul de afișare a unei componente se specifică prin asocierea unui obiect de tip
GridBagConstraints, ce conține diferite proprietăți ale componentei referitoare la
regiunea de afișare și la poziție.

5. Layout Manager
- legătura dintre o componentă și un obiect GridBagConstraints se realizează prin
metoda public void setConstraints(Component comp, GridBagConstraints constraints)

- Cele mai utilizate constrângeri sunt specificate prin următoarele variabile din clasa
GridBagConstraints:
 gridx, gridy – celula ce reprezintă colțul stânga sus al componentei.
 gridwidth, gridheight – numărul de celule pe linie și coloană pe care va fi afișată
componenta.
 fill – specifică dacă o componentă va ocupa tot spațiul pe care îl are destinat, valorile
posibile sunt: HORIZONTAL, VERTICAL, BOTH, NONE.

5. Layout Manager
 insets – distanțele dintre componentă și marginile suprafeței sale de afișare
 anchor – folosită atunci când componenta este mai mică decât suprafața sa
de afișare pentru a forța o anumită dispunere a sa: CENTER, NORTH,
NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST.
 weightx, weighty – folosite pentru distribuția spațiului liber, uzual are
valoarea 1.
6. Clasa Panel
- Oferă un cadru de plasare a altor componente grafice și nu are o
reprezentare vizibilă.
- clasa Panel este derivată din clasa Container, nu adaugă alte metode celor
din clasa Container.
- pentru a crea o componentă de tip Panel se poate utiliza unul dintre
constructorii: Panel( ) și Panel(LayoutManager layout), în cazul primului
constructor gestionarul implicit este de tipul FlowLayout.

6. Clasa Panel
Exemplu: gruparea componentelor folosind Panel

public class TestPanel {
Frame f = new Frame (" Test Panel ");

Panel intro = new Panel ();
intro . setLayout (new GridLayout (1, 3));
intro .add(new Label (" Text :"));
intro .add(new TextField ("", 20) );
intro .add(new Button (" Adaugare "));
Panel lista = new Panel ();
lista . setLayout (new FlowLayout ());
lista .add(new List (10) );
lista .add(new Button (" Stergere "));
6. Clasa Panel
Exemplu: gruparea componentelor folosind Panel
Panel control = new Panel ();

control . add( new Button (" Salvare "));
control . add( new Button (" Iesire "));
f.add(intro , BorderLayout . NORTH );
f.add(lista , BorderLayout . CENTER );
f.add( control , BorderLayout . SOUTH );

f. pack ();
}
}
 Evenimentul reprezintă o acțiune impusă de către utilizator (apăsarea unei taste sau a
unui buton de mouse, manevrarea barei de derulare, marcarea unei opțiuni într-un meniu,
închiderea unei ferestre etc).

 Componentele care generează evenimente se mai numesc și surse de evenimente.
 interceptarea evenimentelor generate de componente se realizează prin intermediul unor
clase de tip listener (ascultător, consumator de evenimente).
 pentru fiecare tip de eveniment există o clasă, de exemplu evenimentul generat de
acționarea unui buton este descris de clasa ActionEvent, cel generat de modificarea unui
text este descris de clasa TextEvent etc. Toate aceste clase sunt derivate din clasa
AWTEvent.
 O clasă consumatoare de evenimente specifică în declarația sa că va asculta evenimente
de un anumit tip, prin implementarea unei interfețe specifice tipului de eveniment.
 Exemplu:
class AscultaButoane implements ActionListener {

public void actionPerformed(ActionEvent e) {
// Metoda interfetei ActionListener
...
}
}
class AscultaTexte implements TextListener {

public void textValueChanged(TextEvent e) {
// Metoda interfetei TextListener
...
}
}
 Toate aceste interfețe sunt derivate din EventListener. (interfaţă din pachetul java.util)
 sursele evenimentelor permit oricărei clase să asculte evenimentele sale prin metode de tip
addTipEvenimentListener( ), unde TipEveniment este un tip de eveniment.
Exemplu:
import java . awt. event .*;

class Fereastra extends Frame implements ActionListener {
Button ok = new Button ("OK");
Button exit = new Button (" Exit ");
int n=0;
public Fereastra ( String titlu ) {

super ( titlu );
setLayout (new FlowLayout ());
setSize (200 , 100) ;
add (ok);
add ( exit );
ok. addActionListener ( this );
exit . addActionListener ( this );
// Ambele butoane sunt ascultate in clasa Fereastra
// deci ascultatorul este instanta curenta : this
}
Exemplu:
// Metoda interfetei ActionListener
public void actionPerformed ( ActionEvent e) {

if (e. getSource () == exit )
System . exit (0); // Terminam aplicatia
if (e. getSource () == ok) {
n ++;
this . setTitle ("Ati apasat OK de " + n + " ori");

}
}
}
Metoda getSource( ) returnează componenta generatoare a unui eveniment
Tratarea evenimentelor – pe scurt:
1. Determină ce eveniment apare.

De ex: evenimentul ce apare la apăsarea butonului Close al unei ferestre
2. Decide ce clasă/interfaţă va trata acest eveniment.

public interface WindowListener extends EventListener {

void windowActivated(WindowEvent e);
void windowClosed(WindowEvent e);
void windowClosing(WindowEvent e);
void windowDeactivated(WindowEvent e);
void windowDeiconified(WindowEvent e);
void windowIconified(WindowEvent e);
void windowOpened(WindowEvent e);
}
3
3. Declară clasa care “ascultă” evenimente, clasa implementează interfeţe specifice fiecărui tip de
eveniment – acestea descriu metode ce vor fi apelate automat la apariţia evenimentelor.
import java.awt.*;
implements WindowListener
import java.awt.event.*;
public class Handler {
public void windowActivated(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowClosing(WindowEvent e) {
Window w = e.getWindow();
w.setVisible(false);
w.dispose();
System.exit(0);
}
public void windowDeactivated(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
}
4. Precizează în ce clasă (clasa de tip listener) este localizată metoda ce se va executa

când apare evenimentul. Sursele evenimentelor permit oricărei clase sa ”asculte”
evenimentele sale prin metode de tip addXXXListener;
import java.awt.*;
public class HelloGUI {

public static void main (String[] args) {
Handler h = new Handler();
System.out.println (“Creare GUI");
Frame f = new Frame ("Hello GUIs");
f.setSize( 200, 200 );
f.addWindowListener(h);
f.setVisible(true);
System.out.println(“Finalizare GUI");
} // main
} // clasa HelloGUI
Tipuri de evenimente:
1) Evenimente de nivel jos (generate la acțiuni directe ale utilizatorului asupra
componentei)
 ComponentEvent
- este generat când componenta este ascunsă, mutată, redimensionată, afișată.
-Pentru a răspunde la acest eveniment trebuie implementată interfața
ComponentListener:
public interface ComponentListener extends EventListener {
public abstract void componentResized(ComponentEvent e);
public abstract void componentMoved(ComponentEvent e);
public abstract void componentShown(ComponentEvent e);
public abstract void componentHidden(ComponentEvent e); }
FocusEvent
-Aceste eveniment este legat de obținerea sau pierderea focusului.
- dacă o componentă este în focus atunci evenimentele generate de tastatură îi sunt
adresate respectivei componente. Interfața care trebuie implementată este
FocusListener:
public interface FocusListener extends EventListener {
public abstract void focusGained(FocusEvent e);
public abstract void focusLost(FocusEvent e); }
1) Evenimente de nivel jos
 KeyEvent
-este generat la acțiunea tastaturii (apăsare, eliberare taste, tastare)
-Interfața care trebuie implementată este KeyListener:
public interface KeyListener extends EventListener {
public abstract void keyTyped(KeyEvent e);
public abstract void keyPressed(KeyEvent e);

public abstract void keyReleased(KeyEvent e);
}
 MouseEvent
-Acest eveniment este legat de anumite acțiuni ale mouse-ului în cadrul componentei.
-Interfața care trebuie implementată este MouseListener:
public interface MouseListener extends EventListener {
public abstract void mouseClicked(MouseEvent e);
public abstract void mousePressed(MouseEvent e);
public abstract void mouseReleased(MouseEvent e);
public abstract void mouseEntered(MouseEvent e);
public abstract void mouseExited(MouseEvent e);
}
1) Evenimente de nivel jos
 WindowEvent
-Eveniment legat de acțiuni asupra ferestrelor: minimizare, maximizare, deschidere,
închidere etc.
-Interfața care trebuie implementată este WindowListener:
public interface WindowListener extends EventListener {
public abstract void windowOpened(WindowEvent e);

public abstract void windowClosing(WindowEvent e);
public abstract void windowClosed(WindowEvent e);
public abstract void windowIconified(WindowEvent e);
public abstract void windowDeiconified(WindowEvent e);
public abstract void windowActivated(WindowEvent e);
public abstract void windowDeactivated(WindowEvent e);
}
Tipuri de evenimente:
2) Evenimente semantice (reprezintă interacțiunea cu o componentă GUI: apăsarea
unui buton, selectarea unui articol dintr-o listă etc)
 ActionEvent
-Acționare
- Interfața care trebuie implementată este ActionListener:
public interface ActionListener extends EventListener {

public abstract void actionPerformed(ActionEvent e);
}
 AdjustmentEvent
- ajustarea unei valori
- Interfața care trebuie implementată este AdjustmentListener:
public interface AdjustmentListener extends EventListener {
public abstract void adjustmentValueChanged(AdjustmentEvent e);
}
2) Evenimente semantice
 ItemEvent
- schimbarea stării
- Interfața care trebuie implementată este ItemListener:
public interface ItemListener extends EventListener {
public abstract void itemStateChanged(ItemEvent e);
}
 TextEvent
- schimbarea textului
- Interfața care trebuie implementată este TextListener:
public interface TextListener extends EventListener {
public abstract void textValueChanged(TextEvent e);
}
Clase adaptori
-Atunci când o clasă care tratează evenimente implementează interfața

corespunzătoare tipului de eveniment, ea trebuie să implementeze obligatoriu
toate metodele definite de acea interfață.

-Pentru situațiile în care nu ne interesează toate metodele interfeței, se poate
folosi o serie de clase care implementează interfețele de tip Listener fără a
specifica cod pentru metodele lor. Aceste clase se numesc adaptori.
-Un adaptor este o clasă abstractă care implementează o anumită interfață fără
a specifica cod nici unei metode a interfeței.
-Scopul unui adaptor este ca la crearea unei clase ascultătoare de evenimente, în
loc să se implementeze interfața, extindem adaptorul corespunzător interfeței
respective și implementăm metodele care ne interesează.
Clase adaptori
În tabelul următor sunt dați adaptorii interfețelor de tip listener. Interfețele care nu au
adaptor sunt cele care definesc o singură metodă și deci crearea unei clase adaptor nu are
sens.
Interfața Adaptor
ActionListener nu are
AdjustmentListener nu are
ComponentListener ComponentAdapter
ContainerListener ContainerAdapter
FocusListener FocusAdapter
ItemListener nu are
KeyListener KeyAdapter
MouseListener MouseAdapter
MouseMotionListener MouseMotionAdapter
TextListener nu are
WindowListener WindowAdapter
1)Clasa Window
- Implementează o fereastră grafică fără titlu și fără chenar.
- Este derivată din clasa Container.

- Metodele mai importante ale clasei sunt:
 public void show( )
- face vizibilă fereastra și o aduce în fața altor ferestre grafice existente.
 public void hide( )
- face fereastra invizibilă fără a o distruge însă.

 public boolean isShowing( )
- verifică dacă fereastra este vizibilă sau nu.
 public void dispose( )
- închide fereastra și eliberează toate resursele acesteia.
 public void pack( )
- redimensionează automat fereastra la o suprafață optimă care să cuprindă toate
elementele sale, se apelează în general după adăugarea tuturor componentelor pe
suprafața ferestrei.
 public Component getFocusOwner( )
- returnează componenta ferestrei care are focus-ul (dacă fereastra este activă).
 public void toFront( )
 public void toBack( )
- mută fereastra în față, respectiv în spatele altor ferestre grafice existente.
2) Clasa Frame
public class Frame extends Window implements MenuContainer

- Este derivată a clasei Window și este folosită pentru crearea de ferestre independente
și funcționale, cu bară de titlu și poate avea și o bară de meniuri.
- Constructorii Frame( ) și Frame(String title) permit crearea unei feresre inițial invizibilă,
parametrul title desemnează șirul afișat în bara de titlu a ferestrei. Pentru a face
fereastra vizibilă se folosește apelul metodei setVisible(true).

- gestionarul de poziționare implicit al clasei Frame este BorderLayout.
- Metode mai utilizate:
 public static Frame [ ] getFrame( )
- returnează lista tuturor ferestrelor deschise ale unei aplicații.
 public void setIconImage(Image im)
- Setează obiectul imagine utilizat ca icoană la minimizarea ferestrei grafice.
 public void setMenuBar (MenuBar mb)
- Setează bara de meniuri asociată ferestrei.
 public void setTitle(String title)
- Setează titlul ferestrei.
 public void setResizable(boolean res)
- stabilește dacă fereastra poate fi redimensionată de utilizator.
3) Clasa Dialog
public class Dialog extends Window

- Este utilizată pentru a crea o fereastră grafică de tip dialog, utilizată de obicei pentru
afișarea unor mesaje și pentru a prelua date de la utilizator.
- Fereastra de tip Dialog are o bară de titlu dar nu poate avea o bară de meniuri.
- Fereastra de dialog este dependentă de o altă fereastră numită fereastră părinte, când
fereastra părinte este distrusă sunt distruse și ferestrele sale de dialog, iar când
fereastra părinte este minimizată ferestrele de dialog sunt făcute invizibile.
- Pot fi de două tipuri:
 modale: care blochează accesul la fereastra părinte în momentul deschiderii lor, cum
sunt ferestrele de introducere a unor date, de alegere a unui fișier, de selectare a unei
opțiuni etc.
 nemodale: care nu blochează fluxul de intrare către fereastra părinte, cum ar fi dialogul
de căutare a unui cuvânt într-un fișier.
- implicit, o fereastră de dialog este nemodală și invizibilă.
3) Clasa Dialog
 Constructorii mai utilizați sunt:

Dialog(Frame parent)
Dialog(Frame parent, boolean modal)
Dialog(Frame parent, String title)
Dialog(Frame parent, String title, boolean modal)

Dialog(Dialog parent)
Dialog(Dialog parent, String title)
Dialog(Dialog parent, String title, boolean modal)
 Alte metode:
public void setModal(booolean)
public boolean isModal( )
- setează/verifică tipul ferestrei (modală sau nu)
public String getTitle( )
public void setTitle(String title)
- returnează/setează titlul ferestrei.
4) Clasa FileDialog
public class FileDialog extends Dialog

- Este o clasă derivată din clasa Dialog și este utilizată pentru a crea o
fereastră de dialog pentru selecția unui fișier.
- Fereastra afișează un arbore ce reprezintă structura ierarhică a directoarelor

și fișierelor și permite utilizatorului căutarea în această structură și selecția
unui fișier.
- Există două tipuri de ferestre FileDialog: fereastră de tip load și fereastră
de tip save.
- Fereastra de tip load permite doar selecția unui fișier existent în structura
de directoare iar cea de tip save oferă posibilitatea de a creea un fișier
nou.
- După ce este selectat un fișier, fereastra se închide automat.
4) Clasa FileDialog
 Are constructorii:
FileDialog(Frame parent)
FileDialog(Frame parent, String title)
FileDialog(Frame parent, String title, int mod)
- Parametrul mod specifică tipul ferestrei (save sau load), pentru

specificarea acestui tip clasa conține două constante statice și anume:
SAVE și LOAD, implicit tipul ferestrei este load.
 Alte metode:
public int getMode( )
public void setMode(int mod)
- returnează/setează tipul ferestrei (save sau load).
public String getDirectory( )
public void setDirectory(String dir)
- returnează/setează directorul de lucru
public String getFile( )
Public void setFile(String file)
- returnează/setează fișierul selectat
1) Clasa MenuComponent
- Este o clasă abstractă derivată din clasa Object și este superclasa tuturor
claselor de tip meniu.
- Câteva dintre metodele clasei sunt:
public String getName( )

public void setName(String name)
- returnează/setează numele componentei.
public MenuContainer getParent( )
- returnează părintele componentei de tip meniu.
public Font getFont( )
public void setFont(Font f)
- returnează/setează tipul de font utilizat pentru afișare.
2) Clasa MenuBar
- Este o clasă derivată din clasa MenuComponent și este utilizată pentru a

crea o bară de meniuri asociată unei ferestre cadru de tip Frame folosind
metoda setMenuBar(MenuBar bar) a clasei Frame.
3) Clasa MenuItem
- Este o clasă derivată din clasa MenuComponent și reprezintă clase ce
implementează un meniu.
- La selecția unui meniu, acesta generează un eveniment de tipul
ActionEvent.
4) Clasa Menu
- Este o clasă derivată din clasa MenuItem și este componenta ce oferă
posibilitatea realizării unei structuri verticale de meniuri.
5) Clasa CheckboxMenuItem
- Este o clasă derivată din clasa MenuItem și implementează interfața

ItemSelectable.
- Implementează într-un meniu articole de tip comutator- care are două stări
logice (ON/OFF), acționarea articolului determinând trecerea sa dintr-o stare

în alta și generarea unui eveniment de tipul ItemEvent.
6) Clasa PopupMenu
- Este o clasă derivată din clasa Menu și reprezintă o componentă de tip meniu
popUp care poate fi asociată oricărei componente grafice derivată din clasa
Component.
- Asocierea cu o componentă grafică de tipul Component se face prin metoda
add(PopupMenu popup) din clasa Component.
Exemplu: crearea unui meniu

import java . awt. event .*;
public class TestMenu {
Frame f = new Frame (" Test Menu ");
MenuBar mb = new MenuBar ();

Menu fisier = new Menu (" File ");
fisier . add( new MenuItem (" Open "));
fisier . add( new MenuItem (" Close "));
fisier . addSeparator ();
fisier . add( new MenuItem (" Exit "));
Menu optiuni = new Menu (" Options ");
optiuni . add( new MenuItem (" Copy "));
optiuni . add( new MenuItem ("Cut"));
optiuni . add( new MenuItem (" Paste "));
Menu editare = new Menu (" Edit ");
editare . add( new MenuItem (" Undo "));
editare . add( optiuni );

editare . addSeparator ();
editare . add( new CheckboxMenuItem (" Bold "));
editare . add( new CheckboxMenuItem (" Italic "));
mb. add( fisier );
mb. add( editare );

f. setMenuBar (mb);
f. setSize (200 , 100) ;
}
}
1) Clasa Label
- Reprezintă o componentă pentru plasarea unui text pe o suprafață de afișare.

- Textul nu poate fi modificat de către utilizator dar poate fi modificat din
program.
public class TestMenu {

Frame f = new Frame (" Label ");
Label nord , sud , est , vest , centru ;
nord = new Label (" Nord ", Label . CENTER );
nord . setForeground ( Color . blue );
sud = new Label ("Sud ", Label . CENTER );
sud . setForeground ( Color .red);

vest = new Label (" Vest ", Label . LEFT );
vest . setFont ( new Font (" Dialog ", Font .ITALIC , 14));
est = new Label ("Est ", Label . RIGHT );
est . setFont ( new Font (" Dialog ", Font .ITALIC , 14));
centru = new Label (" Centru ", Label . CENTER );
centru . setBackground ( Color .green );
centru . setFont ( new Font (" Arial ", Font .BOLD , 20));
f.add(nord , BorderLayout . NORTH );
f.add(sud , BorderLayout . SOUTH );
f.add(est , BorderLayout . EAST );
f.add(vest , BorderLayout . WEST );
f.add(centru , BorderLayout . CENTER );
f. pack ();
}
}
2) Clasa Button
- Reprezintă o componentă pentru plasarea unui buton pe o suprafață de

afișare.
- Este o componentă activă, asupra ei se poate acționa de către utilizator.
- Textul este format dintr-o singură linie.

3) Clasa Choice
- Definește o listă de opțiuni din care utilizatorul poate selecta una singură.
- La un moment dat, o singură opțiune din listă este vizibilă
- Este o componentă grafică de tipul pop-up menu.
4) Clasa List
- Definește o listă de opțiuni care permite utilizatorului să selecteze una sau

mai multe opțiuni la un moment dat.
- Opțiunile sunt afișate într-o componentă de dimensiune fixă, având un
scrollbar.
5) Clasa Checkbox
- Reprezintă o componentă care se poate găsi în două stări: on sau off.

- Prin acțiunea utilizatorului cu mouse-ul asupra componentei se schimbă
starea ei.
6) Clasa CheckboxGroup
- Definește un grup de comutatoare (Checkbox) din care doar unul poate fi

selectat
- Aceste componente se mai numesc butoane radio.
7) Clasa Scrollbar
- definește o bară de defilare pe verticală sau pe orizontală.

- Permite selecția dintr-un domeniu de valori numerice a unei valori sau a unui
subdomeniu.
8) Clasa ScrollPane
- Permite atașarea unor bare de defilare orizontală și/sau verticală oricărei

componente grafice.
- Este utilă pentru acele componente care nu au implementată funcționalitatea
de defilare automată, cum ar listele.

9) Clasa TextField
- Definește un control de editare a textului pe o singură linie

- Este utilă pentru interogarea utilizatorului asupra unei valori.
10) Clasa TextArea

- Definește un control de editare a textului pe mai multe linii
- Este utilă pentru editarea de texte, introducerea unor comentarii etc.
Programare Java
V. Interfața grafică cu utilizatorul

-Swing-
2016
Cuprins
1. Swing – generaliăți
2. Clasa JFrame
3. Clasa Jcomponent
4. Clasa Jlabel
5. Clasan ImageIcon
6. Clasa JTextComponent
7. Clasa JTextField
8. Clasa JTextArea
9. Clasa JList
10. Clasa Jtable
11. Desenarea în Java
12. Clasa Graphics
13. Clasa Font
14. Clasa Color
15. Desenarea în Swing
16. Look and Feel
1. Swing – generalități
Interfața grafică cu utilizatorul (GUI- Graphical User Interface) se referă la

tipurile de comunicare vizuală între un program și utilizator.
GUI – este formată din ferestre, acestea conţin elemente grafice de control
care permit interacţiunea cu utilizatorul.

Limbajul Java pune la dispoziția programatorului două biblioteci pentru
realizarea unei interfețe grafice: java.awt și javax.swing.
AWT (Abstract Windows Toolkit) – este pachetul inițial pus la dispoziție
începând cu primele versiuni de Java
Swing – face parte din Java Foundation Classes (apare cu Java 2) și
introduce noi componente în vederea dezvoltării de interfețe grafice mai
evoluate. De asemenea oferă independență de platformă.
Swing
 este o tehnologie API care extinde AWT-ul pentru a crește abilitățile limbajului relativ
la grafică.
Din Swing fac parte pachetele javax.swing, javax.swing.event şi altele. Multe
din clasele AWT sunt necesare şi atunci când se lucrează în Swing.

 permite schimbarea înfăţişării şi a modului de interacţiune cu aplicaţia în funcţie de
preferinţe (look and feel).
Swing permite crearea unui program Java cu o interfaţă utilizator care foloseste stilul
sistemului de operare nativ, cum ar fi Windows sau Solaris sau un stil propriu Java, care
a fost denumit Metal.
 Permite dezvoltarea de aplicaţii care să comunice cu dispozitive utilizate de către
persoanele cu dizabilităţi.
Swing
Cele mai multe dintre componentele Swing sunt numite componente ușoare
(lightweight) deoarece nu au o componentă peer, spre deosebire de componentele
AWT, numite și componente grele (heavyweight). Permite crearea de aplicaţii care
utilizează grafică la un nivel avansat. Clasele puse la dispoziţie permit crearea de

desene complexe, efectuarea de operaţii geometrice (rotiri, scalări, translaţii, etc.),
prelucrarea de imagini, tipărire, etc.
Oferă posibilitatea de a efectua operaţii drag-and-drop între aplicaţii Java şi aplicaţii
native.
 Permite dezvoltarea de aplicaţii care să poată fi configurate pentru exploatarea lor în
diverse zone ale globului, utilizând limba şi particularităţile legate de formatarea datei,
numerelor sau a monedei din zona respectivă.
Modelul delegării evenimentelor ( Swing delegation event model)
Tratarea evenimentelor în Java este bazată pe modelul delegării evenimentelor.

Elementele principale sunt:
• Clase eveniment ce încapsulează informaţia despre diferite tipuri de interacţiuni cu
utilizatorul. (Event Types: ActionEvent, KeyEvent, MouseEvent, WindowEvent etc.)

• Obiecte ce generează evenimente, informează event listeners când acestea
apar şi oferă informaţii despre ele. (Event Processors: JButton, JList etc.)
• Obiecte event listener ce sunt informate de o sursă de evenimente când apar
acestea, pentru a trece la o anumită acţiune. (Event Listeners : ActionListener,
ComponentListener, KeyListener etc.)
Dimension Classes in the java.awt

LayoutManager package
Heavyweight
Font 1
FontMetrics
Object Color Panel Applet JApplet
Graphics
Component Container Window Frame JFrame

*
Dialog JDialog
JComponent Swing Components

in the javax.swing package
Lightweight
Ierarhia de clase Swing

JCheckBoxMenuItem
JMenuItem JMenu
AbstractButton JButton JRadioButtonMenuItem
JToggleButton JCheckBox
JRadioButton
JComponent JEditorPane
JTextComponent JTextField JPasswordField
JTextArea
JLabel JList JComboBox JPanel JOptionPane JScrollBar JSlider
JTabbedPane JSplitPane JLayeredPane JSeparator JScrollPane JRootPane
JToolBar JMenuBar JPopupMenu JFileChooser JColorChooser JToolTip
JTree JTable JTableHeader JInternalFrame JProgressBar JSpinner
Componentele Swing
 Convenție: pentru componentele Swing numele claselor încep cu litera J
urmată de numele folosit pentru clasa AWT. AWT Swing

AWT: Frame, Button, Applet, Label, Menu etc. Button JButton
Swing: JFrame, JButton, JApplet, JLabel, JMenu etc.
 Aplicațiile GUI vor avea nevoie de pachetul java.awt deoarece aici sunt
definite unele clase folosite pentru desenare, cum ar fi: Color, Font,
Dimension etc.
Poziționarea componentelor este preluată din AWT, dar sunt adăugate noi
clase: BoxLayout, SpringLayout.
 în realizarea unei interfețe grafice Swing se poate folosi limbajul HTML
pentru formatarea textului:
JButton simplu = new JButton("Text simplu");
JButton html = new Jbutton("<html><u>Text</u> <i>formatat</i></html>");
Realizarea unei interfețe grafice simple:
1) Crearea unui cadru

JFrame frame = new JFrame( );
2) Crearea unui element grafic (buton, casetă de text etc.)
JButton buton = new Jbutton(“Apasa-ma”);
3) adăugarea elementului grafic în cadru – elementele de interfață nu sunt adăugate
direct în cadru, ci în panoul de conținut al ferestrei:

frame.getContentPane( ).add(buton);
4) afișarea cadrului
frame.setVisible(true);
Observație. Începând cu versiunea Java 5, modul de adăugare a componentelor într-un

obiect JFrame s-a modificat. Astfel, este permisă adăugarea componentelor direct în
cadru, dar pentru compatibilitate este acceptată și forma cu getContentPane( ).
În documentația Java
http://download.oracle.com/javase/1.5.0/docs/relnotes/features.html
este anunțată această modificare astfel: “În sfârșit, după șapte ani, am făcut ca
jFrame.add() să fie echivalentă cu jFrame.getContentPane( ).add( ) ”
Prima interfață grafică Swing: un buton într-un cadru
import javax.swing.*;
public class GuiSimpla {
JFrame frame = new JFrame("Fereastra" );
JButton buton = new JButton("apasa-ma");
//urmatoarea linie determina iesirea din program imediat dupa inchiderea ferestrei
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(buton);
frame.setSize(300,300);
}
}
2. Clasa JFrame
Pentru a fi afisate pe ecran, componentele grafice ale unei aplicatii care foloseste o
interfaţă Swing, trebuie plasate pe o suprafaţă de afişare, numită “container rădăcină”.

“Containerul rădăcină” este reprezentat de una din clasele JFrame, JDialog sau JApplet.
 o fereastră este o zonă dreptunghiulară cu o bară pentru titlu așezată în partea
superioară a ferestrei. Bara de titlu conține și butoane pentru închiderea, maximizarea sau
minimizarea ferestrei. Fereastra conține de asemnea o zonă rezervată barei de meniuri și
sub aceasta este panoul de conținut al ferestrei. Dacă bara de meniuri nu este adăugată
atunci panoul de conținut este extins până sus.
2. Clasa JFrame
2. Clasa JFrame
 Spre deosebire de Frame, un obiect JFrame are un comportament implicit la
închiderea ferestrei care constă în ascunderea ferestrei atunci când utilizatorul apasă
butonul de închidere. Astfel, se poate apela metoda:
public void setDefaultCloseOperation(int operation)
unde operation poate fi una din constantele:

DO_NOTHING_ON_CLOSE – definită în clasa WindowConstants, nu se întâmplă nimic,
ci numai solicită programului să trateze, în metoda windowClosing( ), evenimentele
interceptate cu un obiect de tip WindowListener.
HIDE_ON_CLOSE – definită în clasa WindowConstants, ascunde automat fereastra
după invocarea și interceptarea unui obiect de tip WindowListener.
DISPOSE_ON_CLOSE- definită în clasa WindowConstants, ascunde și distruge automat
fereastra după invocarea și interceptarea unui obiect de tip WindowListener.
EXIT_ON_CLOSE- definită în clasa JFrame, termină aplicația folosind metoda
System.exit( ).
2. Clasa JFrame
Ferestre interne
 Swing oferă funcționalitate MDI (Multiple Document Interface) prin ferestre interne,
prin clasa JInternalFrame
 clasa JinternalFrame pune la dispoziție o modalitate de a crea ferestre în cadrul altor
ferestre
 obiectele JInternalFrame pot fi plasate pe un container de tip JDesktopPane, care
va fi apoi plasat pe o fereastră de tip JFrame.
Exemplu: ferestre interne
2. Clasa JFrame
import javax . swing .*; public class Test {
import java . awt .*; public static void main(String[] args)
class FereastraPrincipala extends JFrame { {

public FereastraPrincipala ( String titlu ) { FereastraPrincipala fp = new
super ( titlu ); FereastraPrincipala("Test ferestre
setSize (300 , 200) ; interne");
setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE fp.setVisible(true);
); }
FereastraInterna fin1 = new FereastraInterna (); }
fin1 . setVisible ( true );
FereastraInterna fin2 = new FereastraInterna ();

fin2 . setVisible ( true );
JDesktopPane desktop = new JDesktopPane ();
desktop .add( fin1 );
desktop .add( fin2 );
setContentPane ( desktop );
fin2 . moveToFront ();
}
}
class FereastraInterna extends JInternalFrame {
static int n = 0; // nr. de ferestre interne
static final int x = 30, y = 30;
public FereastraInterna () {
super (" Fereastra " + (++ n),
true , // resizable
true , // closable
true , // maximizable
true );// iconifiable
setLocation (x*n, y*n);
setSize ( new Dimension (200 , 100) );
}
}
3. Clasa JComponent
java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
 este superclasa tuturor componentelor Swing

 deoarece extinde clasa Container, deci și Component, ea moștenește funcționalitatea
generală a containerelor și componentelor AWT, furnizând o serie de noi facilități, cum ar fi:
ToolTips
-Folosind metoda public void setToolTipText(String text) se poate atașa unei componente un
text cu explicații legate de componenta respectivă.
-Când utilizatorul survolează cu mouse-ul deasupra componentei va fi afișat textul
specificat.
3. Clasa JComponent
Chenare
- Orice componentă Swing poate avea unul sau mai multe chenare. Specificarea
unui chenar se realizează cu metoda public void setBorder(Border border).
Suport pentru plasare și dimensionare

-Folosind metodele:
public void setPreferredSize(Dimension ps),
public void setMinimumSize( Dimension ms),
public void setMaximumSize ( Dimension ms),
public void setAlignmentX(float align),
public void setAlignmentY (float align)
pot fi controlați parametrii folosiți de gestionarii de poziționare pentru plasarea și
dimensionarea automată a componentelor în cadrul unui container.
3. Clasa JComponent
Controlul opacității
-Folosind metoda public void setOpaque(boolean isOpaque) se specifică dacă o

componentă trebuie sau nu să deseneze toți pixelii din interiorul său. Implicit, valoarea
proprietății de opacitate este false, ceea ce înseamnă că este posibil să nu fie desenați
unii sau chiar toți pixelii, permițând pixelilor de sub componentă să rămână vizibili
(componenta nu este opacă). Valoarea proprietății pentru clasele derivate din
JComponent depinde în general de Look-and-Feel-ul folosit.
Double-Buffering
Tehnica de double-buffering, care implică desenarea componentei în memorie și apoi
transferul întregului desen pe ecran, este implementată automat de componentele
Swing, spre deosebire de cele AWT unde trebuia realizată manual dacă era cazul.
4. Clasa JLabel
import javax . swing .*; public class TestJLabel {

import java . awt. event .*; Ex1 f = new Ex1 ();
class Ex1 extends JFrame { f.setSize(200,200);
private JLabel label1, label2, label3; f.setVisible (true);
}
public Ex1 ( ) {
}
super ("Testare JLabel" );
Container c = getContentPane();
c.setLayout( new FlowLayout() );
label1 = new JLabel( "Label with text" );
label1.setToolTipText( "This is label1" );
c.add( label1 );
Icon bug = new ImageIcon( "D:\\big_smile.gif" );
label2 = new JLabel( "Label with text and
icon",bug, SwingConstants.LEFT );
label2.setToolTipText( "This is label2" );
c.add( label2 );
}
}
5. Clasa ImageIcon
Clasa ImageIcon este o clasă derivată din clasa Object și implementează
interfața Icon.
 constructori mai utilizați ai clasei ImageIcon sunt:
ImageIcon(String filename) – încarcă o imagine (.gif sau .jpeg) din fișierul
specificat
ImageIcon(URL location) – încarcă o imagine de la locația URL specificată
Exemplu:
Icon bug = new ImageIcon( "D:\\big_smile.gif" );
 se poate afișa o imagine icoană prin apelarea metodei:
public void setIcon(Icon ic)
 următoarea metodă returnează icoana curentă:
public Icon getIcon( )
 Componentele Swing pentru afișarea și editarea textelor sunt grupate într-o
ierarhie ce are ca rădăcină clasa JTextComponent din pachetul javax.swing.text.

 Text simplu pe o singură linie
JTextField - Permite editarea unui text simplu, pe o singură linie.

JPasswordField - Permite editarea de parole. Textul acestora va fi ascuns, în
locul caracterelor introduse fiind afi¸sat un caracter simbolic, cum ar fi ’*’.

JFormattedTextField - Permite introducerea unui text care să respecte un
anumit format, fiind foarte utilă pentru citirea de numere, date calendaristice,
etc. Este folosită împreună cu clase utilitare pentru formatarea textelor, cum ar fi
NumberFormatter, DateFormatter, MaskFormatter, etc. Valoarea
conținută de o astfel de componentă va fi obținută/setată cu metodele
getValue, respectiv setValue şi nu cu cele uzuale getText, setText.
 Text simplu pe mai multe linii
JTextArea - Permite editarea unui text simplu, pe mai multe linii. Orice atribut
legat de stil, cum ar fi culoarea sau fontul, se aplică întregului text și nu poate fi
specificat doar unei anumite porțiuni. Uzual, o componentă de acest tip va fi

inclusă într-un container JScrollPane, pentru a permite navigarea pe verticală
si orizontală dacă textul introdus nu încape în suprafața alocată obiectului. Acest
lucru este valabil pentru toate componentele Swing pentru care are sens
noțiunea de navigare pe orizontală sau verticală, nici una neoferind suport
intrinsec pentru această operațiune.
Text cu stil îmbogățit pe mai multe linii
JEditorPane - Permite afișarea și editarea de texte scrise cu stiluri multiple și

care pot include imagini sau chiar diverse alet componente. Implicit,
următoarele tipuri de texte sunt recunoscute: text/plain, text/html și text/rtf.

Una din utilizările cele mai simple ale acestei clase este setarea documentului ce
va fi afișat cu metoda setPage, ce primește ca argument un URL care poate
referi un fișier text, HTML sau RTF.
JTextPane - Această clasă extinde JEditorPane, oferind diverse facilități
suplimentare pentru lucrul cu stiluri și paragrafe.
7. Clasa JTextField
 Este o clasă derivată din clasa JTextComponent
 Permite editarea unei singure linii de text

 Constructori:
JTextField( int col) – crează o rubrică de text cu un număr specificate de coloane
JTextField(String text) – crează o rubrică de text inițializată cu șirul specificat

Exemplu:
JTextField field = new JTextField(“Numele tau”);
 Folosirea componentei:
1) obținerea textului din rubrica de text
System.out.println(field.getText( ));
2) înlocuirea textului din rubrica de text
field.setText(“altceva”);
field.setText(“”); //șterge conținutul rubricii de text
7. Clasa JTextField
3) obținerea unui eveniment de tip ActionEvent atunci când utilizatorul apasă tasta Enter
field.addActionListener(myActionListener);
4) Selectarea sau deselectarea textului din rubrică
field.selectAll( );
5) mutarea cursorului în rubrica de text ( astfel încât utilizatorul poate începe să scrie)
field.requestFocus( );
8. Clasa JTextArea
 Este o clasă derivată din clasa JTextComponent
 Spre deosebire de JTextField, componenta JTextArea poate conține mai multe linii de
text
 Un obiect JTextArea nu include implicit bare de derulare și nu face automat trecerea
textului pe linie nouă

 Pentru obținerea unui obiect JTextArea cu derulare, trebuie să-l includem într-un obiect
ScrollPane.
 Constructori:
public JTextArea(int rows, int columns) – crează o casetă de text cu un număr specificat de
linii și coloane.
public JTextArea(String text, int l, int c) - crează o casetă de text cu text și număr de linii și
coloane specificate.
8. Clasa JTextArea
 Folosire componentă:
1) Adaugarea barei de derulare verticală:

//crearea unui obiect JScrollPane și transmiterea casetei de text pentru care va face
derularea
JScrollPane scroll = new JScrollPane(text);

//activarea trecerii automate a textului pe linie nouă
Text.setLineWrap(true);
//folosirea doar a barei de derulare verticală
scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
scroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
//adăugarea panoului de derulare în panou
2) înlocuirea textulului din caseta de text

text.setText(“Acesta este un text”);
8. Clasa JTextArea
3) Adăugarea unui text la ceea ce există deja în caseta de text
text.append(“alt text”);
4) Selectarea sau deselectarea textul din caseta de text

text.selectAll( );
5) mutarea cursorului în caseta de text (astfel încât utilizatorul poate începe să scrie)
text.requestFocus( );
8. Clasa JTextArea
Exemplu:
import javax.swing.*;
import java.awt.*;
public class TextArea1 implements ActionListener {
JTextArea text;

TextArea1 gui = new TextArea1( );
gui.go( );
}
8. Clasa JTextArea
public void go( ) {
JFrame fereastra = new JFrame("JTextArea" );
JPanel panou = new JPanel( );

JButton buton = new JButton("apasa-ma");
buton.addActionListener(this);
text = new JTextArea(10,20);
text.setLineWrap(true);
JScrollPane scroll = new JScrollPane(text);

panou.add(scroll);
fereastra.add(BorderLayout.CENTER, panou);
fereastra.add(BorderLayout.SOUTH, buton);
fereastra.setSize(350,300);
fereastra.setVisible(true);
}
public void actionPerformed(ActionEvent ev) {

text.append("buton apasat \n");
}
}
9. Clasa JList
 este o clasă derivată din clasa JComponent.

 Descrie o listă de elemente dispuse pe una sau mai multe coloane, din care
utilizatorul poate selecta unul sau mai multe elemente.
 Un obiect de tip JList va fi inclus într-un container de tip JScrollPane.

 Constructori mai utilizaţi:
public JList (Vector listData) – crează o listă cu elementele specificate în vector
public JList (ListModel dataModel) – crează o listă cu elementele specificate în
model ( un obiect dintr-o clasă care implementează interfața ListModel)
9. Clasa JList
Exemplu:
String[ ] lista = {“alpha”, “beta”, “gama”, “delta”, “epsilon”, “zeta”, “eta”);

JList list = new JList(lista);
Folosirea componentei JList:
1) Adaugi o bară de derulare verticală

//creezi un obiect JScrollPane și îi transmiți lista
JScrollPane scroll = new JScrollPane(list);
//adaugi bara de derulare în panou
panel.add(scroll);
2) stabilești numărul de linii care vor fi afișate înainte de derulare
list.setVisibleRowCount(4);
9. Clasa JList
3) restricționezi posibilitățile de selecție ale utilizatorului la un singur articol din listă
list. setSelectionMode(ListSelectioModel.SINGLE_SELECTION);
// alte opțiuni: SINGLE_INTERVAL_SELECTION, MULTIPLE_INTERVAL_SELECTION
4) urmărești un eveniment generat prin selectarea unui articol din listă
list.addListSelectionListener(this);
5) Tratezi evenimentele (și afli ce articol a fost selectat din listă)
//metoda valueChanged este apelată ori de câte ori va fi schimbată selecția elementelor din
listă
public void valueChanged(ListSelectionEvent ev) {
if (!ev.getValueIsAdjusting( ) ) {
String selection = (String) list. getSelectedValue( );
System.out.println(selection);
}
}
10. Clasa JTable
 Este o clasă derivată din clasa JComponent
 Permite crearea de componente care să afișeze o serie de elemente într-un format

tabelar, articolele fiind dispuse pe linii și coloane
 Un tabel poate fi folosi doar pentru afișarea formatată a unor date, dar este posibilă și
editarea informației din celulele sale

 Constructori:
public JTable (Vector rowData, Vector colData) – crează un tabel cu elementele specificate
sub forma unei matrici
public JTable (int nrRows, int nrCol) – crează un tabel cu un număr de linii și coloane
specificat
Exemplu:
String [ ] coloane = {“Nume”, “Varsta”, “Student”}
Object [ ] [ ] elemente = {
{ “Ionescu”, new Integer(20), Boolean.TRUE|}, { “Popescu”, new Integer(80), Boolean.FALSE} };
JTable tabel = new Jtable(elemente, coloane);
Exemple de componente Swing

 un program Java care are interfață grafică cu utilizatorul trebuie să
deseneze pe ecran toate componentele sale care au o reprezentare vizuală.

 unei componente grafice îi este asociat un context grafic, un obiect de tipul
Graphics, care permite apelul unor metode de desenare.
 metodele care controlează procesul de desenare se găsesc în clasa

Component și sunt următoarele:
public void paint (Graphics g)
- desenează o componentă.
- este supradefinită de fiecare componentă pentru a furniza reprezentarea
grafică specifică.
- este apelată de fiecare dată când conținutul componentei trebuie desenat sau
redesenat și nu va fi apelată explicit.
public void update (Graphics g)
- actualizează starea grafică a unei componente

- acțiunea acestei metode se realizează în trei pași:
1) Șterge componenta prin supradesenarea ei cu culoarea fundalului.
2) stabilește culoarea componentei.

3) Apelează metoda paint( ) pentru a redesena componenta.
public void repaint ( )

- Execută explicit un apel al metodei update pentru a actualiza reprezentarea
grafică a unei componente.
Clasa Canvas
 este o clasă generică din care se derivează sublcase pentru crearea

suprafețelor de desenare (planșe).
 este o clasă derivată din clasa Component.

 planșele nu pot conține alte componente grafice, ele sunt utilizate doar ca
suprafețe de desenat sau ca fundal pentru animație.
 desenarea pe o planșă se face prin supradefinirea metodei paint a acesteia.
 o planșă este o suprafață dreptunghiulară de culoare albă pe care se poate
desena.
dimensiunile implicite ale unei planșe sunt 0, de aceea se recomandă
redefinirea metodei getPrefferedSize( ), eventual getMinimumSize( ),
getMaximumSize( ).

import java.awt.*;
public class PaintDemo {

Frame f = new Frame("Have a nice day!");
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {

System.exit(0);
}
});
f.add(new SmileyCanvas(Color.yellow),
BorderLayout.CENTER);
f.pack();
f.setVisible(true);
}
}
import java.awt.Canvas; public void paint(Graphics g) {
import java.awt.Color; Dimension size = getSize();
import java.awt.Dimension; int d = Math.min(size.width, size.height);

import java.awt.Graphics; int ed = d/20;
class SmileyCanvas extends Canvas { int x = (size.width - d)/2;
int y = (size.height - d)/2;
public SmileyCanvas(Color faceColor)
{ //deseneaza capul
setForeground(faceColor); g.fillOval(x, y, d, d);
} g.setColor(Color.black);
g.drawOval(x, y, d, d);
public Dimension getPreferredSize( ) { // deseneaza ochii
return new Dimension(300,300); g.fillOval(x+d/3-(ed/2), y+d/3-(ed/2), ed, ed);
} g.fillOval(x+(2*(d/3))-(ed/2), y+d/3-(ed/2), ed, ed);
//deseneaza gura
g.drawArc(x+d/4, y+2*(d/5), d/2, d/3, 0, -180);
}
}
12. Clasa Graphics
 este clasa de bază abstractă a tuturor contextelor grafice care permit desenarea pe
suprafața componentelor grafice realizate pe diverse dispozitive fizice ( ecran, imprimantă,

plotter etc.)
Un context grafic este specificat prin intermediul unui obiect de tip Graphics primit ca
parametru în metodele paint și update.

Un obiect din clasa Graphics încapsulează informația de stare a contextului grafic la care
se referă și anume:
- obiectul din clasa Component (sau dintr-o subclasă a acesteia) pe care se desenează;
- o translație a originii sistemului de coordonate; toate coordonatele din desen sunt
raportate la această origine;
- decupajul curent (dreptunghiul in interiorul caruia se trasează desenul);
- culoarea curentă;
- fontul curent;
12. Clasa Graphics
Metode ale clasei Graphics:
public abstract Graphics create( ) - crează și returnează un nou obiect din clasa
Graphics, care este o copie a obiectului pentru care se aplică această metodă;
public abstract Graphics create(int x, int y, int width, int height) - crează si returnează o
copie a obiectului din clasa Graphics căruia i se aplică, însă cu o nouă translație a originii
(x,y) si cu valori noi ale lățimii și înăltimii dreptungiului de desenare (suprafetei de
decupare);
public abstract void translate(int x, int y) - translatează originea sistemului de
coordonate in punctul (x,y) al sistemului de coordonate curent;
public abstract Color getColor() – returnează culoarea de desenare curenta;
public abstract void setColor(Color c) - seteaza culoarea de desenare curenta;
public abstract Font getFont() - returnează fontul curent;
public abstract void setFont(Font f) - setează fontul curent;
12. Clasa Graphics
public abstract FontMetrics getFontMetrics() - returnează metrica fontului curent;
public abstract void setFontMetrics(FontMetrics fm) - seteaza metrica fontului curent;

public abstract Rectangle getClipBounds() - returnează dreptunghiul de decupare curent;
public abstract void setClip(int x, int y, int width, int height) - seteaza dreptunghiul de
decupare curent;
public abstract void copyArea(int x, int y, int width, int height, int dx, int dy) - copiaza
suprafata dreptunghiulara cu originea (x,y), latimea width si inaltimea height intr-o noua
zona de aceleasi dimensiuni, avand originea (x+dx, y+dy)..
public abstract void setPaintMode() - seteaza operatia logica pe pixeli curenta la modul
paint, adica desenarea se face peste fondul existent, folosinduse culoarea de desenare
curenta, fara a lua in consideratie culoarea fondului.
12. Clasa Graphics
public abstract void setXORMode(color c1) - setează operatiile pe pixeli la modul XOR,
adica se alterneaza pixelii de culoare curenta cu cei din culoarea c1; aceasta inseamna
ca daca un pixel nou plasat are aceeasi culoare curenta cu cea existenta anterior in
acelasi loc, ea va fi inlocuita cu c1; invers, daca pixelul existent anterior avea culoarea
c1, ea va fi inlocuita cu culoarea curenta.

public abstract void drawLine(int x1, int y1, int x2, int y2) - se trasează o linie dreapta
din punctul de coordonate (x1,y1) pana in punctul (x2,y2);
public abstract void drawRect(int x, int y, int width, int height) - se trasează un
dreptunghi cu coltul din stanga sus in punctul (x,y), avand latimea width si inaltimea
height;
public abstract void fillRect(int x, int y, int width, int height) - umple cu culoarea curenta
interiorul dreptunghiului cu coltul din dreapta sus in punctul (x,y) si cu dimensiunile
(width, height);
12. Clasa Graphics
public abstract void clearRect(int x, int y, int width, int height)
- sterge continutul dreptunghiului de coordonate si dimensiuni specificate, umplandu-l

cu culoarea de fond;
public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int
arcHeight)
- traseaza un dreptunghi cu colturile rotunjite, unde arcWidth si arcHeight sunt
respectiv diametrul orizontal si diametrul vertical al arcelor de rotunjire;
public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int
arcHeight)
- umple cu culoarea curenta interiorul unui dreptunghi cu colturile rotunjite;
public abstract void draw3DRect(int x, int y, int width, int height, boolean raised)
- deseneaza un dreptunghi astfel luminat, incat el apare ca iese din suprafata de baza,
daca raised=true, sau este scufundat in aceasta suprafata, daca raised=false;
12. Clasa Graphics
public abstract void fill3dRect(int x, int y, int width, int height, boolean raised)
- umple cu culoarea curenta interiorul unui dreptunghi tridimensional, luind in consideratie si

iluminarea;
public abstract void drawOval(int x, int y, int width, int height)
-se deseneaza ovalul inscris in dreptunghiul cu coltul din stanga sus in punctul (x,y) si cu
dimensiunile (width, height);
public abstract void fillOval(int x, int y, int width, int height)
-- se umple cu culoarea curenta continutul ovalului inscris in dreptunghiul cu coltul stanga
sus in punctul (x,y) si de dimensiuni (width, height);
public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
- se deseneaza un arc circular sau eliptic, care acopera dreptunghiul specificat. Putem sa ne
imaginam ca din elipsa inscrisa in acest dreptunghi si avand centrul in centrul dreptunghiului,
se traseaza efectiv numai arcul care incepe de la unghiul startAngle si se extinde pe un unghi
egal cu arcAngle. Unghiurile sunt masurate in grade.
12. Clasa Graphics
public abstract void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) - traseaza o
linie franta, care trece prin punctele ale caror coordonate (x,y) sunt date in tabelele
xPoints si yPoints; numarul de puncte este nPoints;
public abstract void drawPoligon(int[] xPoints, int[] yPoints, int nPoints) - traseaza un
poligon cu nPoints varfuri, situate in punctele ale caror coordonate (x,y) sunt date in
tabelele xPoints si yPoints;
public abstract void drawPoligon(Poligon p) - traseaza poligonul specificat ca argument;
public abstract void fillPoligon(int[] xPoints, int[] yPoints, int nPoints) - umple cu
culoarea curenta un poligon cu nPoints varfuri, situate in punctele ale caror coordonate
(x,y) sunt date in tabelele xPoints si yPoints;
public abstract void fillPoligon(Poligon p) - umple cu culoarea curenta poligonul
specificat ca argument;
12. Clasa Graphics
public abstract void drawString(String str, int x, int y)
-traseaza sirul de caractere str, folosind fontul si culoarea curente; baza primului caracter
al sirului este in punctul de coordonate (x,y);
public abstract void drawString(AttributedCharacterIterator iterator, int x, int y)
-traseaza un sir de caractere continute in obiectul iterator, care specifica nu numai

caracterele propriuzise ci si fontul fiecarui caracter; baza primului caracter este in
punctul de coordonate (x,y);
public abstract void drawChars( char[] data, int offset, int length, int x, int y)
- traseaza length caractere din tabloul data, incepand cu caracterul cu indicele offset;
baza primului caracter se gaseste in punctul de coordonate (x,y); fontul si culoarea sunt
cele curente;
13. Clasa Font
 este o clasă derivată din clasa Object
 un obiect Font încapsulează informații despre toți parametrii unui font, mai puțin
despre metrica acestuia.
 parametrii ce caracterizează un font sunt:
- Numele fontului: Arial Bold Italic, Helvetica Bold, Times New Roman etc
- familia din care face parte fontul: Arial, Helvetica, Times New Roman etc
- dimensiunea fontului: înălțimea sa
- stilul fontului: normal, îngroșat, înclinat ( specificat prin constantele: Font.PLAIN,
Font.BOLD, Font.ITALIC)
- metrica fontului
 constructorul clasei are trei parametri: numele fontului, dimensiune și stilul acestuia:
public Font( String name, int style, int size)
 lista fonturilor instalate pe o platformă de lucru se poate obține astfel:
Font [ ] fonturi = GraphicsEnvironment.getLocalGraphicsEnvironment( ).getAllFonts( );
13. Clasa Font
 Metode ale clasei Font:
public String getFontName() - intoarce numele fontului;

public int getStyle() - intoarce stilul PLAIN, BOLD, ITALIC sau BOLD+ITALIC;
public int getSize() - intoarce marimea fontului;
public boolean isPlain() - intoarce true daca stilul este normal;

public boolean isBold() - intoarce true daca stilul este bold (aldin);
public boolean isItalic() - intoarce true daca stilul este italic (inclinat);
public Font deriveFont(int style, float size) - creaza un nou font, similar cu cel existent, dar
cu stilul si marimea date ca argumente;
public Font deriveFont(float size) - creaza un nou font, similar cu cel existent, dar de alta
marime;
public Font deriveFont(int style) - creaza un nou font, similar cu cel existent, dar de alt stil;
public boolean canDisplay(char c) - intoarce true daca acest font contine caracterul c (il
poate afisa).
13. Clasa Font
Clasa FontMetrics
Un obiect din clasa FontMetrics se construieste pornind de la un obiect de

tip Font si pune la dispozitie informatii despre dimensiunile în pixeli pe care
le au caracterele fontului respectiv.

 un obiect de tip FontMetrics încapsuleaza informatii despre metrica unui
font, cu alte cuvinte despre dimensiunile în pixeli ale caracterelor sale.
 Utilitatea principală a acestei clase constă în faptul că permite pozitionarea
precisa a textelor pe o suprafata de desenare, indiferent de fontul folosit de
acestea.
13. Clasa Font
Metrica unui font consta în urmatoarele atribute pe care le au caracterele
unui font:
- linia de baza : este linia dupa care sunt aliniate caracterele unui font
-linia de ascendenta : linia superioara pe care nu o depaseste nici un caracter
din font
-linia de descendenta : linia inferioara sub care nu coboara nici un caracter
din font
- ascendentul: distanta între linia de baza si linia de ascendenta
- descendentul:distanta între linia de baza si linia de descendenta latimea:
-latimea unui anumit caracter din font înaltimea: distanta între liniile de baza
- distanta între linii ("leading"):distanta optima între doua linii de text scrise
cu acelasi font.
13. Clasa Font
Cele mai uzuale metode ale clasei FontMetrics sunt cele pentru:
public int getHeight( ) – pentru aflarea înaltimii unei linii pe care vor fi scrise caractere
ale unui font:,

public int stringWidth (String str) - aflarea latimii totale în pixeli a unui sir de caractere
specificat:
public int charWidth (char ch) - aflarea latimii unui anumit caracter din font:
14. Clasa Color
 clasa Color încapsulează informațiile despre culoare
 In Java se foloseste modelul de culori RGB (engleza: red, green, blue) in care fiecare
culoare este considerata ca fiind compusa din trei culori fundamentale: rosu, verde si
albastru.
 culoarea este data prin trei numere cuprinse in intervalul [0, 255], reprezentand
ponderile celor trei culori fundamentale.
Color constant Color RGB value

public final static Color RED red 255, 0, 0
public final static Color GREEN green 0, 255, 0
public final static Color BLUE blue 0, 0, 255
public final static Color ORANGE orange 255, 200, 0
public final static Color PINK pink 255, 175, 175
public final static Color CYAN cyan 0, 255, 255
public final static Color MAGENTA magenta 255, 0, 255
public final static Color YELLOW yellow 255, 255, 0
public final static Color BLACK black 0, 0, 0
public final static Color WHITE white 255, 255, 255
public final static Color GRAY gray 128, 128, 128
public final static Color LIGHT_GRAY light gray 192, 192, 192
public final static Color DARK_GRAY dark gray 64, 64, 64
14. Clasa Color
 constructorii clasei Color sunt:
Color(float red, flot green, float blue)

Color(flot red, float green, float blue, float alpha)
Color(int red, int green, int blue)
Color(int red, int green, int blue, int alpha)

Color(int rgb)
unde red, green, blue, alpha sunt valorile pentru ro¸su, verde, albastru și transparență,
iar parametrul ”rgb” de la ultimul constructor reprezintă un întreg format din: biții 24-31
alpha, 16-23 roșu, 8-15 verde, 0-7 albastru.
 Valorile argumentelor variază între 0 − 255 pentru tipul int, respectiv 0.0 − 1.0 pentru
tipul float.
 Daca alpha=255, culoarea este complet opacă. Aceasta inseamna ca daca o figura cu
aceasta culoare se suprapune peste alta, o mascheaza complet. Daca alpha=0, culoarea
este complet transparenta, deci practic invizibila.
14. Clasa Color
Metodele cel mai frecvent utilizate:
public int getRed() - intoarce ponderea culorii red (rosu);

public int getGreen() - intoarce ponderea culorii green (verde);
public int getBlue() - intoarce ponderea culorii blue (albastru);
public int getAlpha() - intoarce componenta alpha (opacitatea culorii);
public Color brighter() - creaza o versiune mai luminoasa a acestei culori;

public Color darker() - creaza o versiune mai intunecata a acestei culori;
Exemplu:
14. Clasa Color
import java.awt.*; g.setColor( Color.blue );
g.fillRect( 25, 75, 100, 20 );

import java.awt.event.*; g.drawString( "RGB curent: " + g.getColor(),
public class ShowColors extends Frame { 130, 90 );
public ShowColors() { Color c = Color.magenta;
super( "Culori" ); g.setColor( c );
setSize( 400, 130 ); g.fillRect( 25, 100, 100, 20 );
setVisible(true); g.drawString( "valori RGB : " + c.getRed() + ", "

} + c.getGreen() + ", " + c.getBlue(), 130, 115 );
public void paint( Graphics g ) {
g.setColor( new Color( 255, 0, 0 ) ); }
g.fillRect( 25, 25, 100, 20 ); public static void main( String args[] ) {
g.drawString( "RGB curent: " + g.getColor(), ShowColors app = new ShowColors();
130, 40 ); app.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent e )
g.setColor( new Color( 0.0f, 1.0f, 0.0f ) ); {
g.fillRect( 25, 50, 100, 20 ); System.exit( 0 );
g.drawString( "RGB curent: " + g.getColor(), }
130, 65 ); }
);
}
 se bazează pe modelul AWT, metoda cea mai importantă fiind paint( ) , apelată
automat ori de câte ori este necesar.

Pentru componentele Swing, această metodă are însă o implementare specifică și nu
trebuie supradefinită
 Metoda paintComponent
protected void paintComponent(Graphics g)
-este principala metodă pentru desenare ce este supradefinită pentru fiecare componentă
Swing în parte pentru a descrie reprezentarea sa grafică
-Argumentul metodei este un obiect de tip Graphics, ceea ce înseamnă că poate să fie o
subclasă Graphics, de fapt chiar este o sublcasă.
-Argumentul este de fapt de tip Graphics2D, clasă ce extinde Graphics și pune la dispoziție
metode mai evoluate de desenare numite Java2D.
 Dacă se dorește folosirea unei metode din clasa Graphics2D, nu se poate
folosi parametrul g al metodei paintComponent( ), așa cum a fost furnizat. Dar

se poate face o conversie către o nouă variabilă de tip Graphics2D
Graphics2D g2s = (Graphics2D) g;
 Metode ce pot fi apelate pentru o referință Graphics2D

public void fill3DRect(int x, int y, int width, int height, boolean raised)
public draw3DRect(int x, int y, int width, int height, boolean raised)
public abstract void translate (double tx, double ty)
public abstract void rotate (double theta)
alte metode:
public abstract void fillRoundRect (int x, int y, int width, int height, int arcWidth,
int arcHeight)
public abstract void drawRoundRect (int x, int y, int width, int height, int arcWidth,
int arcHeight)
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Desen extends JPanel {
public void paint(Graphics g) {

g.setColor (Color.green);
g.draw3DRect (25, 10, 50, 75, true);
g.draw3DRect (25, 110, 50, 75, false);
g.fill3DRect (100, 10, 50, 75, true);
g.fill3DRect (100, 110, 50, 75, false);
g.setColor (Color.MAGENTA);
g.fillRoundRect (195, 40, 90, 55, 50, 50);
g.drawRoundRect (290, 40, 90, 55, 20, 20);
}
JFrame frame = new JFrame("Dreptunghiuri");
frame.add(new Desen());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);
}
}
16. Look and Feel
 reprezintă modul în care sunt desenate componentele Swing şi felul în care
acestea interacţionează cu utilizatorul.

 Acelaşi program poate utiliza diverse moduri Look-and-Feel, cum ar fi cele
standard Windows, Mac, Java, Motif sau altele oferite de diverşi dezvoltatori.
• javax.swing.plaf.metal.MetalLookAndFeel
Varianta implicită de L&F şi are un aspect specific Java.

• com.sun.java.swing.plaf.windows.WindowsLookAndFeel
Varianta specifică sistemelor de operare Windows. Incepând cu versiunea 1.4.2
există şi implementarea pentru Windows XP .
• com.sun.java.swing.plaf.mac.MacLookAndFeel
Varianta specifică sistemelor de operare Mac.
• com.sun.java.swing.plaf.motif.MotifLookAndFeel
Specifică interfaţa CDE/Motif.
• com.sun.java.swing.plaf.gtk.GTKLookAndFeel
GTK+ reprezintă un standard de creare a interfeţelor grafice dezvoltat
independent de limbajul Java. (GTK este acronimul de la GNU
ImageManipulation Program Toolkit).
16. Look and Feel
Windows LAF
16. Look and Feel
Motif LAF
16. Look and Feel
Java (Metal) LAF

Întrebări
1. Ce diferenţă există între AWT şi Swing?
2. Care sunt etapele ce permit crearea unei interfeţe grafice Swing?
3. Care este clasa de bază pentru toate componentele Swing?

4. Care sunt gestionarii de poziţionare?
5. Explicaţi modelul delegării evenimentelor.

Programare Java
VII. Applet-uri Java
2013
Applet-uri Java
Cuprins
1. Ce este un applet?
2. Ciclul de viață a unui applet
3. Parametrii unui applet

4. Tag-ul APPLET
5. Metode ale clasei Applet
6. Securitatea unui applet

Applet-uri Java
Java oferă două tipuri de programe: standalone ( aplicații de sine

stătătoare, independente) și applet-uri.
Un applet este un un program care se execută prin intermediul

navigatoarelor Web (Internet Explorer, Mozilla, Netscape,
Chrome etc.) sau prin intermediul interpretorului appletviewer,
oferit de Java SDK.

Applet-uri Java
Browser-ul web sau appletviewer-ul execută applet-ul atunci

când un document HTML ce conține applet-ul este deschis în
browser sau appletviewer.

 Pachetul care oferă suport pentru crearea de applet-uri este
java.applet, clasa cea mai utilizată fiind clasa Applet.
 De asemenea, în pachetul javax.swing există clasa JApplet,
care extinde clasa Applet.


Applet-uri Java
Ierarhia claselor din care derivă applet-urile:


Applet-uri Java
Ierarhia claselor din care derivă applet-urile:

Applet-uri Java
Exemplu: un applet simplu

1) Editare și salvare cod sursă
//fisierul SalutAp.java
import java.applet.*;
import java.awt.*;
public class SalutAp extends Applet

{
public void paint(Graphics g)
{
g.drawString(“Salut", 50, 25);
}
}
Applet-uri Java
2. Compilare sursă
 Se folosește comanda javac SalutAp.java , rezultând fișierul
SalutAp.class.
3. Execuția applet-ului
 crearea fișierului HTML (de ex. Salut.html)

<html>
<body>
Acesta este un applet:
<APPLET code=“SalutAp.class" WIDTH=300 HEIGHT=200 >
</APPLET>
</body>
</html>
Applet-uri Java
Vizualizarea applet-ului folosind un browser sau appletviewer

( folosind din linia de comandă appletviewer Salut.html sau din
mediul Eclipse comanda Run As -> Java Applet).

Applet-uri Java
 Container este superclasa clasei Applet, prin urmare applet-urile

sunt suprafețe de afișare.

 Gestionarul de poziționare implicit este FlowLayout.
 desenarea pe suprafața unui applet se face prin supradefinirea

metodei paint.
public void paint ( Graphics g) {

//desenare
}
init()
stop()
start()
destroy()
java.awt.Panel
java.applet.Applet
Applet-uri Java
Applet-uri Java
 init( )
- Este metoda apelată de browser imediat după crearea applet-ului, imediat

după inițializarea lui (după apelul constructorului)
- Permite inițializarea diverselor variabile, citirea unor parametri de intrare,

încărcarea unor imagini sau alte fișiere media.
- această metodă poate fi folosită pentru a crea un thread.
- este apelată la prima încărcare a paginii html care conține applet-ul.
 start( )
- Este apelată de browser imediat după metoda init( ) și ori de câte ori
utilizatorul revine în pagina html în care se află applet-ul.
- Această metodă poate fi folosită pentru pornirea unui thread.
Applet-uri Java
 stop( )
- Este apelată de browser ori de câte ori se iese din pagina web în care se
află applet-ul, iar când pagina devine din nou activă, va fi reapelată
metoda start( ).
- Poate fi utilizată pentru oprirea unui thread.
 destroy( )
- este apelată de browser înainte de a elibera resursele alocate applet-ului.

- Este apelată la închiderea browser-ului.
- apelul acestei metode este precedat de apelul metodei stop( ).
Applet-uri Java
Structura generală a unui applet este:
import java.applet.Applet;
import java.awt.*;
public class AppletStr extends Applet {

public void init ( ) {
}
public void start ( ) {
}
public void stop ( ) {
}
public void destroy ( ) {
}
}
Obs. Aceste metode sunt apelate automat de browser.
Applet-uri Java
Exemplu: lucrul cu metodele init, start, stop, destroy moștenite din clasa Applet
import java.awt.*;
public class TestInit extends Applet{
TextArea ta = new TextArea( );
Button b1 = new Button ("Buton1");

Button b2 = new Button ("Buton2");
StringBuffer buf = new StringBuffer( );
public TestInit ( ) {
System.out.println("apel constructor ");
}
public void init( ) {
setLayout (new BorderLayout( ) );
add("West", b1);
add("North", b2);
add("Center", ta);
print("metoda init()");
}
Applet-uri Java
public void start() {
print("metoda start()");
}
public void stop() {
print("metoda stop()");
}
public void destroy() {

print("metoda destroy()");
}
public void print(String s) {
System.out.println(s);
buf.append(s+"\n");
ta.setText(buf.toString());
repaint();
}
}
Applet-uri Java
 parametrii unui applet permit personalizarea aspectului sau

comportării unui applet.

 definirea parametrilor se face în cadrul tag-ului APPLET din fișierul
HTML ce conține applet-ul

 parametrii sunt identificați prin atributul PARAM.
 fiecare parametru are un nume, specificat prin NAME și o valoare,
specificată prin VALUE.
 tipul parametrilor este șir de caractere, cu sau fără ghilimele.
Applet-uri Java
< APPLET CODE=“ParamAp.class” WIDTH=200 HEIGHT=300

<PARAM NAME=“paramStr” VALUE=“Salut”>

<PARAM NAME=“paramInt” VALUE= “100”>
</APPLET>
 un applet are și parametri prestabiliți ce definesc informații
generale despre applet, de exemplu: CODE, WIDTH, HEIGHT.
 folosirea parametrilor primiți de către un applet se face cu metoda
getParameter ( ) care are ca argument numele unui parametru ți
returnează valoarea acestuia:
public String getParameter (String name)
Applet-uri Java
 folosirea parametrilor primiți de către un applet se face cu metoda

getParameter ( ) care are ca argument numele unui parametru ți

returnează valoarea acestuia:
public String getParameter (String name)
 Prin supradefinirea metodei getParameterInfo( ), un applet

pune la dispoziție informații despre parametrii pe care îi suportă,
această metodă returnează un vector format din triplete de șiruri
(numele parametrilor, tipul său și o descriere a sa)
public String[ ] [ ] getParameterInfo( )
Applet-uri Java
4. Tag-ul APPLET
 sintaxa tag-ului APPLET este următoarea:
< APPLET
[ CODEBASE = codebaseURL ]
CODE = appletFile
[ ARCHIVE = archivesList ]
[ ALT = alternateText ]
[ NAME = appletInstanceName ]
WIDTH = pixels
HEIGHT = pixels
[ ALIGN = alignment ]
[ VSPACE = pixels ]
[ HSPACE =pixels ]
>
[<PARAM NAME = appletParameter1 VALUE = value >]
[<PARAM NAME = appletParameter1 VALUE = value >]
...
[alternateHTML]
</APPLET>
 Atributele ce apar între paranteze drepte sunt opționale
Applet-uri Java
4. Tag-ul APPLET
 CODEBASE – specifică URL-ul la care se găsește clasa applet-ului.

Se exprimă relativ la directorul fișierului HTML.

 CODE – numele fișierului ce conține clasa principală a applet-ului.
 ARCHIVE – specifică arhiva în care se găsesc clasele applet-ului.

 ALT – specifică textul ce trebuie afișat dacă browser-ul înțelege
tag-ul APPLET dar nu poate rula applet-uri Java.
 NAME – se atribuie un nume applet-ului, oferind astfel posibilitatea
ca mai multe apeluri aflate pe aceeași pagină să poată comunica între
ele folosind numele lor.
 WIDTH, HEIGHT – specifică lățimea și înălțimea suprafeței în care
va fi afișat applet-ul.
Applet-uri Java
4. Tag-ul APPLET
 ALIGN – specifică modul de dispunere a applet-ului în pagina Web.

Poate primi una din valorile: left, right, top, texttop, middle,
absmiddle, baseline, bottom, absbottom.
 VSPACE, HSPACE – specifică numărul de pixeli dintre applet și

marginile suprafeței de afișare.
 PARAM – aceste tag-uri sunt folosite pentru specificarea
parametrilor applet
Applet-uri Java
public String getAppletInfo( )
–returnează un șir de caractere ce reprezintă informații despre applet, cum

ar fi numele, autorul, versiunea etc.
public URL getCodeBase( )
-returnează URL-ul directorului ce conține clasa applet-ului.

public URL getDocumentBase( )
-returnează URL-ul directorului ce conține fișierul HTML în care este inclus
applet-ul respectiv
public void showStatus (String mes)
-afișează un mesaj în bara de stare a browser-ului.
public Image getImage( URL url)
–returnează o referință la o imagine ce poate fi afișată pe ecran și are ca
argument adresa URL a fișierului ce reprezintă imaginea.
Applet-uri Java
Exemplu: afișarea unei imagini

import javax . swing . *;
public class ImagAp extends JApplet {

Image img = null ;
public void init () {
img = getImage ( getCodeBase () ,"floare.jpg");
}
public void paint ( Graphics g) {
g. drawImage (img , 0, 0, this );
}
}
Applet-uri Java
public AppletContext getAppletContext( )
–determinarea contextului de execuție, adică pagina în care applet-ul

rulează, eventual cu alte applet-uri.
-Contextul este descris de interfața AppletContext, crearea unui obiect ce
implementează această interfață se face de către browser, la apelul acestei

metode.
public void showDocument (URL url)
-afișează documentul (text, html, imagine etc.) ce are adresa URL specificată
- această metodă este apelată prin intermediul contextului de execuție
try {
URL doc = new URL("http://www.etti.tuiasi.ro");
getAppletContext().showDocument(doc);
}
catch(MalformedURLException e) {
System.err.println("URL invalid! \n" + e);}
Applet-uri Java
Exemplu: comunicarea între două applet-uri – primul applet așteaptă
introducerea unui text într-o casetă și în momentul apăsării butonului Send

trimite textul celui de-al doilea applet din pagină.
import java.awt.event.ActionListener;
import java.awt.TextField;
import java.awt.Button;
import java.awt.event.ActionEvent;
public class Applet1 extends Applet implements ActionListener

{
public TextField tf;
public Applet2 a;
public Button b;
Applet-uri Java
public Applet1()
{
}
public void init()
{
tf = new TextField( 30 );
add( tf );
b = new Button("Send");
add( b );
b.addActionListener( this );
a = (Applet2)getAppletContext().getApplet("APPLET2");
}
public void actionPerformed(ActionEvent arg0)

{
a.write( tf.getText());
}
}
Applet-uri Java
import java.awt.Graphics;
public class Applet2 extends Applet

{
private String string = null;
public Applet2()
{
}
public void paint(Graphics g)
{
if( string != null )
g.drawString(string, 10, 10 );
}
public void write(String s)
{
string = s;
repaint();
}
}
Applet-uri Java
Fișierul html:
<html>
<body>
<applet code="Applet1.class" width=400 height=200 name="APPLET1">
Acesta este primul applet.

</applet>
<applet code="Applet2.class" width=200 height=100 name="APPLET2">
Acesta este al doilea applet.
</applet>
</body>
</html>
Applet-uri Java
 deoarece un applet se execută pe mașina utilizatorului care a

accesat pagina Web ce conține applet-ul, sunt necesare măsuri de
securitate pentru a controla activitatea applet-ului.
 în acest scop, procesul care rulează applet-uri instalează un

manager de securitate (un obiect de tip SecurityManager) care va
controla metodele applet-ului, iar în cazul unei operații nepermise se
va arunca o excepție de tip SecurityException.
public class SecurityManager extends Object
Applet-uri Java
Modelul de securitate oferit de Java se bazează pe conceptul de sandbox, pentru a

impune limitele de securitate disponibile unui program. Astfel, un program java poate
rula numai în interiorul propriului sandbox, respectând limitele de securitate stabilite.
Astfel, applet-urile Java nu pot face următoarele operații:
- citirea sau scrierea de fișiere de pe mașina pe care se execută (client) fără

permisiunea utilizatorului.
- deschiderea de conexiuni cu alte mașini în afară de cea de pe care provine.
- pornirea programelor pe mașina client.
- citirea diverselor proprietăți ale sistemului de operare al clientului.
- ștergerea sau modificarea fișierelor.
-încărcarea de noi biblioteci dinamice și apelarea directă de metode native.
- introducerea unui virus sau a unui troian.
Applet-uri Java
Există tehnologii precum Java Web Start (JWS) și java Network Launch Protocol
(JNLP) care permit applet-urilor sau aplicațiilor să interacționeze cu utilizatorul prin

cererea permisiunii de a accesa diferite resurse de sistem. Astfel, cu permisiunea
utilizatorului , este permisă extinderea sandbox-ului de către programatorii Java,
dar fără a li se da acces la toate resursele locale ale utilizatorului, astfel

respectându-se conceptul de sandbox.
Java Web Start este o tehnologie pentru lansarea applet-urilor și aplicațiilor direct
de pe web.
Tehnologia JNLP defineşte un format de fişier standard care descrie modul de
lansare a unei aplicaţii, denumit fişier JNLP.
Programare Java
VII. Comunicații Java folosind

socket-uri
2013
Comunicații Java folosind socket-uri
Cuprins
1. Prezentarea pachetului java.net
2. Gestionarea adreselor Internet

3. Comunicarea prin UDP
4. Comunicarea prin TCP
5. Accesul la resurse Internet prin URL

Clasele pachetului java.net sunt destinate să realizeze

următoarele funcții:
- gestiunea adreselor Internet

- comunicarea prin UDP
- comunicarea prin TCP
- accesul la resursele Internet prin URL
 Pachetul este structurat pe un singur nivel, toate clasele
moștenesc clasa Object.

Cele mai utilizate clase sunt prezentate în figura de mai jos:


 socket (soclu) – termen abstract ce folosește combinația dintre adresa

IP și numărul de port; conexiune.
 Un socket furnizează facilități pentru crearea de fluxuri de intrare și

ieșire, care permit schimbarea de date între client și server.
 Pentru un socket, numărul de port poate fi specificat prin program sau
asignat de către sistemul de operare (pentru socket-urile client).
 Comunicațiile prin socket se fac pe baza modelului client-server
(Server - cel care oferă servicii, Client – cel care solicită servicii oferite
de server) .
 Când se folosesc socket-uri, trebuie să se stabilească tipul de protocol

ce se dorește a fi utilizat pentru transportul datelor în rețea:
- protocolul orientat pe conexiune;

- protocolul neorientat pe conexiune.
 Specificațiile de comunicații pentru serviciile standard sunt publice și
sunt disponibile pe Internet sub forma unor RFC-uri (Request For
Comments).
 Serviciile standard au asociate porturi standard de comunicare,
precum și tipurile de socket (TCP, UDP) prin care comunică.

Serviciul Port asociat Socket

Time 37 TCP
UDP
Echo 7 TCP
UDP
SMTP (Simple Mail 25 TCP
Transfer Protocol)
server e-mail
POP3 (Post Office 110 TCP
Protocol)
FTP (File Transfer 21 TCP
Protocol)
Serviciul Port asociat Socket

TFTP (Trivial File 69 UDP

Transfer Protocol)
Telnet 23 TCP
SSH (Security SH) 22 TCP

HTTP (HyperText 80 TCP
Transfer Protocol)
HTTPS (HyperText 443 TCP
Transfer Protocol Secure)
http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers
Clasa InetAddress - reprezintă descrierea unei adrese Internet și este
folosită atât pentru comunicare prin UDP cât și prin TCP.
public final class InetAddress extends Object implements Serializable

 Câteva dintre metodele clasei InetAddress sunt:
public static InetAddress getLocalHost( )
- returnează o adresă IP pentru host-ul local.
public static syncronized InetAddress getByName (String host)
- returnează o adresă IP pentru mașina indicată de host

public static synchronized InetAddress [ ] getAllByName (String host)
- returnează un tablou cu toate adresele IP care localizează host.
public String getHostName ( )

- returnează numele host-ului gazdă.
public byte [ ] getAddress ( )
- returnează adresa IP în formă binară, într-un șir de 4 octeți, primul
fiind cel mai semnificativ.

Exemplu: afișare adresă IP locală
import java.net.*;
public class adresaIPLocala {

public static void main (String args [ ]) {

InetAddress adresaIPLocala = null;
try {
adresaIPLocala = InetAddress.getLocalHost( );
System.out.println(“adresa IP locala = “ + adresaIPLocala) ;
} catch (UnknownHostException e) {
System.out.println(“ nu putem gasi gazda “ + e.toString());
}
}
}
 UDP ( User Datagram Protocol) – protocol neorientat pe conexiune.
 Comunicarea prin UDP este adesea folosită în comunicații simple, la care este
mai importantă viteza și mai rar în cazurile în care sunt importante datele ce se
transmit.
 Se trimit pachete de date, numite datagrame, de la o aplicație la alta, dar nu
este garantată ajungerea pachetelor la destinație ,iar ordinea expedierii poate
să nu fie păstrată.
Clasa DatagramPacket – conține constructori care pot fi utilizați pentru crearea
obiectelor pachet.
 pachetele trimise prin protocolul UDP sunt descrise de clasa DatagramPacket,

care gestionează structura pachetelor UDP.
 există două tipuri de constructori, după scopul utilizării pachetelor: pentru trimitere
sau pentru recepționare:
public DatagramPacket (byte [ ] buf, int length)
- constructor folosit pentru recepția unei datagrame, are ca parametri un tablou de tip
byte ce desemnează zona de memorie în care se va copia conținutul mesajului și
lungimea maximă a mesajului recepționat.

public DatagramPacket (byte [ ] buf, int length, InetAddress adress, int port)
- constructor folosit pentru crearea unui pachet datagramă pentru trimiterea
pachetelor de lungime length către portul specificat pe adresa precizată.

Mesajul ce se transmite este indicat de primul argument, buf.
 Conținutul și adresa unui obiect DatagramPacket pot fi determinate și
modificate cu metodele:
public byte [ ] getData( )
- returnează în tabloul de byte datele trimise/recepționate.
public int getLength( )
- returnează lungimea informației utile trimise/recepționate

public int getPort( )
- returnează numărul portului de la care a transmis expeditorul mesajului sau la
care a primit destinatarul.
public InetAddress getAddress( )

- întoarce un obiect de tip InetAddress care conține adresa IP a datagramei.
public void setAddress (InetAddress adr )
- stabilește adresa IP pentru datagrama curentă.
public void setData (byte [ ] buf )
- modifică conținutul mesajului.
public void setLength (int length)
- modifică lungimea mesajului.

Clasa DatagramSocket – conține diferite metode folosite pentru transmitere și
primirea de datagrame în rețea.
 Corespunde unui socket pentru datagrame, prin intermediul căruia se vor putea
primi, respectiv recepționa astfel de pachete.
 Cei mai utilizați constructori sunt:
public DatagramSocket ( )
- Creează un obiect DatagramSocket cu ajutorul căruia se pot trimite pachete pe orice
port local disponibil
public DatagramSocket (int port)
- Creează un obiect DatagramSocket care așteaptă primirea de pachete la numărul de
port specificat.
 Clasa DatagramSocket furnizează metode pentru trimiterea și primirea de
obiecte DatagramPacket, închiderea socketului, obținerea adresei locale,
setarea timpului de așteptare pentru primire etc.

void send (DatagramPacket pachet)
- Transmite pachetul specificat ca parametru, adresa și portul destinație
trebuie să fie deja trecute în pachet.
void receive (DatagramPacket pachet)
- Recepționează un pachet de la socket.

public InetAddress getLocalAddress ( )
- Returnează adresa locală la care este legat socketul.
public int getLocalPort ( )

- Returnează portul la care așteaptă socketul curent.
- Această metodă este utilă pentru socketul care trimite pachete de la un
port ales aleator de sistemul de operare local.
public void close( )
- Închide socketul eliberând astfel resursele ocupate

UDPClient.java
import java.io.*;
import java.net.*;
public class UDPClient {
public static void main(String args[]) throws Exception {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();

InetAddress IPAddress = InetAddress.getByName("127.0.0.1");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
String modifiedSentence = new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
}
UDPServer.java
import java.io.*;
import java.net.*;
class UDPServer {
public static void main(String args[]) throws Exception {
//crearea unui socket UDP la portul 9876
DatagramSocket serverSocket = new DatagramSocket(9876);

byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true){
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
//receptionarea unei datagrame
serverSocket.receive(receivePacket);
String sentence = new String(receivePacket.getData());
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
serverSocket.send(sendPacket);
}
}
}
 TCP (Transmission Control Protocol) – protocol orientat pe conexiune.
 Un socket client stabilește o conexiune cu un socket server când acesta este creat.
 Fiecare pachet trimis este primit, iar atunci când un socket trimite un pachet va
aștepta o confirmare că pachetul s-a primit cu succes, iar dacă nu primește
confirmarea într-un timp precizat, socketul retrimite pachetul.
 Pachetele sunt citite de socketul destinație în aceeași ordine în care au fost trimise.
 Un socket TCP pentru client corespunde unei instanțe a clasei Socket, iar pentru un
server, unei clase ServerSocket.
 Odată stabilită conexiunea, se pot trimite sau primi fluxuri de la aplicația de la
distanță, comunicarea realizându-se prin intermediul fluxurilor.

Clasa Socket din pachetul java.net
 Un obiect Socket corespunde unei conexiuni de rețea TCP.
 Obiectele de tip Socket sunt folosite atât la nivel de client, cât și la nivel de
server.
 Clientul deschide o conexiune către un server prin intermediul unui obiect
Socket și realizează comunicarea cu serverul prin intermediul aceluiași
obiect. Aplicația client trebuie să cunoască adresa serverului, precum și
portul acestuia.
 Cei mai utilizați constructori ai clasei Socket sunt:
public Socket ( )
- creează un obiect Socket neconectat.

public Socket (String host, int port)
- creează un obiect Socket conectat la portul indicat al adresei gazdă
specificată prin șirul de caractere host .
public Socket (InetAddress adresa, int port)
- creează un obiect Socket conectat la portul indicat și se specifică adresa IP a
serverului prin intermediul unui obiect de tip InetAddress.

 Metodele clasei Socket permit identificarea gazdei de la distanță, a portului
local și a celui de la distanță, precum și extragerea de fluxuri în vederea
comunicării bidirecționale.
 Pentru comunicarea TCP trebuie mai întâi stabilirea conexiunii (crearea
unui obiect Socket), apoi apelarea metodelor getInputStream() și
getOutputStream() pentru obținerea fluxurilor de intrare și respectiv
ieșire, cu ajutorul cărora se realizează comunicarea la distanță.
 Atât clientul cât și serverul vor avea câte un obiect InputStream și
OutputStream în scopul comunicării.

public InputStream getInputStream ( )
- Returnează un flux de intrare care permite citirea datelor din socket
(trimise de cealaltă aplicație).

public OutputStream getOutputStream ( )
- Returnează un flux de ieșire care permite scrierea datelor în socket (către
celălaltă aplicație).
void close ( )
- Închide socketul curent, închizând conexiunea și eliberează reursele
utilizate.
public InetAddress getInetAddress ( )
- Returnează adresa IP a mașinii de la distanță.
public int getPort ( )

- Returnează numărul portului gazdei de la distanță la care este conectat
socketul curent.
- Returnează portul local de la care este conectat socketul curent.
public InetAddress getLocalAddress ( )
- Returnează adresa mașinii locale de unde este conectat socketul curent.

Clasa ServerSocket din pachetul java.net
 Un obiect ServerSocket are rolul de a aștepta și de a accepta cererile de
conexiune de la clienți.
 Serverul e înștiințat de stabilirea conexiunii prin primirea unui obiect de tip
Socket, prin intermediul căruia se va realiza comunicația.
 La crearea unui obiect ServerSocket se precizează doar portul de
comunicație. Numărul de port ales trebuie apoi comunicat clienților pentru
a se putea conecta la server.

 Constructori semnificativi:
public ServerSocket (int port)
- Creează un socket pentru server la portul specificat.

public ServerSocket (int port, int nr)
- Creează un socket pentru server la portul specificat și se stabilește
lungimea maximă a șirului de așteptare pentru cererile de conectare. Dacă
o cerere vine într-un moment în care coada de cereri este plină,
conexiunea e refuzată.
 Cele mai importante metode ale clasei ServerSocket sunt:
public Socket accept ( )

- În momentul conectării unui client, metoda returnează un socket prin
intermediul căruia se realizează comunicația.
public void close ( ) - Închide socketul.

public InetAddress getInetAddress ( )
- Returnează adresa locală la care este legat socketul. Dacă nu se specifică
nici o adresă locală în constructor, atunci se va returna 0.0.0.0
- Returnează numărul portului la care este legat socketul sau -1 dacă acesta nu
este legat.
Exemplu: aplicatie CitatulZilnic
TCPClient.java
import java.io.*;
import java.net.*;
public class TCPClient

{
public void go() {
try {
//creare socket client
Socket clientSocket = new Socket("127.0.0.1", 4242);
//creare flux de intrare
InputStreamReader streamReader = new InputStreamReader(clientSocket.getInputStream());
BufferedReader inFromServer= new BufferedReader(streamReader);
//citire linie de la server
String citat= inFromServer.readLine();
System.out.println("Citatul zilei: " + citat);
inFromServer.close();
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
public static void main(String[] args)
{
TCPClient client = new TCPClient();
client.go();
}
}
TCPServer.java
import java.io.*;
import java.net.*;
public class TCPServer

{
String[] listaCitate= {"Invinge durerea, razi cat se poate, caci tot la zi ajunge si cea mai lunga noapte...",
"Nu indraznim pentru ca lucrurile sunt dificile, dar lucrurile sunt dificile tocmai pentru ca nu indraznim",
"Fii bun de cate ori se poate. Si intotdeauna se poate.",
"Da-i unui om un peste, si va fi satul o zi intreaga: invata-l sa pescuiasca si va fi satul o viata intreaga.",
"Succesul inseamna a fi in stare sa mergi din esec in esec, fara sa-ti pierzi entuziasmul."};
public void go() {

try {
//creare socket la portul 4242
ServerSocket serverSocket = new ServerSocket(4242);
while (true)
{
//serverul accepta cererea venita de la client
Socket connectionSocket = serverSocket.accept();
// crearea flux de iesire, atasat la socket
PrintWriter outToClient= new PrintWriter(connectionSocket.getOutputStream());
String sfat= getAdvice();
outToClient.println(sfat);
outToClient.close();
System.out.println(sfat);
}
} catch (IOException ex)
{
ex.printStackTrace();
}
}
private String getAdvice() {
int random = (int) (Math.random() * listaCitate.length);
return listaCitate[random];
}
public static void main(String[] args)
{
TCPServer server = new TCPServer();
server.go();
}
}
Clasa URL
 clasa URL (Uniform Resource Locator) – permite instanțierea unor obiecte

care identifică resurse accesibile pe Web (un fișier, un director, o cerere
adresată unei baze de date sau unui motor de căutare etc.).
 URL are mai multe componente: protocolul folosit pentru accesarea

resursei (http, ftp etc.), mașina pe care se găsește resursa accesată, portul
asociat serviciului care implementează protocolul folosit și numele resursei
respective ( inclusiv calea relativă în structura de directioare).
 portul este un parametru opțional, dacă nu este furnizat se consideră
pentru acesta o valoare implicită (80 direct, 8080 prin proxy), care
corespunde serviciului http.
 constructori ai clasei URL:
public URL (String protocol, String host, int port, String fisier)
public URL (String protocol, String host, String fisier)
public URL (String specificare)
-parametrul specificare conține adresa URL corespunzătoare, în cazul în care

parametrul nu conține un URL valid, se va arunca excepția
MalformedURLException.
 Metode pentru obținerea informațiilor încapsulate:
public String getFile ( )
- Returnează numele fișierului
public String getHost ( )
- Extrage numele mașinii gazdă
public String getPort ( ) - returnează portul utilizat
public String getProtocol ( )
- returnează numele protocolului

public String getRef ( )
- returnează referința
public final Object getContent ( )

-returnează conținutul resusrsei referite sub forma unui obiect al cărui tip este
convenabil ales în funcție de tipul fișierului
public final InputStream openStream ( )
-deschide o conexiune la adresa referită și întoarce obiectul InputStream
corespunzător
public URLConnection openConnection ( )
- realizează o conexiune la resursa indicată
Clasa URLConnection
 clasa abstractă URLConnection este superclasa tuturor claselor care

intermediază comunicarea dintre o aplicație sau applet Java și o resursă
Internet, identificată printr-un URL.
 crearea unei conexiuni la un anumit URL se realizează în mai mulți pași:

1. Se apelează metoda openConnection( ) a clasei URL, această metodă returnează
oiectul de conexiune de tipul URLConnection.
2. se manipulează parametrii implicați în conexiunea la resursa de la distanță.
3. Se apelează metoda connect( ) a clasei URLConnection, această metodă permite
stabilirea unei conexiuni dintre aplicația curentă și resursa referită prin URL.
4. După apelul connect, aplicația poate interacționa cu obiectul de la distanță referit
prin URL.
 câteva metode ale clasei URLConnection:
public abstract void connect ( )

- Deschide comunicația
public URL getURL ( )
- returnează obiectul URL al conexiunii

public int getContentLength ( )
- returnează lungimea conținutului resursei
public long getDate ( )
- data creare resursă, milisecunde de la 01.01.1970 00:00
public long getLastModified ( )
- data ultimei modificări a resursei
public InputStream getInputStream ( )
public OutputStream getOutputStream ( )

- aceste metode permit deschiderea unui stream de intrare, respectiv de
ieșire , prin care aplicația curentă poate citi, respectiv transmite date
obiectului de la distanță.
public void setDoInput (boolean b)
public boolean getDoInput ( )
public void setDoOutput (boolean b)
public boolean getDoOutput ( )
- aceste metode manevrează flagurile de intrare și de ieșire. O conexiune
poate fi folosită pentru intrare sau/și pentru ieșire. Implicit flag-ul de intrare
este true, iar flag-ul de ieșire este false.
 Exemplu: acces la o resursă Internet
import java.io.*;
import java.net.*;
import java.util.*;
public class URLInfo {
public static void main(String argv[]) throws Exception {

//creeaza un URL la o resursa, deschide o conexiune cu acest URL
URL url = new URL ( argv[0]);
URLConnection u = url.openConnection( );
//afiseaza adresa URL si alte informatii despre aceasta
System.out.println (u.getURL ( ) .toExternalForm ( ) + “:”);
System.out.println (“Tip continut: “ + u.getContentType ( ) );
System.out.println (“Lungime continut: “ + u.getContentLength () );
System.out.println (“Ultima modificare: “ + new Date
(u.getLastModified ( ) ) );
System.out.println ( “Flagurile I/O Input: “ + u.getDoInput ( ) +
“ Output: “ + u.getDoOutput ( ) ) ;
//citeste si afiseaza primele 10 linii de la URL
System.out.println ( “Primele 10 linii: “);

BufferedReader in = new BufferedReader (
new InputStreamReader (u.getInputStream ( )));
for ( int i = 0; i<10; i++) {
String linie = in.readLine ( );
if ( linie == null ) break;
System.out.println (linie);
}
}
}
- Programul afișează, pentru URL-ul transmis ca argument în linia de

comandă, șase rânduri de informații despre URL-ul respectiv (URL-ul, tipul
conținutului, lungimea acestuia în octeți, data și ora ultimei modificări,
flagurile de I/O ) și primele 10 linii sursă ale acestui URL.
O posibilă execuție pentru comanda: java URLInfo http://www.etti.tuiasi.ro/
Tip continut: text/html; charset=utf-8

Lungime continut: 43183
Ultima modificare: Tue Nov 30 10:33:25 EET 2010
Flagurile I/O Input: true Output: false
Primele 10 linii:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="ro-ro" lang="ro-ro"
>
<head>
<title>ETTI - Facultatea de Electronica, Telecomunicatii si Tehnologia
Informatiei</title>
<style type="text/css">
<!--
.absolut {position: absolute; left: 145px; }
Programare Java
IX. Lucrul cu baze de date în Java
2013
Lucrul cu baze de date în Java
Cuprins
1. Ce este JDBC?
2. Conectarea prin JDBC la o bază de date

3. Conversie SQL - Java
4. Comenzi SQL
5. Referințe JDBC
1. Ce este JDBC?
JDBC (Java Data Base Connectivity) – este un API care permite

accesul din programe Java la surse de date, în special la baze de
date relaționale.
 Prin JDBC mediul Java pune la dispoziție un instrument puternic
de comunicare și de lucru cu bazele și cu server-ele de date.
 JDBC oferă posibilitatea de a executa comenzi SQL pentru cereri
din baza de date, precum și efectuarea unor modificări asupra
datelor din bază.


1. Ce este JDBC?
Arhitectura JDBC este prezentată mai jos:

1. Ce este JDBC?
Driver-ul JDBC reprezintă interfața între API și baza de date,

prin această interfață se asigură accesul uniform la baza de date.
Astfel, dacă se schimbă baza de date, codul aplicației rămâne

nemodificat.
 Driver-ele JDBC sunt furnizate de către producătorii de baze de
date: Oracle, Microsoft, Sysbase, SQL Server, MySQL, DB2, IBM
etc.
1. Ce este JDBC?
Un driver JDBC se prezintă sub forma unei arhive .jar accesibilă

prin classpath.
DriverManager-ul este responsabil cu administrarea driver-elor

JDBC.
 Funcția DriverManager-ului este aceea de a conecta corect
aplicațiile Java la driver-ul JDBC potrivit.
 Interfețele și clasele pentru JDBC se găsesc în pachetele
java.sql și javax.sql.
 Pașii ce trebuie parcurși pentru accesul la o bază de date din Java
sunt:
1) Instalarea unui driver adecvat
- Încărcarea unei clase Driver pentru conectarea prin JDBC la un
anumit tip de bază de date, de exemplu:
Class.forName( "com.mysql.jdbc.Driver" ).newInstance();
- Astfel se obține un DriverManager potrivit accesului la tipul de
bază de date dorit.

2) Crearea unei conexiuni
- Înainte de conectare este necesară inițializarea drive-ului, de

exemplu:
String url = "jdbc:mysql://localhost/magazin";
- Se obține din DriverManager un obiect de tip Connection și se
apelează metoda getConnection, de exemplu:
Connection conn = DriverManager.getConnection( url, "root", "admin" );

- metoda getConnection poate avea următoarele forme:
Connection c = DriverManager.getConnection(url);
Connection c = DriverManager.getConnection(url, username, password);
Connection c = DriverManager.getConnection(url, dbproperies);
3) Interacțiunea cu baza de date
- Se creează un obiect de tip Statement, cu ajutorul căruia putem
trimite secvențe SQL către baza de date, de exemplu:
Statement st = conn.createStatement();
4) Accesul la baza de date
- În funcție de tipul de acces dorit, se pot specifica instrucțiuni SQL de
acces, folosind metodele: executeUpdate(String) sau

executeQuery(String) ale obiectului Statement.
- Metoda executeQuery( ) execută comanda SQL primită ca parametru
și returnează un obiect de tip ResultSet și se utilizează pentru execuția
comenzilor SQL de interogare SELECT.

Exemple:
String query = "SELECT * FROM CATEGORII;";

ResultSet rs = st.executeQuery(query);
- Metoda executeUpdate( ) execută comanda SQL primită ca parametru și
returnează numărul de articole (records) modificate.
- Se utilizează pentru comenzile SQL de manipularea datelor: INSERT,

UPDATE, DELETE și pentru comenzi de definire a datelor
CREATE/DROP TABLE, caz în care valoarea returnată este 0.
Exemple:
st.executeUpdate( "INSERT INTO PRODUSE(NUME, PRET, ID_CATEGORIE, CANTITATE) “
+ "VALUES ('MEMORIE', 35, 3, 14)" );
st.executeUpdate( "UPDATE PRODUSE SET CANTITATE = CANTITATE + 1 WHERE
NUME='MEMORIE'" );
st.executeUpdate( "DELETE FROM PRODUSE WHERE NUME='MEMORIE'" );
5) Prelucrarea interogărilor
- Obiectul ResultSet conține rezultatul interogării bazei de date, pentru
parcurgerea liniilor din baza de date se folosește metoda next( ).

Exemplu:
while ( rs.next() )
{
String nume = rs.getString( "NUME" );
int pret = rs.getInt( "PRET" );
int cantitate = rs.getInt( 3 );
System.out.println( nume + " " + pret + "RON " + cantitate );
}
- Dacă rezultatul interogării este vid se va genera o excepție SQLException.

- Obiectul ResultSet conține metode pentru accesul datelor din rezultat,
folosind metodele getXXX(int) și getXXX(String) ce returnează valoarea
dintr-o coloană specificată prin parametru și linia curentă. În locul XXX se

pune un tip predefinit Java (ex: int, String).
Exemplu:
String nume = rs.getString( "NUME" );
int pret = rs.getInt( "PRET" );
6) Închiderea conexiunii
- Se închid, în ordine, obiectele ResultSet, Statement, Connection.

Exemplu:
conn.close();
3. Conversie SQL - Java

4. Comenzi SQL
 Creare de tabele:
CREATE TABLE nume(col1 tip_col1, col2 tip_col2, col3 tip_col3, …);

Exemplu:
CREATE TABLE `produse` (

ìd` int(11) NOT NULL AUTO_INCREMENT,
`nume` varchar(20) DEFAULT NULL,
`pret` int(11) DEFAULT NULL,
ìd_categorie` int(11) NOT NULL,
`cantitate` int(11) DEFAULT NULL,
PRIMARY KEY (ìd`),
KEY `fk` (ìd_categorie`)
)
4. Comenzi SQL
 Selectarea datelor:
SELECT col1[,col2, col3, …] FROM tabel[WHERE conditie];
- Se pot selecta mai multe coloane, se poate utiliza caracterul *.

Exemplu:
SELECT * FROM ‘categorii’ WHERE 1

4. Comenzi SQL
 Inserarea de date
INSERT INTO tabelVALUES (val1, val2, val3, …);

Exemplu:
insert into `magazin`.`categorii`(ìd`,`nume`) values (1,'electronice');

insert into `magazin`.`categorii`(ìd`,`nume`) values
(2,'electrocasnice');
insert into `magazin`.`categorii`(ìd`,`nume`) values (3,'componente
PC');
insert into `magazin`.`categorii`(ìd`,`nume`) values (4,'software');
4. Comenzi SQL
 Actualizarea datelor
UPDATE tabelSET col1=val_nouaWHERE oper1=val1 AND, OR

etc.;
 Ștergerea datelor
DROP TABLE tabel;
DELETE FROM tabel

WHERE col1 op val1 AND, OR etc
5. Referințe JDBC
JDBC Data Access API – JDBC Technology Homepage

http://www.oracle.com/technetwork/java/javase/tech/index-jsp-
136101.html
JDBC Database Access – The Java Tutorial
http://download.oracle.com/javase/tutorial/jdbc/index.html
JDBC Documentation
http://download.oracle.com/javase/1.4.2/docs/guide/jdbc/index.html
java.sql package
http://download.oracle.com/javase/6/docs/api/java/sql/package-
summary.html
JDBC Technology Guide: Getting Started
http://download.oracle.com/javase/1.4.2/docs/guide/jdbc/getstart/Gettin
gStartedTOC.fm.html
JDBC API Tutorial and Reference (book)
http://java.sun.com/docs/books/jdbc/

Curs Java PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs Java PDF

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA TEHNICĂ “GH.

ASACHI” DIN IAŞI

II. Elementele de bază ale

2. Tipuri de date și variabile

- caracterul tabulator orizontal: ‘\t’

CR (carrriage return), ‘\r’

Identificatorii – reprezintă nume pentru variabile, metode, clase

Condiții asupra numelui:

- numele este o secvență de litere, cifre, caracterele $ sau _ , dar care nu

- numele trebuie să fie diferit de orice cuvânt cheie;

- numele trebuie să fie diferit de null, false, true;

mici; de ex: suma, Suma, SUMA sunt trei identificatori diferiți.

- numele claselor încep cu majusculă, fiecare cuvânt distinct din identificator

urmează începând cu majusculă; ex: name, setName( )

 Comentariile - utilizate pentru a explica și pentru a documenta

În Java există trei tipuri de comentarii:

// această linie este comentată

 Separatorii - caractere care separă unitățile lexicale Java unele de altele

String sau tipul null.

 logici - pot lua doar două valori: true sau false.

Observație. Spre deosebire de limbajul C++, valorile 0 și 1 nu mai au

Literalii logici sunt de tip boolean.

 șir de caractere – este o secvență de zero sau mai multe caractere

Observație. În Java orice șir de caractere este o instanță a clasei String,

limbajul Java. Sunt cuvintele care însoțesc variabilele, metodele, clasele.

double else extends final finally float

rezultatul comparării fiind de tip boolean:

condiționali: && (și)

sir_caractere+var_tipT sau var_tipT+sir_caractere

+=, -=, *=, /=, %= x += y; echivalent cu x = x + y;

<<=, >>=, >>>= x <<= n; echivalent cu x = x << n;

 operatorul cast - este utilizat pentru a converti o valoare dintr-un tip

Obs. Tipul boolean nu poate fi convertit în nici un alt tip și invers.

- testează dacă un obiect este de o anumită clasă

clasă derivată din aceasta și false în caz contrar.

byte 8 -27=-128 27-1=127

short 16 -215=-32768 215-1=32767

int 32 -231 231-1

long 64 -263 263-1

char 16 ‘\u0000’=0 ‘\uffff’=65535

float 32 1.4e-045 3.4e+038

double 64 4.9e-324 1.8e+308

boolean false true

[ lista _modificatori] tip_data numeVariabila;

Scope ( int param) { // param este vizibil doar în acest constructor

 variabilele locale – nu primesc valori prestabilite.

private String titlu; Rezultat:

public int getTitlu ( ) {

fi creat vreun obiect al clasei

public Jucator ( String s) {

Exemplu: variabile PI din clasa Math

public – să fie accesibilă din orice cod

static – să nu fie necesară o instanță a clasei Math

pot fi accesate utilizând un nume comun

int [ ] [ ] tabMultidim; //declarare tablou bidimensional

în Java un tablou este întotdeauna un obiect.

 Accesul la elementul de pe poziția i: tablou [i]

 Indicele este cuprins între 0 și length-1

 În Java este verificat accesul la elementele tabloului, dacă se depășește

Copierea conținutului unui tablou în alt tablou:

case 2: System.out.println("Februarie"); break;

FACULTATEA DE ELECTRONICĂ, TELECOMUNICAŢII ŞI TEHNOLOGIA INFORMAŢIEI

- permit întreruperea necondiționată a unei secvențe de program și