Proiect

UNIVERSITATEA TIBISCUS DIN TIMIOARA
FACULTATEA DE CALCULATOARE I INFORMATIC APLICAT
CUPRINS
CUPRINS...................................................................................................1
1. INTRODUCERE...................................................................................2
2. NOIUNI DESPRE LIMBAJUL JAVA..............................................4
2.1 Obiecte i clase n programarea pe obiecte...........................................4
2.2 Organizarea unui program n obiecte....................................................5
2.3. Definirea unei clase..............................................................................9
2.4 Motenire.............................................................................................16
2.5. Principalele pachete din JDK.............................................................26
2.6 Interfeele grafice de utilizator n Java................................................30
3. APLICAIA AVIOANE......................................................................40
3.1 Soluia de implementare......................................................................40
3.2 Structura programului.........................................................................41
3.3 Regulile i funcionarea aplicaiei.......................................................43
4. CONCLUZII........................................................................................46
BIBLIOGRAFIE....................................................................................48
ANEXA.....................................................................................................49
Marius Cristian Lighezan

1. INTRODUCERE
Rolul informaiei n activitatea omului devine tot mai important pe msur ce
aceasta devine tot mai complex. Pe lng aceasta, costul unui computer este astzi
suficient de redus nct el s devin un obiect la ndemna unei largi categorii de
utilizatori. Prin urmare, calculatorul este folosit actualmente n din ce n ce mai multe
domenii, soluionnd o gam vast de aplicaii de la sistemele expert destinate
cercetrii de nalt nivel pn la jocurile pe calculator ori aplicaii casnice foarte uor
de utilizat de nespecialiti.
Lucrarea de fa i propune prezentarea unei aplicaii de colectare a datelor
personale i nregistrarea lor ntr-o baz de date relaional. Aplicaia const ntr-o
interfa ce permite conectarea la o baz de date pentru a introduce sau selecta datele
din ea. Programul este realizat n limbajul de programare Java.
Materialul este structurat pe mai multe pri, ncercndu-se punerea n eviden
a celor mai importante elemente utilizate n realizarea aplicaiei.
Prima partea lucrrii, se constituie ntr-o prezentare general a tematicii
abordate n cadrul capitolelor ce compun prezentarea. Fiecare dintre seciuni este
analizat prin prisma utilitii ei n cadrul ansamblului.
Capitolul al doilea se constituie ntr-o scurt trecere n revist a principalelor
elemente, metodele i tehnici n limbajul de programare obiectual Java. Se
accentueaz acele caracteristici care au relevan pentru implementarea efectiv a
aplicaiei ce face obiectul acestei lucrri de licen.
Partea a treia cuprinde o prezentare detaliat a modului n care s-a implementat
aplicaia curent. De asemenea se ofer precizri privind modul concret de utilizare al
programului n subcapitolul Ghid de utilizator.
n seciunea a patra sunt prezentate concluziile finale i posibilitile de
dezvoltare ulterioar a aplicaiei CV de colectare a datelor personale. Sunt

exemplificate cteva soluii concrete pentru a crete eficiena lucrului cu programul i
pentru a mri flexibilitatatea aplicaiei.
n ultima parte se prezint bibliografia studiat i utilizat de autorul acestei
lucrri de licen n implementarea programului i elaborarea materialului de fa.

2. NOIUNI DESPRE LIMBAJUL JAVA
2.1 Obiecte i clase n programarea pe obiecte

Clasa fiind o definiie teoretic, un tipar, conine doar declararea tipurilor
datelor i expresiile funciilor membre. Clasele sunt folosite pentru a crea obiecte.
Obiectele sunt elementele funcionale ale programului n limbajul Java. n cursul
rulrii ele sunt create, sunt utilizate i atunci cnd devin inutile, sunt distruse.
Obiectul reprezint materializarea n interiorul unui program a unei clase. El
cuprinde valorile numerice efective ale datelor membre prezentate atunci cnd s-a
declarat clasa.
Obiectele construite dup modelul definit de o clas sunt instane ale acelei
clase. Din acest motiv crearea unui obiect se mai numete i instaniere.
Dac dintr-o clas se instaniaz mai multe obiecte, aceste obiecte, dei sunt
asemntoare, reprezint entiti diferite n cadrul programului. Pentru fiecare dintre
ele exist un spaiu de memorie separat i cte o copie autonom pentru fiecare
variabil din componen. Acest spaiu este alocat atunci cnd se creeaz obiectul,
este folosit pe parcursul vieii acestuia i este eliberat la distrugerea lui.
ntr-un program pot s existe mai multe clase, fiecare dintre ele avnd propriile
obiecte. ntre clasele implicate n funcionarea programului respectiv pot s existe
relaii de interdependen. De exemplu o clas poate s reprezinte un model general
din care, n cursul dezvoltrii programului, se deriv subclase (modele particulare)
care conin descrieri teoretice mai detaliate i, prin urmare, mai restrictive. De obicei
n programe exist clase de baz sau printe i clase fiice sau derivate.
Clasa:
Echip de fotbal

Obiecte:
-
UTA;
Dinamo;
Steaua;
U Craiova.
Poli Timioara
Subclasa: Echip de fotbal universitar

Obiecte:
-
U Craiova.
Poli Timioara;
Subclasa: Echip de fotbal bucuretean

Obiecte:
-
Steaua;
Dinamo.
Obiectele se creeaz cu ajutorul unui tip special de funcie numit constructor.

Constructorul trebuie scris iniial cnd se definete clasa. Eliminarea unui obiect se
face n C++ cu o funcie destructor ce trebuie de asemenea scris la definirea clasei.
n Java calculatorul produce automat un destructor.
n C++ funciile membre pot fi inline, adic au codul scris chiar acolo unde
sunt declarate n interiorul clasei, sau offline, adic n afara clasei. n Java funciile
membre sunt denumite metode i sunt obligatoriu scrise n interiorul definiiei clasei.
Acest fapt este compatibil att cu caracterul pur obiectual al limbajului ct i cu
funcionarea efectiv a programelor.
2.2 Organizarea unui program n obiecte

Un program ntr-un limbaj procedural, cum este de exemplu limbajul C, conine
ntotdeauna urmtoarele blocuri:
Zona include unde se face legtura cu bibliotecile;

Declararea constantelor i variabilelor externe;
Declararea funciilor;
Funcia main (corpul principal);
Expresiile funciilor.
La rndul lui corpul principal al programului, denumit funcia main, conine

n interiorul su urmtoarele componente:
Declararea variabilelor i constantelor interne;
Alocri de spaiu n memorie;
Asignri variabile;
Operaii cu datele mai sus definite;
Apeluri la funcii.
n cazul programelor obiectuale cum este C++, spre deosebire de situaia

descris anterior, aceast structur se modific radical deoarece trebuiesc declarate
iniial clasele cu datele si funciile membre, apoi trebuiesc instaniate obiectele,
procesate datele respectnd ncapsularea i n final distruse obiectele. Prin urmare
structura programului devine:
Zona include unde se face legtura cu bibliotecile;
Declararea claselor;
Expresia funciilor membre off-line;
Declararea funciilor externe;
Funcia main cuprinznd instanieri de obiecte, procesri de date

membre cu funcii membre ale aceleiai clase i eliminri de obiecte;
Expresiile funciilor externe.
Dac se opteaz pentru organizarea tip proiect clasele se pot plasa att n
fiiere .h cat i n fiierele .cpp.
Limbajul Java este un limbaj obiectual pur, adic spre deosebire de C++ sau de
varianta pe obiecte a Pascalului, care pstreaz parial caracteristicile motenite de la
limbajele procedurale din care provin, n Java totul se desfoar cu i prin
intermediul obiectelor. Nu exist o funcie main() a programului, ci una sau mai multe

funcii executabile pentru fiecare clas.
Clasele Java sunt plasate dup compilare n cte un fiier separat cu extensia
.class, chiar dac iniial n etapa de editare a programului clasele au fost toate
definite n unul i acelai fiier, avnd extensia .java.
Mai mult dect att, aa cum se va arta n capitolul Clase utilizate ca date,
tipurile simple de date cum sunt byte, int sau float pot fi definite att direct (precum n
limbajele procedurale), ct i sub forma unor clase i utilizate ca atare.
import pachet_1;
.....
import pachet_M;
class Clasa_unu{
//declaraie clasa Clasa_unu
declaraii date membre Clasa_unu;

declaraii funcii membre (metode) Clasa_unu;
}
class Clasa_doi{
//declaraie clasa Clasa_doi
declaraii date membre Clasa_doi;

declaraii funcii membre (metode) Clasa_doi;
}
class Clasa_N{
//declaraie clasa Clasa_N
declaraii date membre Clasa_N;

declaraii funcii membre (metode) Clasa_N;
}
De multe ori, n cazul aplicaiilor complexe este indicat organizarea sub form
de proiect, n care doar clasa principal este plasat ntr-un fiier cu extensia
.java, iar celelalte clase sau familii de clase se pot grupa n fiiere bibliotec definite
de utilizator. Dac rularea se face n cadrul unei pagini web, atunci proiectul conine
una sau mai multe pagini .html. De asemenea n interiorul proiectului se gsesc
fiiere de configurare a opiunilor de lucru. Proiectele prezint unele avantaje ntre
care cele mai importante sunt: pstrarea automat a setului de opiuni ale mediului de
programare (n fiiere de configurare) i posibilitatea includerii unor fiiere deja

compilate n pachetul de fiiere utilizat.
O specificitate important a limbajului Java este legat de faptul c aplicaiile
Java ruleaz la fel de bine pe un calculator PC compatibil IBM dotat cu Windows `95,
`97, `98 sau NT, pe o staie Sun, pe un computer Apple McIntosh sau pe alte
platforme. Acest lucru este posibil datorit faptului c pe toate acestea se realizeaz n
fapt o emulare a unei maini virtuale, denumit main Java. Oricare dintre
computerele enumerate poate fi folosit pentru editarea, compilarea i rularea
programelor Java dac exist urmtoarele dou componente soft:
un editor capabil s creeze fiiere surs .java (preferabil i pagini

.html),
un browser capabil s lucreze cu Java.
Mediul Java Development Kit (JDK) este un editor simplu de utilizat i se poate
gsi la site-ul limbajului Java: http://java.sun.com de unde poate fi descrcat cu
ajutorul unui browser sau al unui program FTP. Fiecare tip de calculator are propriile
particulariti i instalarea programului JDK prezint diferene specifice fiecruia.
Detalii suplimentare despre aceste probleme i n general nouti cu privire la limbajul
Java se pot gsi tot la adresa de Internet a firmei Sun, promotoarea limbajului Java:
http://java.sun.com
n ce privete browserele compatibile Java, cele mai performante dintre ele sunt:
HotJava (scris complet n limbajul Java), Microsoft Internet Explorer i Netscape
Navigator. Primul este disponibil la aceiai adres cu JDK. Celelalte dou, care sunt i
cele mai rspndite, sunt produsele firmelor Microsoft (componente ale pachetului
Windows) i Netscape (se poate descrca din pagina WEB: http://home.netscape.com)
O alt variant de lucru este utilizarea pachetului Microsoft Development Studio for
Java (MsDev) care are un editor pentru fiierele surs .java, unul pentru paginile
.html i un browser incorporat care permite testarea programelor. MsDev este
conceput s faciliteze lucrul n sistemul de proiect descris anterior.
Recent tot firma Microsoft a scos pe pia mediul de programare Microsoft
Visual Java (MsVJ), o variant perfecionat a mediului MsDev, avnd multe
similitudini ca funcionare i grafic cu acesta dar i o serie de diferene importante.

Autorul a testat programele prezentate n aceast carte n mediile MsDev i MsVJ i
nu a detectat incompatibiliti. Acest lucru provine i din utilizarea modului de lucru
proiect, mod care conserv opiunile de configurare ale mediului.
2.3. Definirea unei clase

n limbajele procedurale C sau Pascal, n cazul n care se combin mai multe
date de tipuri diferite ntr-o singur variabil, aceast variabil se numete structur.
Structurile se declar prin declararea tuturor datelor membre n interiorul unui bloc.
struct Persoana{
char nume[25];
char adresa[50];
int data[3];
// zi, luna, an natere
int tel;
}
Se poate observa c toate aceste date, dei diferite ca tip i coninut, au ca
element comun faptul c sunt referitoare la Persoana. Astfel nct dac n program
se declar o variabil:
Persoana Ion,
se pot apoi scrie caracteristicile personale, ntr-o form ncapsulat, n aceast
structur. Acest avantaj al structurilor de a trata n comun datele complexe nu este
prea frecvent exploatat de limbajele procedurale i, din acest motiv, structurile nu sunt
foarte des ntlnite n programe.
n limbajele obiectuale ns, structurile sunt transformate n arhitecturi mai
complexe, care prin includerea funciilor membre devin clase i reprezint prototipul
obiectelor, elementele constitutive de baz al programelor orientate pe obiect. Clasele
sunt declarate similar cu structura din exemplul anterior, doar c lista conine i
funcii ale cror cod poate fi scris pe aceiai linie cu declaraia. n Java toate funciile
sunt in line adic se scriu in interiorul clasei din care fac parte.

Definirea unei clase n limbajul Java se face cu sintaxa de mai jos:
[specif_acc] class nume_cls [extends clsp][implements intf]{
[declaraii variabile]
[declaraii funcii]
}
Elementele cuprinse in paranteze ptrate sunt facultative i unele din ele pot in
diferite cazuri s lipseasc. Cea mai simpl declaraie de clas este cea a clasei Vida:
class Vida{
//clasa vid evident fr aplicaii
}
Elementele opionale sunt: specificatorul de acces specif_acc care limiteaz
vizibilitatea clasei, extends care precede clasa printe clsp a clasei curente i
implements care precede numele interfeei intf. O asemenea clas este n fapt o
structura creia i se adaug un numr de elemente i proprieti suplimentare. n
esen ns, la fel ca i structurile, clasele sunt prototipuri ideale.
Obiectele sunt variabile declarate ca avnd tipul definit de clas. Obiectele sunt
instane ale claselor, adic ele trebuie concepute ca fiind materializarea practic a
prototipurilor ideale care sunt clasele.
Dac se transform structura Persoana n clas, atunci Persoana Dan este o
instan a clasei Persoana, un obiect.
class Persoana{
char nume[25];
char adresa[50];
int data[3];
int tel;
void print_it(){
// metod membr
propoziiile funciei print_it

}
}
Aa cum se vede mai sus o clas conine n general dou feluri de elemente:
date membre de obicei protejate fa de exterior i funcii membre care au acces i
proceseaz datele membre. Aceast proprietate a claselor se numete ncapsulare.
10

Datele membre sunt variabilele declarate n interiorul clasei. Ele sunt accesibile
pentru toate funciile clasei i numai pentru ele.
Evident i n cazul variabilelor din interiorul claselor este absolut obligatorie
pstrarea ordinii anterior stabilite:
declaraia variabilei n interiorul declaraiei clasei
inializarea variabilei la instanierea obiectului
asignarea la procesare
n exemplul de mai jos variabilele sunt: ziua, luna i data. Ele sunt
componentele clasei Data i de fiecare dat cnd se creeaz un obiect ce aparine
acestei clase, acestor variabile trebuie s li se atribuie valori.
class Data{
int ziua;
int luna;
int anul;
}
Sintaxa de declararea a variabilelor membre este:
[specificator acces] tip_variabila nume_variabila;
Specificatorul de acces este opional i guverneaz ca i n cazul claselor
vizibilitatea variabilei. Exist trei specificatori de acces:
private - limiteaz vizibilitatea variabilelor strict la interiorul clasei, doar

funciile clasei pot accesa aceste date;
protected - limiteaz vizibilitatea variabilelor la interiorul clasei i al

motenitorilor acesteia, doar funciile clasei i cele ale motenitorilor pot
accesa aceste date;
public -
permite accesul liber la variabile al tuturor funciilor din
program.
Uneori anumite variabile sunt iniializate cu o valoare ce trebuie s rmn
aceiai pe toat durata rulrii programului. n acest caz se adaug la declaraie
specificatorul final i sintaxa declaraiei va fi de forma:
[specificator acces] final tip_variabil nume_variabil=valoare;
11

Spre exemplu, n cazul clasei Data se poate specifica faptul c limita maxim
pentru variabila luna este:
class Data{
int ziua;
int luna;
int anul;
final int Max=12;
// variabil final
}
n programele orientate pe obiecte, n loc s se defineasc separat datele i
funciile care le prelucreaz, aa cum se procedeaz n limbajele procedurale, cele
dou devin membre ale aceleiai structuri compozite denumit clas.
Avantajul acestei abordri a problemei const n faptul c aceast definire
comun, mpreun cu specificatorii de acces, delimiteaz clar cine are i cine nu are
dreptul de a modifica valoarea unei anumite variabile.
Sintaxa unei funcii membre denumit n java metod este:
[specif_acces] tip_val_returnate nume_metod (list_param){
propoziiile metodei;
}
Se poate observa c, n afar specificatorul de acces, sintaxa de mai sus este
clasic pentru orice funcie. Se declar tipul valorii returnate, numele metodei i lista
parametrilor acesteia. n absena unei valori returnate se pune n loc void, care
semnific faptul ca funcia nu returneaz nici un parametru. Lista parametrilor, fie ea
i vid, trebuie ntotdeauna s fie specificat.
De exemplu, n blocul de program prezentat mai jos, void print_it () este o
metod a clasei Data, care nu are nici parametrii nici valoare returnabil:
class Data{
private int ziua;
private int luna;
private int anul;
public void print_it(){
12

System.out.println(data.ziua, data.luna, data.anul);
}
}
n limbajul Java exist posibilitatea de a defini mai multe funcii care sa aib
unul i acelai nume, dar o list de argumente diferit. Aceast proprietate se numete
suprancrcarea funciilor.
La apelare funcia chemat este cea a crui numr i tip de argumente coincide
cu numrul i tipul argumentelor din expresia apelant. n situaia prezentat n
exemplul de mai jos, evident, numrul de parametrii este hotrtor. Dac se consider
i cea de a treia funcie atunci tipul fiecrui argument devine important.
De exemplu se pot defini funciile:
void m() { propoziii funcia1 }
void m(int x, int y) { propoziii funcia2 }
void m(byte x, byte y) { propoziii funcia3 }
In cazul n care la apelare apar argumente de un alt tip, calculatorul face
conversia i ,dac se pierde din precizie, d un avertisment la compilare.
O clasa n Java trebuie obligatoriu s aib cel puin o funcie membru i anume,
o funcie capabil s instanieze obiecte din tipul definit de acea clas. Aceast funcie
special se numete constructor i va fi detaliat n paragraful urmtor.
Spre deosebire de C++, n Java nu este necesar crearea unui destructor avnd
funcia invers, de eliminare a obiectelor. Java arunc la gunoi automat elementele
de care nu mai este nevoie.
O alt funcie, care este ntotdeauna prezent n interiorul claselor care sunt
executabile, este funcia principal main(), care primete mesajele din exterior,
conine expresii condiionale care le interpreteaz i guverneaz, n general,
manifestarea clasei n timpul rulrii programului.
Metodele i variabilele statice reprezint o categorie aparte deoarece ele pot fi
mai degrab considerate membre ale clasei, dect ale obiectelor create din clasa
respectiv.
Variabilele statice sunt utilizate atunci cnd este necesar existena unei
variabile comune pentru toate obiectele care s-au construit din clasa respectiv.
13

Sintaxa de declarare i iniializare a acestor variabile este:
[specificator acces] static tip_variabil nume_variabil=valoare;
Un exemplu tipic, n acest sens, este implementarea unui contor care s in
evidena numrului de obiecte existente la un moment dat.
class Soldat{
private boolean viu;
private static int contor=0
//contorul variabil static
public void Soldat(){
//constructor
viu = true;
contor ++;
//incrementare contor
}
public void mort{
if (viu){
viu =false;
contor --;
//decrementare contor
}
}
De fiecare dat cnd creeaz un obiect se utilizeaz constructorul Soldat i, prin
urmare, se face incrementarea contorului. Cnd, n cursul rulrii programului, un
obiect de tip Soldat dispare, se execut metoda mort() i se face decrementarea
contorului. Deci, n variabila static numit contor se pstreaz evidena numrului de
soldai vii.
Diferena de comportare dintre o variabila obinuit, cum este viu i o
variabila static, aa cum este contor, provine din felul n care se desfoar
lucrurile la instanierea obiectelor. Fiecrui obiect creat i se atribuie la instaniere o
copie independent a fiecrei variabile uzuale. Aceste copii pot lua, n mod
independent, fiecare n parte, diverse valori. n schimb, variabila static este unic,
fiind aceiai pentru toate obiectele unei clase.
Metodele statice sunt, spre deosebire de metodele obinuite, disponibile i n
situaia n care nu s-a construit nici un obiect din clasa n care au fost declarate.
Sintaxa de declarare a unei metode statice este:
14

[specif acces]static tipul_retur nume_metod (list_parametrii){
propoziiile metodei;
}
Exist mai multe motive pentru care o asemenea metod ar putea fi utilizat n
programele scrise n limbajul Java. Una dintre cele mai frecvente utilizri este crearea
posibilitii de a construi un obiect al unei clase int i de al transmite cu
instruciunea return. Alt posibilitate de folosire a specificatorului static este in
cazul funciilor cu utilitate global n program.
class Matematica{
public static int patrat(x){
//ridicare la ptrat
return x*x;
}
public static int suma(x,y){
// nsumare
return x+y;
}
}
class Oclas{
public void ometoda(){
int i, j;
i=Matematica.patrat(5)
//metodele patrat i suma
j=Matematica.suma(3,6)
//utilizat fr ca s existe
//un obiect din clasa Matematica
}
}
Clasa Matematica este o clas de utiliti. Metodele ei, fiind declarate statice, se
pot folosi oriunde n interiorul celorlalte clase fr ca s fie necesar construirea unor
obiecte (instane) ale clasei.
Aa cum se poate vedea, n exemplul de mai sus, apelarea unei asemenea
metode se poate face cu sintaxa:
nume_clas.nume_metod_static (list_parametrii);
O alt variant de utilizare a unei metode statice este iniializarea static
15

utilizat la crearea constantelor disponibile pentru toate obiectele clasei i pentru toate
clasele motenitoare.
class Utilizatori{
static String lista[] = new String[3];
static{ lista[0]=Adi; lista[1]=Dan; lista[3]=Laura;
System.out.print(Utilizatorii incarcati si initializati);}
}
2.4 Motenire
Unul dintre cele mai importante beneficii ale utilizrii limbajelor de programare
orientate pe obiecte este posibilitatea utilizrii conceptului de motenire. Aceast
facilitate permite rezolvarea problemelor pornind mai nti de la cadrul general i,
apoi, mergnd spre particularitile fiecrui element al programului.
Acest lucru implic implementarea iniial a unor clase printe, care n Java se
numesc clase de baz i reprezint modele abstracte ce cuprind doar elementele
comune ale obiectelor din program. Apoi, se creeaz clasele fiice, numite n Java clase
derivate sau subclase, care reprezint modelele specializate ale obiectelor.
Prin urmare, odat definit o clas de baz, o subclas a ei poate fi definit
pornind de la ceea ce s-a specificat deja anterior n clasa de baz. n practic, este
vorba de o dezvoltare a modelului general pentru a obine din el modele particulare
ale obiectelor.
Clasa Animale este o clas de baz ce poate s aib subclasele: Mamifere i
Reptile. Prima clas derivat are ca trstur specific, de exemplu, sistemul de
nmulire cu naterea puilor vii, a doua are pielea solzoas tipic reptilian.
Cu adevrat important este ns, faptul c motenirea ofer posibilitatea
utilizrii n programele proprii ca i clase de baz, a unor clase din bibliotecile i
pachetele specializate ale limbajului Java. De exemplu, orice clas care este destinat
s funcioneze n cadrul unei pagini HTML pe Internet se poate defini ca o subclas a
16

clasei java.applet.Applet i beneficiaz de toate facilitile deja create n aceast clas.
Practic, pentru clasa derivat singura problem ce mai trebuie soluionat este
scrierea codului ce definete efectiv aciunea ce trebuie s se desfoare n spaiul
paginii. Evident, acest fapt aduce cu el posibilitatea realizrii unei mari economii de
timp i efort.
Sintaxa utilizat pentru derivarea unei subclase din clasa de baz este parte din
sintaxa general de declarare i definire a unei clase prezentat la nceputul capitolului
de fa. Statutul de motenitor al unei clase este indicat de cuvntul cheie extends
urmat de numele clasei de baz.
[specificator_acces] class nume_clasa [extends clasa_de _baz]{
[declaraii funcii]
}
n Java toate clasele sunt clase motenitoare direct sau prin intermediari ale
clasei rdcina Object. n general programatorii nu mai scriu extends Object dar
acest lucru este subneles.
class Animal extends Object{ //extends Object poate fi omis
protected boolean foame = true;
public void spune(){
System.out.print(Vreau mncare)
}
public void cerere(){
if (foame) spune();
}
}
class Pisica extends Animal{
//polimorfism
System.out.print(Miau!)
}
}
class Cainele extends Animal{
17

//polimorfism
System.out.print(Ham!)
}
}
n exemplul de mai sus s-au prezentat o ierarhie de clase ce cuprinde: o clas de
baz Animal i dou clase derivate Pisica i Cinele. Clasa de baz conine o variabil
i dou metode. Toi aceti membrii sunt disponibili i n subclase (excepie fac
variabilele si metodele declarate private n clasa de baz), ei nu mai trebuiesc nc
odat declarai n acestea. Faptul c subclasele primesc membrii clasei de baz
reprezint esena motenirii.
Prima metod este rescris diferit n fiecare din subclase. Prin urmare, atunci
cnd se utilizeaz metoda chemare cele dou tipuri de obiecte rspund, n caz c le
este foame, n mod diferit: Pisica cu miau, cinele cu ham. Aceast proprietate a
subclaselor de a putea suprancrca metode ale clasei de baz se numete
polimorfism. Teoretic, polimorfismul se poate aplica att n cazul metodelor, cat i al
variabilelor, ns aplicaii practice concrete exist doar pentru primele.
Dac n anumite situaii este dorit utilizarea metodei din clasa de baz n locul
celei din clasa derivat se apeleaz la cuvntul cheie super.
super.nume_metod(lista_parametrii)
Se poate, de exemplu, modifica funcia spune() din subclasa Pisica astfel:
class Pisica extends Animal{
private boolean Pisica_minune;
if(pisica_minune) super.spune();
else System.out.print(Miau!);
}
}
Specificatorul super se poate, n principiu, folosi i pentru variabilele
membre, dar acest lucru nu este utilizat n programe deoarece, de obicei, variabilele
nu se declar nc odat n clasele derivate.
n primul exemplu din acest paragraf metoda spune() din clasa Animal nu se
18

utilizeaz niciodat efectiv n program. Ea este doar un model abstract ce servete ca
baz pentru metodele din subclase.
n aceast situaie metoda se declar abstract utiliznd sintaxa urmtoare:
[specificator acces] abstract void nume_metod ();
Dac ntr-o clas exist cel puin o metod abstract, atunci toat clasa trebuie
declarat abstract:
[specificator_acces] abstract class nume_clasa [extends clasa_de _baz]{
[declaraii funcii]
}
Prin urmare, clasa Animal se poate declara ca fiind abstract:
abstract class Animal {
protected boolean foame = true;
public abstract void spune()
public void chemare(){
if (foame) spune();
}
}
n cazul n care, din diverse motive, programatorul dorete s nu permit crearea
de clase derivate ale unei anumite clase, la declararea acesteia va folosi specificatorul
final. Sintaxa declaraiei devine:
[specificator_acces] final class nume_clasa [extends baza]{
[declaraii funcii]
}
Dac trebuie interzis suprancrcarea prin polimorfism n subclase a unei
metode din clasa de baz atunci aceast metod se declar final:
[specif_acces] final tip_val_return nume_metod (parametrii);
n limbajele obiectuale structurile sunt transformate n arhitecturi mai complexe
care, prin includerea funciilor membre, devin clase i reprezint prototipul obiectelor,
elementele constitutive de baz al programelor orientate pe obiect.
19

O clas conine n general dou feluri de elemente: date membre, de obicei
protejate fa de exterior i funcii membre,
care au acces i proceseaz datele
membre. Funciile membre sunt definite n interiorul clasei. Datele membre sunt
variabilele declarate n interiorul clasei i sunt disponibile n interiorul acesteia pentru
toate funciile clasei. Aceast proprietate a claselor se numete ncapsulare.
n limbajul Java exist posibilitatea de a defini mai multe funcii care sa aib
unul i acelai nume, dar o list de argumente diferit. Aceast proprietate se numete
suprancrcarea funciilor.
Variabilele statice sunt utilizate atunci cnd este necesar existena unei
variabile comune pentru toate obiectele care s-au construit din clasa respectiv.
Metodele statice sunt disponibile i n situaia n care nu s-a construit nici un obiect
din clasa n care au fost declarate.
Dac, n anumite situaii, este dorit utilizarea metodei din clasa de baz n locul
celei din clasa derivat se apeleaz la cuvntul cheie super. Dac, ntr-o clas exist
cel puin o metod abstract, atunci toat clasa trebuie declarat abstract. n cazul n
care, din diverse motive, programatorul dorete s nu permit crearea de clase
derivate ale unei anumite clase, la declararea acesteia va folosi specificatorul final.
Constructorul unei clase este metoda apelat de fiecare dat cnd se creeaz un
obiect din acea clas. Constructorul are ntotdeauna acelai nume cu clasa, iar sintaxa
lui este identic cu aceea a unei metode oarecare.
Clasa Data, care a fost folosit anterior pentru exemplificare, este rescris aici i
completat cu un constructor:
class Data{
protected int ziua;
protected int luna;
protected int anul;
public Data(int a, int b, int c) {
ziua = a;
luna = b;
anul = c;
}
20

public void print_it(){
System.out.println(data.ziua, data.luna, data.anul);
}
}
Constructorii nu au tip pentru variabila returnat. Ei transform structura
abstract a claselor n elemente cu caracteristici clar definite, obiectele.
n Java, ca i n C++, instanierea se face n programul principal cu instruciunea
new folosind sintaxa:
nume_clas nume_obiect = new constructor;
Adic, pentru clasa Data:
Data zi_nat=new Data (01,12,1918)
n cazul n care programatorul nu scrie un constructor, calculatorul creeaz un
constructor implicit. Din motive de control al funcionrii se recomand ca s nu se
omit niciodat scrierea constructorului.
Pan acum s-a discutat n principal despre clase, iar noiunea de obiectele a fost
tratat doar marginal. n acest paragraf, dup ce principalele chestiuni legate de clase
au fost discutate i lmurite anterior, se va analiza n detaliu problematica obiectelor.
Obiectele reprezint, aa cum s-a specificat anterior, instane ale claselor, adic
materializri ale acestora. Atunci cnd se creeaz un obiect se fac urmtoarele
operaiuni:
se aloc spaiu n memorie pentru variabile membre;
se iniializeaz variabilele membre.
Crearea obiectelor se face cu instruciunea new:

nume_clas nume_obiect;
//declararea obiectului
nume_obiect = new constructor;//iniializarea obiectului

sau n varianta comprimat:
nume_clas nume_obiect = new constructor;
De exemplu pentru clasa:
class Alfa{
private int a;
21

public Alfa(int x){
//constructor Alfa
a=x;
}
public print_it(){
System.out.println(Alfa.a);
}
}
Instanierea obiectului unAlfa se face cu propoziia:
Alfa unAlfa = new Alfa(5)
//copia membrului a din obiectul

//unAlfa are valoarea 5
n expresiile de mai sus, nume_obiect este o referin la obiectul nou creat,

noiune relativ similar cu pointerii din C i C++, n sensul ca funcioneaz ca un
indicator. Referinele pot fi folosite pentru asignri i comparri, dar spre deosebire de
pointeri nu pot sa fie operanzi n operaii aritmetice.
Operatorii utilizabili cu referinele sunt:
testul de egalitate = =;
testul de inegalitate !=;
testul de apartenen la o clas instanceof.
Un exemplu de utilizare al acestei instruciuni este:

if (unObiect instanceof O_clas){
System.out.print(unObiect este instana din O_clas);
}
else System.out.print(unObiect nu este obiect O_clas);
Aa cum s-a artat n paragrafele anterioare, referirile n program la datele
membre i metodele membre ale unui obiect se fac respectnd regulile de mai jos. n
cazul datelor membre:
nume_obiect.dat_membr
iar n cazul metodelor membre:
nume_obiect.metod_membr(parametrii)
Limbajul Java pune la dispoziia utilizatorilor o variabil special read-only
22

(poate fi doar citit nu i modificat), care conine o referin la obiectul curent
numit this. Aceast variabil se poate utiliza pentru a transmite referina la un
obiect ntr-o metod din alt obiect.
O utilizare simpl a variabilei this este diferenierea ntre variabilele locale i
date membre avnd acelai nume.
class Alfa{
int gama;
alte variabile membre ale clasei Alfa
Alfa(gama){
//constructor Alfa
this.gama=gama;
//this indic variabila membru
alte propoziii ale constructorului

}
alte metode ale clasei Alfa
}
Variabila this este de asemenea utilizat n cazul legturilor ncruciate ntre
clase, precum cele din exemplul de mai jos:
class Alfa{
Beta obiect_beta;
Alfa(Beta obiect_beta){
//constructor Alfa
alt_obiect_beta=obiect_beta;
}
alte metode ale clasei Alfa
}
class Beta{
Alfa obiect_alfa;
Beta (){
//constructor Beta
un_obiect_alfa=new Alfa(this);
}
alte metode ale clasei Beta
}
n acest exemplu la crearea unui obiect instan a clasei Beta cu ajutorul
23

constructorului Beta() se instaniaz un_obiect_alfa i se transmite prin variabila
this o referin a obiectului creat cu Beta() ctre constructorul Alfa(). n programele
complexe se utilizeaz frecvent aceast tehnic de legare a unor obiecte aparinnd
unor clase diferite.
n general, valoarea unei referine la un obiect nu este cunoscut programului.
Aceast valoare este asignat unor variabile sau este transmis unor metode, dar nu
este utilizat de fapt ca o variabil obinuit. O excepia de la aceast regul este
situaia n care se folosete variabila null. Ea poate fi asignat oricrei referine la
un obiect, iar unele metode returneaz null pentru a arta c spaiul necesar unui
obiect nu a putut fi alocat.
Se poate, de asemenea, utiliza null pentru a testa dac un anumit obiect exist
sau nu:
if (unObiect!=null) {
System.out.print(unObiect exist);
}
n limbajul Java exist un numr important de clase i familii de clase
predefinite, care pot fi folosite de programatori ca atare sau ca baz pentru derivarea
unor clase fiice utilizabile n program. Orice programator, care concepe un program n
Java, va ncerca s economiseasc efort i timp utiliznd aceste clase predefinite.
Exemple de utilizare ale acestei importante faciliti se gsesc n toate programele
prezentate pn acum.
n acelai timp, n cazul n care programatorul dispune de familii de clase create
anterior de ctre el sau de ali utilizatori, va putea de asemenea sa le refoloseasc
parial sau total n noul program.
Pachetele Java sunt fiiere bibliotec ce conin clase i familii de clase
predefinite. Ele se import parial sau total n programe pentru a beneficia de clasele
coninute de ele.
Utilizarea pachetelor de clase este una dintre cele mai importante faciliti
create de tehnica programrii obiectuale.
Exist trei metode prin care se pot folosi aceste pachete:
24

aducerea ntregului pachetului n programul curent;
aducerea unei clase n programul curent;
utilizarea unei clase din pachet.
Prima metodologie se folosete atunci cnd n programul curent este necesar

utilizarea mai multor clase dintr-un anumit pachet sau a unei clase n mai multe locuri
din program. Pentru a aduce pachetul se utilizeaz cuvntul cheie import n cadrul
unei linii de cod de forma:
import nume_pachet
//importul ntregului pachet
A doua variant este recomandat n situaia utilizrii multiple a unei singure

clase din pachet n cadrul programului curent. Clasa se aduce cu:
import nume_pachet.nume_clasa //importul unei singure clase
A treia cale este recomandat pentru situaiile cnd este necesar utilizarea unei
singure clase ntr-o singur linie de program sau n puine situaii. Sintaxa de
declarare a unui obiect al unei clase din pachet este:
nume_calificat_clas nume_obiect;
De exemplu, pentru a folosi mai multe clase din java.util trebuie scris chiar la
nceputul programului:
import java.util;
iar, dac se dorete utilizarea unei singure clase, spre exemplu Date, tot la
nceputul programului se scrie:
import java.util.Date;
ntr-un program unde este necesar un obiect din clasa Date din pachetul
java.util, trebuie deci procedat ca mai jos:
java.util.Date o_Dat = new java.util.Date(); //instaniere obiect
System.out.print(o_Dat);
n exemplul de mai sus este redat instanierea obiectului o_Dat din clasa Date.
Dup cum se vede, clasa Date este scris cu numele ei calificat, adic inclusiv numele
pachetului de fiecare dat cnd ea apare.
25

2.5. Principalele pachete din JDK

Java Development Kit (JDK) conine cincisprezece pachete de clase utilizabile
n programe. Cele mai folosite sunt ns clasele care aparin sub-setului Applet API.
Aceste clase, utilizate n aplicaiile pentru paginile HTML pe Internet (applet-uri),
sunt:
java.lang, clase utilitare ale limbajului (Integer, Character, etc.);
java.util, clase utilitare(Vector, Hashtabel, Math, etc.);
java.applet; clasele de baz pentru crearea applet-urilor;
java.awt,clase pentru interfaa de utilizator;
java.io, clase pentru intrare/ieire;
java.net, clase pentru lucrul n reea.
Precum s-a precizat anterior, importul pachetului java.lang n programe este

fcut automat de mediul JDK. Java.lang conine clasa System clasa Thread (pentru
multitasking) i un numr de clase care implementeaz tipurile de variabile prezentate
n lecia anterioar: Pachetul java.util conine de asemenea clase ce implementeaz
tipuri de date.
Clasa java.applet conine clasele i interfeele necesare pentru implementarea
aplicaiilor Java n paginile HTML pe Internet, astfel nct s poat s interacioneze
cu browser-ele. Cea mai important component a pachetului este clasa
java.applet.Applet, subclas a clasei java.awt.Panel. Aa cum s-a putut observa din
programele prezentate la sfritul leciilor anterioare, java.applet.Applet reprezint
clasa de baz a tuturor applet-urilor. Detalii privind aceast clas i celelalte
componente ale pachetului se vor prezenta n Lecia nr. 12 Aplicaii Java n paginile
web
Pachetul de programe java.io conine clasele de baz pentru implementarea
operaiilor de intrare ieire n mediul Java. Dispozitivele standard de intrarea i
respectiv ieire sunt tastatura i respectiv monitorul. Clasele utilizate pentru execuia
acestor transferuri sunt ImputStream i OutputStream. Detalii privind operaiunile I/O
n limbajul java se vor prezenta n Lecia nr. 8 Comunicaii n Java.
26

Limbajul Java ofer o serie de faciliti suplimentare la accesarea reelei Internet
i anume, nu doar obinerea unor informaii clasice, ci i programe executabile.
Aceast
extensie
este
posibil
datorit
pachetului
java.net,
care
permite
implementarea unei arhitecturi capabil s acceseze programe i date n mod dinamic.

Clasele de baz ofer funciile necesare pentru realizarea conexiunilor i
protocoalelelor de comunicaie pentru transferul fluxurilor de date la i de la
calculatorul gazd.
Pachetul java.awt (Another Windows Toolkit) conine clase utile n realizarea
dialogului n cadrul ferestrelor din mediul Windows, precum i a graficii pe ecranul
monitorului. Detalii suplimentare despre aceste clase se prezint n Lecia nr. 13
Grafica n java.
Aa cum s-a subliniat anterior, unul din avantajele importante ale limbajelor
obiectuale este refolosirea unor clase create anterior de utilizator. n cazul limbajului
Java acest lucru presupune organizarea claselor n pachete de utilizator.
Pachetele de utilizator sunt acele fiiere bibliotec ce conin clase i familii de
clase predefinite, altele dect cele standardizate n limbajul Java i n mediile de
programare Java.
Un asemenea pachet de utilizator se creeaz prin scrierea unui fiier care are pe
prima linie o declaraie a numelui pachetului i, n continuare, conine declaraiile
claselor ce se conserv, pentru a putea fi ulterior folosite n diferite aplicaii.
Fiierul bibliotec se plaseaz ntr-un director, avnd acelai nume cu cel al
pachetului, subdirector al directorului n care sunt celelalte fiiere ale programului
curent. Evident, dup compilare vor apare fiiere .class coninnd fiecare cte o
clas din cele din pachet.
Sintaxa declaraiei numelui pachetului este:
package nume_pachet;
n exemplul de mai jos se schieaz structura unui fiier bibliotec, adic
declaraia i irul claselor componente ale pachetului.
package un_pachet;
public class Clasa1{
27

date i metode ale clasei
}
public class Clasa2{
}
...
public class ClasaN{
}
n fiierul programului curent utilizarea pachetului de utilizator presupune
importul acestuia n mod similar cu importul pachetelor predefinite de productorul
mediului de programare. Sintaxa este:
import nume-pachet.nume_clasa
De exemplu pentru utilizarea pachetului definit mai sus se procedeaz astfel:
import un_pachet.*; // import toate clasele pachetului
class O_clasa extends Clasa3{
date i metode ale clasei O_clasa
}
class Alta_clasa extends Clasa2{
date i metode ale clasei Alta_clasa
}
n cazul utilizrii unei singure clase din pachet se import doar aceasta:
import nume_pachet.nume_clas,
Adic dac de exemplu din pachetul prezentat n exemplul anterior se folosete
doar clasaN atunci n prima linie a programului unde este necesar aceasta se scrie:
import un_pachet.ClasaN
n faza de compilare se controleaz doar existena claselor clasa2 i clasa3 n
subdirectorul UN_PACHET al directorului programului. Realizarea legturilor
propriu-zise (link-editare) se face n etapa rulrii. Aceast proprietate a programelor
Java se numete legare dinamic (engl. Dynamic binding) i d caracterul dinamic al
acestui limbaj de programare.
28

Evident, buna funcionare a programului este condiionat de rmnerea
fiierelor .class n subdirectorul UN_PACHET. Deci, aceste fiiere nu trebuiesc
mutate redenumite sau terse.
Odat creat, un pachet de utilizator poate fi folosit n orice program prin simpla
copiere a directorului corespunztor lui ca subdirector al directorului proiectului
(programului) i scriere comenzii de import al pachetului ca mai sus.
n limbajul Java clasele utile n realizarea unor interfee de utilizator n cadrul
ferestrelor din mediul Windows precum i a graficii pe ecranul monitorului sunt
grupate n pachetul java.awt (Abstract Window Toolkit).
Faptul c n java clasele de dialog sunt nrudite cu cele pentru desenare este o
consecin a modului actual de funcionare a mediilor Windows, MacIntosh, etc. unde
interfeele de utilizator au n compunerea lor numeroase elemente grafice (butoane,
bare de derulare, casete de opiuni).
Pachetul java.awt este destul de vast, cuprinznd peste aizeci de clase i
interfee. ntre acestea cele mai importante sunt:
java.awt.Graphics, clas pentru grafic pe ecran;
java.awt.Color, permite implementarea culorilor;
java.awt.Font, implementarea diferitelor tipuri de caractere;
java.awt.Event, trateaz evenimentele de mouse i tastatur;
java.awt.MediaTraker, implementare animaie n applet-uri;
java.awt.AWTExceptions, trateaz excepiile la rulare;
java.awt.AWTError, trateaz erorile.
Alturi de clasele de uz general de mai sus exist un numr de clase particulare

ce implementeaz elemente concrete (ferestre, butoane, casete de dialog, etc.). Aceste
clase vor fi prezentate mai pe larg n paragraful Interfee de utilizator. De asemenea,
n pachet sunt i o serie de biblioteci suplimentare precum:
java.awt.image, care conine clase pentru manipularea i procesarea

imaginilor,
java.awt.peer, care conine clase pentru crearea interfeelor native de
29

utilizator.
2.6 Interfeele grafice de utilizator n Java

Grafica pe ecranul monitorului se realizeaz n limbajul Java prin metodele
componente ale clasei Graphics, component a pachetului java.awt. Utilizarea lor are
ca rezultat desenarea principalelor figuri geometrice la coordonatele i cu
dimensiunile precizate prin intermediul valorilor din listele de parametrii.
Cele mai des utilizate dintre aceste metode sunt urmtoarele:
public void drawLine(int x0,int y0,int x,int y)
deseneaz o linie cu originea n punctul de coordonate (x0,y0) i captul n
punctul (x,y). Desenarea se face n culoarea curent selectat, iar coordonatele sunt
relative la colul stnga sus al applet-ului.
public void drawRect(int x,int y,int lat,int lung)
deseneaz conturul unui dreptunghi cu colul din stnga sus n punctul de
coordonate (x,y), avnd dimensiunile lat i respectiv lung.
public void fillRect(int x,int y,int lat,int lung)
deseneaz un dreptunghi similar cu cel anterior, dar avnd interiorul colorat n
culoarea curent.
public void clearRect(int x,int y,int lat,int lung)
terge dreptunghiul desenat anterior prin umplerea spaiului aferent acestuia cu
culoarea fondului.
public void drawRoundRect(int x,int y,int lat,int lung)
public void fillRoundRect(int x,int y,int lat,int lung)
sunt asemntoare cu metodele drawRect() i fillRect() ns, dreptunghiurile
desenate au coluri rotunjite.
public void draw3DRect(int x,int y,int lat,int lung,boolean a)
public void fill3DRect(int x, int y, int lat, int lung, boolean a)
deseneaz dreptunghiuri tridimensionale, nlimea fiind dat de parametrul
a care specific prin valoarea sa scoaterea n eviden a obiectului (true = culoare
strlucitoare, false = culoare ntunecat).
30

public void drawOval(int x,int y,int lat,int lung)
public void fillOval(int x,int y,int lat,int lung)
prima metod deseneaz conturul unei elipse nscrise n dreptunghiul determinat
de valorile din lista de parametrii, iar cea de a doua produce o elipsa umplut avnd
culoarea curent i dimensiunile identice cu cea de mai sus.
public void drawArc(int x,int y,int lat,int lung,int u0,int u)
public void fillArc(int x,int y,int lat,int lung)
deseneaz un contur i respectiv un arc plin delimitat de dreptunghiul
determinat de primele patru mrimi din lista de parametrii. Parametrul u 0 reprezint
unghiul de start iar u extensia unghiular a arcului.
public drawString(String s,int x,int y)
afieaz irul s ncepnd cu punctul de coordonate (x,y).
public copyArrea (int x0,int y0,int lat,int lung,int x1,int y1)
copiaz obiectele din zona delimitat de (x,y,lat,lung) ntr-o zon cu
coordonatele (x0,y0,lat,lung).
Realizarea unor desene complexe n interiorul applet-urilor presupune
construirea unor combinaii ale obiectelor simple rezultate din utilizarea metodelor de
mai sus.
Utilizarea acestor funcii se face prin apelarea lor ca metode ale unui obiect
grafic instaniat anterior:
Graphics g;
g.fill3Drect(10,10,100,100,true);
g.drawOval(20,20,80,80);
g.drawString(Desen, 45, 45);
Setarea culorii curente de lucru se face cu metoda:
public void setColor(Color col)
unde col poate fi o culoare din paleta standard:
public final static Color white
//alb
public final static Color lightgray
// gri deschis
public final static Color gray
//gri
public final static Color darkgray
//gri nchis
31

public final static Color black
//negru
public final static Color red
//rou
public final static Color pink
//roz
public final static Color orange
//portocaliu
public final static Color yellow
//galben
public final static Color green
//verde
public final static Color magenta
//violet
public final static Color cyan
//azuriu
public final static Color blue
//albastru
sau o nuan definit de programator prin combinaia celor trei culori fundamentale:
Color nuan = new Color(int rou,int verde,int albastru);
Gama de variaie pentru cei trei ntregi din lista de parametrii este 0...256
deoarece fiecare culoare este codat pe cte trei octei, cte unul pentru fiecare
component fundamental.
Deci, pentru a seta culoarea curent de desenare n exemplul anterior, dup
declararea obiectului g, se scrie o linie de cod de forma:
g.setColor(Color.blue);
Alt variant este crearea unei culori noi culoarea_mea:
Color.culoare = new Color(120, 40, 85)
care apoi se poate folosi ca si culoare curent:
g.setColor(culoarea_mea);
Alegerea tipului de caractere cu care se scriu mesajele pe ecran se face cu
metoda:
public void setFont (Font tip_caracter)
Tipurile de caractere disponibile sunt:
Dialog;
Helvetica;
TimesRoman;
Courier;
Symbol.
32

Se poate construi un stil de scriere propriu definindu-l cu metoda:
public Font (String nume,int stil,int dimensiune)
unde nume este numele tipului de caractere, stil este:
0 pentru caractere normale (PLAIN);
1 pentru caractere ngroate (BOLD);
2 pentru caractere italice (ITALIC);
3 pentru italice ngroate (BOLD ITALIC);
iar dimensiune este mrimea literelor.

De exemplu pentru a scrie mesajul Text de prob cu caractere albastre
TimesRoman de mrimea 14 accentuate se scriu urmtoarele linii de cod:
Font f = new Font(TimesRoman, 2, 14);
g.setFont(f);
g.setColor(Color.blue);
g.drawString(Text de prob, 10, 10);
Elementele prezentate anterior permit afiarea n interiorul applet-urilor a unor
texte i desene aducnd o contribuie important la aspectul estetic al paginilor web n
care acestea exist.
Realizarea unor interfee de utilizator n java se face cu ajutorul unui set de
clase special create pentru fiecare element de dialog n parte. Cele mai importante
dintre ele sunt:
java.awt.Frame, cadru;
java.awt.Panel, implementare panel;
java.awt.Container, container;
java.awt.Button, butoane;
java.awt.ScrollBar, bare de derulare;
java.awt.Menu, meniuri;
java.awt.Choice, list derulant;
java.awt.CheckBox, casete de opiuni;
java.awt.Label, etichete;
33

java.awt.List, liste de opiuni;
java.awt.TextArea, arii de text;
java.awt.TextField, cmpuri de text.
Prin urmare, componente interfeelor de dialog sunt obiecte ale claselor

enumerate mai sus i manipularea lor este conform cu regulile aplicabile obiectelor
Java n general.
De exemplu, pentru a implementa o caset de opiuni i un buton se scriu
urmtoarele comenzi:
class O_clasa extends Applet{
private Button un_buton;
private Checkbox o_opiune;
...
public void init(){
add(o_opiune=new Checkbox("Gata!"));
add(un_buton=new Button("Aciune"));
...
}
...
}
Aciunea comandat de acionarea unui element de dialog este introdus n
program sub forma unui obiect al clasei Event i este tratat cu metoda:
public boolean handleEvent(Event e)
a clasei Component.
De exemplu aciunile asociate apsrii butonului declarat anterior trebuie
plasate n program ntr-un bloc similar cu cel de mai jos
public boolean handleEvent(Event e){
switch(e.id){
case Event.ACTION_EVENT:{
if(("Aciune").equals(e.arg)){
Aciuni asociate apsrii butonului;
34

return true;
}
}
default: return false;
}
}
Dup cum se poate vedea n exemplul anterior, pentru fiecare din componentele,
a cror manipulare comand aciuni sau selecii, se include n program cte un bloc de
decizie cuprinznd un set de comparaii cu argumentul arg al obiectului instaniat
din clasa Event. n aceste comparaii cu arg intr ca prim termen:
Numele butonului (String) pentru butoane;
Starea casetei (Boolean) pentru casetele de confirmare;
Poziia aleas (String) pentru listele derulante;
Selecia aleas (String) pentru listele de opiuni;
Textul scris (String) pentru TextField.
Pentru a trata o comand a utilizatorului provenit de la tastatur se apeleaz

metodele:
public boolean keyDown(Event e,int cod)
care declaneaz evenimentul e atunci cnd tasta cu codul numeric cod este
apsat i:
public boolean keyUp(Event e,int cod)
care acioneaz n cazul eliberrii tastei.
Controlul alinierii componentelor ntr-o interfa se realizeaz utiliznd clasa
FlowLayout. Constructorii acestei clase:
public FlowLayout(int aliniere)
public FlowLayout(int aliniere,int spaiu_V,int spatiu_H)
permit ordonarea elementelor de dialog pstrnd pe orizontal i vertical
pauzele spaiu_V i spaiu_H. Parametrul aliniere poate fi:
public final static int CENTER (aliniere la centru);
public final static int LEFT (aliniere la stnga);
35

public final static int RIGHT (aliniere la dreapta).
n Java imaginile sunt obiecte ale clasei Image. Prin urmare, toate procedurile
de manipulare ale imaginilor, pornind de la achiziie i ncheind cu afiarea i
prelucrarea, se desfoar conform tipologiei generale de lucru cu obiectele. Pentru
toate aceste operaii, n clasele Applet i Graphics s-au definit metode, care permit
executarea lor n cadrul applet-urilor.
Preluarea unei imagini de la o adres oarecare ntr-un obiect Image se face cu
metoda component a clasei Applet:
public Image getImage(URL a,String nume_imagine)
similar cu cazul sunetelor prezentat n paragraful anterior adresa URL se obine cu
metoda:
public URL getDocumentBase()
Prin urmare instanierea unui obiect imagine se face cu o linie de cod de forma
Image o_imagine=getImage(getDocumentBase(),"imag.gif");
Afiarea unei imagini ntr-un applet se face cu metoda component a clasei
Graphics:
public void drawImage(Image im,int x,int y,ImageObserver obs)
n care im este obiectul imagine, (x,y) coordonatele colului stnga sus, iar obs
este component a interfeei ImageObserver implementat de clasa Component. De
obicei acest parametru este nlocuit cu this.
Afiarea imaginii transferat n exemplul anterior la coordonatele (10,10) se
face deci cu liniile de program prezentate n continuare:
Graphics g;
g.drawImage(o_imagine,10,10,this);
Applet-ul de mai sus ruleaz ntr-o pagin web similar ca form cu cele
prezentate n leciile anterioare. Pentru buna funcionare este necesar ca dimensiunile
width i hight declarate n fiierul HTML s fie alese suficient de mari, nct
imaginea i celelalte elemente s ncap n spaiul rezultat.
Sunetele sunt preluate i prelucrate n limbajul Java sub form de obiecte
AudioClip, adic obiecte ale claselor ce implementeaz interfaa AudioClip. Metodele
36

destinate manipulrii fiierelor sonore sunt componente ale clasei Applet sau ale
interfeei AudioClip.
Pentru a ncrca un fiier audio .au se utilizeaz metoda component a clasei
Applet:
public AudioClip getAudioClip(URL a, String nume_sunet);
unde a este un obiect al clasei URL adres n reea cuprinznd inclusiv relaii
despre protocolul de comunicaii utilizat i despre calculatorul gazd.
Aceast adres poate fi obinut cu funcia
public URL getDocumentBase()
De exemplu:
audio=getAudioClip(getDocumentBase(),"sunet.au");
Ascultarea sunetului cuprins n pagina web se comand cu metoda:
public void play (URL url, String nume_sunet)
a clasei Applet. Adic pentru fiierul sonor din exemplul anterior comanda de pornire
este:
play(getDocumentBase(),"sunet.au");
Alt variant de manipulare a sunetelor este utilizarea metodelor interfeei
AudioClip:
public abstract void loop():clipul este ascultat n bucl;
public abstract void play(): clipul este ascultat o singur dat;
public abstract void stop():clipul este oprit;
Un exemplu de program care cnt clipul audio celine.au plasat n acelai

director cu fiierul surs este prezentat n Figura 14.1.
n practic paginile web ce conin sunete cuprind pe lng elemente de dialog i
comand (interfa de utilizator), imagini ce ilustreaz grafic sunetele din fiierele
.au prezentate.
Programele n limbajul Java destinate realizrii efectului de animaie afieaz la
intervale regulate cadre de imagine n care poziiile relative ale unor obiecte sau
poriuni ale acestora variaz progresiv, astfel nct s se creeze senzaia de micare.
n practic se utilizeaz dou tipuri de animaie:
37

afiarea aceleiai imagini n care un obiect sau o parte a unui obiect se

mic,
afiarea unei succesiuni de cadre diferite.
Prima variant de animaie permite ca utiliznd o singur imagine i un program

de modelare 3D s se simuleze micarea unui obiect sau a unei poriuni din acesta n
spaiul interior al acesteia. Practic, imaginea devine o scen n cadrul creia obiectul
de obicei suprapus se deplaseaz fie liber fie controlat de utilizator (de exemplu, prin
micarea mouse-ului)
A doua variant presupune achiziionarea n prealabil a setului de imagini ce
prezint micarea elementelor componente. Aceste imagini trebuie afiate cu o
ritmicitate suficient de mare (peste 20 cadre pe minut) astfel nct datorit remanenei
pe retina ochiului uman se creeaz iluzia micrii continue. Atunci cnd aplicaia nu
necesit obligatoriu obinerea senzaiei de micare continu pentru a economisi
resursele sistemului se accept o ritmicitate mai redus i rezult o micare sacadat
(efect stroboscopic).
ncrcarea cadrelor de imagine ce compun secvena se face prin utilizarea
repetat (ntr-un ciclu for) a metodei getImage() prezentat n paragraful anterior.
Pentru a fi ulterior afiate secvenial ele se plaseaz n ordine ntr-un obiect al clasei
MediaTracker din pachetul java.awt cu metoda:
public void addImage(Image nume_imagine,int prioritate)
unde, pentru toate imaginile unei secvene, prioritatea se ia aceiai.
De exemplu ncrcarea unui numr de N cadre de imagine imag[i] ntr-un
fir_animaie se poate realiza astfel:
MediaTracker fir_animaie = new MediaTracker(this);
for(i = 0; i < N; i ++){
o_imagine = getImage(getDocumentBase(),imag[i]);
fir_animaie.addImage(o_imagine,0);
}
Dup ce toate cadrele au fost ncrcate, pornirea animaiei se face cu metoda:
public void start()
38

Iar afiarea acestor cadre este realizat cu metoda drawImage() utilizat la fel ca
pentru imaginile statice.
Adic pentru setul de imagini din exemplul anterior pornirea se face cu linia de
program:
fir_animaie.start();
iar afiajul cu:
g.drawImage(fir_animaie,0,0,this);
Pe Internet exist cteva site-uri care conin applet-uri animate concepute astfel
nct s permit utilizatorului s-i utilizeze propria secven de cadre de imagine. Ele
sunt adesea preferate deoarece sunt foarte performante i extrem de uor de utilizat.
Sunetele sunt preluate i prelucrate n limbajul Java sub form de obiecte
AudioClip. Metodele destinate manipulrii fiierelor sonore sunt componente ale
clasei Applet sau ale interfeei AudioClip
Imaginile sunt obiecte ale clasei Image. Prin urmare toate procedurile de
manipulare ale imaginilor, pornind de la achiziie i ncheind cu afiarea i
prelucrarea, se desfoar conform tipologiei generale de lucru cu obiectele. Pentru
toate aceste operaii, n clasele Applet i Graphics s-au definit metode, care permit
executarea lor n cadrul applet-urilor.
Programele n limbajul Java destinate realizrii efectului de animaie afieaz la
intervale regulate cadre de imagine n care poziiile relative ale unor obiecte sau
poriuni ale acestora variaz progresiv astfel nct s se creeze senzaia de micare.
Pe Internet exist cteva site-uri care conin applet-uri animate concepute astfel
nct, s permit utilizatorului s-i utilizeze propria secven de cadre de imagine.
39

3. APLICAIA AVIOANE
3.1 Soluia de implementare

Aplicaia Avioane este un Joc care ilustreaz un algoritm euristic de cutare i
are un scop didactic. Pentru simplificare s-a adoptat soluia competiiei dintre operator
i un juctor automat emulat de calculator. Pe baza acestei soluii iniiale se poate
ulterior implementa un joc n reea n care s se confrunte doi operatori umani rulnd
pe dou calculatoare diferite.
Aplicaia a fost implementat n limbajul Java deoarece acesta este independent
de platform i permite prin urmare rularea cvasi-identic pe oricare dintre sistemele
de calcul folosite curent.
Programarea orientat pe obiecte este o opiune mai avantajoas dect
programarea procedural, pentru c ferestrele, meniurile, interfeele grafice de
utilizator sunt mult mai uor de implementat prin utilizarea unor clase i familii de
clase predefinite.
Limbajul Java2 versiunea jdk 1.5.0_05 are implementate att familia de clase
javax.swing.* ct i java.awt.*, pachete care permit faciliti suplimentare pentru
introducerea unor interfee grafice de utilizator prefabricate pentru ferestrele de
dialog cu utilizatorul.
Scrierea i testarea programului s-a fcut n Netbeans 4.1 care permite utilizarea
scrierea programelor sub form de proiect. Acest fapt permite compilarea i rularea
mai multor fiiere surs din cadrul proiectului. Aceast form de lucru a permis
separarea sursei pe un numr de patru fiiere care conin cele patru clase ale aplicaiei
40

Avioane.
Jocul implementat are o funcionare corect i eficient, deoarece codul scris
este compact avnd avantajul c soluioneaz toate cerinele din specificaie ntr-un
mod direct i corect.
Posibilitile de dezvoltare ulterioar sunt principial posibile prin ataarea de noi
module funcionale sub forma unor clase sau pachete de clase Java.
3.2 Structura programului
Programul este structurat pe patru fiiere cuprinznd fiecare dintre ele cte o
clas public, deci avnd acelai nume cu fiierul.
Aceste fiiere sunt:
1. Avioane.java clasa Avioane (clasa principal a programului)
2. Avion.java clasa Avion
3. AvioaneFrame.java clasa AvioaneFrame
4. Ptrat.java clasa Ptrat
5. MyMap.java clasa MyMap
Clasa principal Avion cuprinde doar partea de instaniere i afiare a aplicaiei
Avioane. Structura sa conine doar funcia main() aa cum se vede n listingul de mai
jos.
public class Avioane {
public static void main(String[] args) {
AvioaneFrame frame = new AvioaneFrame();
frame.setVisible(true);
}
}
// clasa principala a aplicatiei

// instantiere fereastra aplicatie
// afisare fereastra
Clasa Avion este responsabil de desenarea i operarea cu avioanele pe care

juctorul le are la dispoziie. Aceast clas are structura reprezentat n listingul de
mai jos:
public class avion{
// date membre
// clasa patrat utilizata pantru a defini capul avionului
public patrat cap;
41

public int tip=0;
public patrat[] all = new patrat[10];
// tipul avionului = dispunerea sa spaial

// instrument desenare
// metode membre
// metoda constructor cu care se instaniaz avioanele
// tiprirre rezultate n fereastra consol
public avion(int _x, int _y, int _tip){...}

void print (){...}
}
Clasa AvioaneFrame cuprinde partea de implementare a structurii ferestrei i

toate elementele ce se afieaz n cadrul jocului. Dei aceast clas nu este (formal)
clasa principal, ea este n fapt locul unde se creeaz cadrul i se desfoar ntreaga
competiie dintre juctor i calculator. Listingul de mai jos conine scheletul acestei
clase.
public class AvioaneFrame extends JFrame {
// date membre
//coordonate
// identificatori avion
// coordonate mouse
// mouse apasat
// harta computer
// harta player
private int x;y;

private int tipavion, nrAvion=0;
private int mouseX, mouseY;
private boolean mouseclicked = false;
myMap computer = new myMap();
myMap player = new myMap();
...
Vector avioane = new Vector(3);
...
// vectori date
// metode membre
// constructor
// tratare evenimente de mouse
// metoda paint()
// lovitura operator
// lovitura computerului
// generare harta dispunerii avioanelor computerului
// inchiderea ferestrei aplicatiei
public AvioaneFrame(){...}
public void actionPerformed(ActionEvent e) {...}
public void paint(Graphics g){...}
private boolean loveste_player(){...}
private void loveste_computer(){...}
public void generareAImap(){...}
protected void windowClosed() {...}
}
Clasa MyMap conine datele i metodele membre necesare pentru a implementa

hrile de dispunere a avioanelor operatorului uman i respectiv juctorului automat
emulat de calculator.
public class myMap{
// matrice ce modeleaz harta
public int map[][] = new int[11][11];
public myMap(){...}
public boolean aseazaAvion(int x, int y, int tip){...}
public void print(){...}
// metode membre
// constructor
// pozitionare avion
// desenare avion
Clasa Ptrat este cea care definete unitatea de msur i n acelai timp
componenta de construcie a avioanelor.
public class patrat{
// date membre
// coordonate
public int x=0 ;

public int y=0 ;
public int tip=0;
// 1 - patratul nu este lovit 0 - patratul este lovit

// metode membre
42

public patrat(int _x, int _y, int _tip){...}
public patrat(){...}
public void print(){...}
// constructorul I clasei patrat

// constructorul II al clasei patrat
// tiprire la consol
Listingul complet al tuturor acestor clase este furnizat n Anexa de la sfritul

acestui material.
3.3 Regulile i funcionarea aplicaiei

Fereastra principal a aplicaiei este prezentat n figura de mai jos. Aa cum se
poate observa ea cuprinde:
a.
hrile de distribuie a avioanelor celor doi juctori harta juctorului

uman este la vedere cealalt este afiat fr avioane;
b.
cele patru tipuri de avioane ce se pot plasa pe hart;
c.
butonul start
Operatorul uman selecteaz pe rnd tipul de avioanele dorite i le plaseaz pe
43

harta sa.
Rezult o formul n genul celei din figura de mai jos si jocul poate porni prin
apsarea butonului Start.
Calculatorul genereaz automat o harta a sa aleatoare, hart care evident

rmne secret pentru operatorul uman.
44

n cursul desfurrii jocului calculatorul i operatorul uman lovesc pe rnd

cte un ptrat din harta vecinului. Pentru punct ochit se afieaz culoarea roie pentru
ratare se afieaz verde.
Doborrea unui avion se face ochind pe rnd toate ptratele sale componente.
Un avion lovit n cap este considerat dobort n ntregime i se coloreaz n rou
pentru punctele ochite i negru pentru restul.
Ctigtorul este declarat cel care, primul, distruge complet toate avioanele
adversarului.
45

4. CONCLUZII
Aplicaia Avioane este un Joc cu scop didactic care ilustreaz o cutare bazat
pe un algoritm euristic. Avnd n vedere specificaia iniial a proiectului s-a adoptat
soluia simpl a unei btlii ntre un operator uman i un competitor artificial
reprezentnd calculatorul.
O dezvoltare ulterioar a acestui joc ar putea fi introducerea posibilitii ca el s
fie jucat n reea de doi juctori umani care s ruleze programul pe calculatoare
diferite. Pentru acest lucru trebuie implementat n program un server i doi clieni
separai corespunztori celor doi competitori.
Aplicaia a fost implementat n limbajul Java deoarece acesta este independent
de platform i permite prin urmare rularea cvasi-identic pe oricare dintre sistemele
de calcul folosite curent.
Programarea orientat pe obiecte este o opiune mai avantajoas dect
programarea procedural, pentru c ferestrele, meniurile, interfeele grafice de
utilizator sunt mult mai uor de implementat prin utilizarea unor clase i familii de
clase predefinite.
Scrierea i testarea programului s-a fcut n Netbeans 4.1 care permite utilizarea
scrierea programelor sub form de proiect. Acest fapt permite compilarea i rularea
mai multor fiiere surs din cadrul proiectului. Aceast form de lucru a permis
separarea sursei pe un numr de patru fiiere care conin cele patru clase ale aplicaiei
Avioane.
Jocul implementat are o funcionare corect i eficient, deoarece codul scris
este compact avnd avantajul c soluioneaz toate cerinele din specificaie ntr-un
mod direct i corect.
46

Posibilitile de dezvoltare ulterioar sunt principial posibile prin ataarea de noi
module funcionale sub forma unor clase sau pachete de clase Java. Dintre aceste
posibile dezvoltri menionez introducerea unor interfee grafice de interaciune cu
operatorul GUI mai elaborate, a unui Help on line mai elaborat, a unor meniuri care
de exemplu s permit Undo la poziionare, etc.
47

4. BIBLIOGRAFIE
1.
2.
3.
4.
5.
Chan M.C., Griffith W.S., Iasi F.A., 1001 de secrete Java ed

Teora Bucureti 2000
Lemay L., Cadenhead R., Java 2 fr profesor ed. Teora
Bucureti 2001
Lalani S., Jamsa K., Java Biblioteca programatorului, ed All
Timioara 1977
Lacrm L.D., Programarea orientat pe obiecte ed. Helicon
Timioara 1999
Norton P., Stanek W., Limbajul Java ed. Teora Bucureti 1997
48

ANEXA
// Fisierul Avioane.java
public class Avioane {
public static void main(String[] args) {
AvioaneFrame frame = new AvioaneFrame();
frame.setVisible(true);
}
}
// clasa principala a aplicatiei

// instantiere fereastra aplicatie
// afisare fereastra
// Fisierul avion.java
public class avion{
public patrat cap;
public int tip=0;
public patrat[] all = new patrat[10];
public avion(int _x, int _y, int _tip){
int i;
for (int j= 0; j< 10; j++ )
all[j] = new patrat();
cap = new patrat();
cap.x=_x;
cap.y=_y;
tip=_tip;
all[0].x = _x;
all[0].y = _y;
switch (_tip){
case 0:
{
all[1].x=_x-2; all[1].y=_y+1;
all[2].x=_x-1; all[2].y=_y+1;
all[3].x=_x; all[3].y=_y+1;
all[4].x=_x+1; all[4].y=_y+1;
all[5].x=_x+2; all[5].y=_y+1;
all[6].x=_x; all[6].y=_y+2;
all[7].x=_x-1; all[7].y=_y+3;
all[8].x=_x; all[8].y=_y+3;
all[9].x=_x+1; all[9].y=_y+3;
for(i=0;i<10;i++)
all[i].tip=0;
break;
}
case 1:{
all[1].x=_x-2; all[1].y=_y-1;
all[2].x=_x-1; all[2].y=_y-1;
all[3].x=_x; all[3].y=_y-1;
all[4].x=_x+1; all[4].y=_y-1;
all[5].x=_x+2; all[5].y=_y-1;
all[6].x=_x; all[6].y=_y-2;
all[7].x=_x-1; all[7].y=_y-3;
49
// avion
//
//////////
//
//////
// avion
//////
//
//////////
//

all[8].x=_x; all[8].y=_y-3;
all[9].x=_x+1; all[9].y=_y-3;
for(i=0;i<10;i++)
all[i].tip=0;
break;
}
case 2:{
// avion
all[1].x=_x-1; all[1].y=_y-2;
all[2].x=_x-1; all[2].y=_y-1;
all[3].x=_x-1; all[3].y=_y;
all[4].x=_x-1; all[4].y=_y+1;
all[5].x=_x-1; all[5].y=_y+2;
all[6].x=_x-2; all[6].y=_y;
all[7].x=_x-3; all[7].y=_y-1;
all[8].x=_x-3; all[8].y=_y;
all[9].x=_x-3; all[9].y=_y+1;
for(i=0;i<10;i++)
all[i].tip=0;
break;
}
case 3:{
// avion
all[1].x=_x+1; all[1].y=_y-2;
all[2].x=_x+1; all[2].y=_y-1;
all[3].x=_x+1; all[3].y=_y;
all[4].x=_x+1; all[4].y=_y+1;
all[5].x=_x+1; all[5].y=_y+2;
all[6].x=_x+2; all[6].y=_y;
all[7].x=_x+3; all[7].y=_y-1;
all[8].x=_x+3; all[8].y=_y;
all[9].x=_x+3; all[9].y=_y+1;
for(i=0;i<10;i++)
all[i].tip=0;
break;
//
// //
////////
// //
//
//
// //
////////
// //
//
}
}
}
public boolean isalive(){
if (cap.tip==1) return false;
if (all[1].tip==1 &&
all[2].tip==1 &&
all[3].tip==1 &&
all[4].tip==1 &&
all[5].tip==1 &&
all[6].tip==1 &&
all[7].tip==1 &&
all[8].tip==1 &&
all[9].tip==1
) return false;
return true;
}
void print (){
int i;
for(i=0;i<10;i++)
System.out.print(all[i].x+","+all[i].y+","+all[i].tip+"\n");
}
}
// Fisierul patrat.java
public class patrat{
public int x=0 ;
public int y=0 ;
public int tip=0;
// 1 - patratul nu este lovit

// 0 - patratul este lovit
public patrat(int _x, int _y, int _tip){
x=_x;
50

y=_y;
tip=_tip;
}
public patrat()
{
x=0;
y=0;
tip=0;
}
public void print(){
System.out.print("["+x+","+y+"]="+tip+"\n");
}
}
// Fisiaerul AvioaneFrame.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
public class AvioaneFrame extends JFrame {
private int x;
private int y;
private int tipavion=0;
private int nrAvion=0;
private int mouseX, mouseY;
private boolean mouseclicked = false;
myMap computer = new myMap();
myMap player = new myMap();
int playerReady=0;
private boolean start=false;
private boolean finish =false;
Vector avioane = new Vector(3);
Vector avioaneAI = new Vector(3);
Vector playerShoot = new Vector(50);
Vector compShoot = new Vector(50);
public AvioaneFrame(){
JMenuBar menuBar = new JMenuBar();
JMenu menuFile = new JMenu();
JMenuItem menuFileExit = new JMenuItem();
menuFile.setText("File");
menuFileExit.setText("Exit");
menuFileExit.addActionListener( // adauga ActionListener pentru buton
new ActionListener() {
public void actionPerformed(ActionEvent e) {
AvioaneFrame.this.windowClosed();
}
}
);
menuFile.add(menuFileExit);
menuBar.add(menuFile);
setTitle("Avioane");
setJMenuBar(menuBar);
setSize(new Dimension(600, 600));
this.setLayout (new BorderLayout());
Panel buttonPanel, drawPanel;
buttonPanel = new Panel();
JButton susButton = new JButton((Icon)new ImageIcon("sus.gif"));
JButton josButton = new JButton((Icon)new ImageIcon("jos.gif"));
JButton stButton = new JButton((Icon)new ImageIcon("stanga.gif"));
JButton drButton = new JButton((Icon)new ImageIcon("dreapta.gif"));
final JButton startButton = new JButton("Start");
buttonPanel.setLayout (new FlowLayout(FlowLayout.CENTER));
buttonPanel.add(susButton);
buttonPanel.add(josButton);
buttonPanel.add(drButton);
buttonPanel.add(stButton);
51

buttonPanel.add(startButton);
this.add(buttonPanel, BorderLayout.SOUTH);
susButton.addActionListener(
tipavion=0;
}
}
);
josButton.addActionListener
(
tipavion=1;
}
}
);
drButton.addActionListener(
tipavion=2;
}
}
);
stButton.addActionListener(
tipavion=3;
}
}
);
startButton.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
if (nrAvion==3 && start==false)
{
generareAImap();
computer.print();
start=true;
repaint();
}
else start=false;
}
}
);
this.addWindowListener(
// adauga WindowListener
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
AvioaneFrame.this.windowClosed();
}
}
);
this.addMouseListener(
new MouseListener(){
public void mousePressed (MouseEvent me){
mouseX=me.getX(); mouseY=me.getY();
mouseclicked = true;
repaint();
}
public void mouseClicked (MouseEvent me){}
public void mouseEntered (MouseEvent me) {}
public void mouseReleased (MouseEvent me) {}
public void mouseExited (MouseEvent me) {}
}
);
}
public void paint(Graphics g){
int i=0,j;
int dx,dy ;
52

Toolkit toolkit= Toolkit.getDefaultToolkit();
Image map = toolkit.getImage("map.gif");
Font serif = new Font("Serif",Font.BOLD,18);
g.setFont(serif);
g.drawString("
Algoritmi Euristici de Exploarare - Jocul AVIOANE",10,50);
g.drawString("PLAYER",250,80);
g.drawImage(map,50,85,199,185,this);
g.drawString("COMPUTER",250,290);
g.drawImage(map,50,300,199,185,this);
g.drawRect(10,60,400,430);
if (avioane.size()>0){
for(i=0;i<avioane.size();i++){
for(j=0;j<10;j++){
dx=80+15* (((avion)avioane.elementAt(i)).all[j].x-1);
dy=105+15* (((avion)avioane.elementAt(i)).all[j].y-1);
g.setColor(Color.black);
g.fillRect(dx,dy,15,15);
g.setColor(Color.yellow);
g.drawRect(dx,dy,15,15);
}
}
}
if (avioaneAI.size()>0){
for(i=0;i<avioaneAI.size();i++) {
if(((avion)avioaneAI.elementAt(i)).isalive()!=true){
for(j=0;j<10;j++){
dx=80+15* (((avion)avioaneAI.elementAt(i)).all[j].x-1);
dy=320+15* (((avion)avioaneAI.elementAt(i)).all[j].y-1);
g.setColor(Color.red);
}//endfor
}//endif
}//endfor
}//endif
if (playerShoot.size()>0){
for(i=0;i<playerShoot.size();i++){
dx=80+15* (((patrat) playerShoot.elementAt(i)).x-1);
dy=320+15* (((patrat) playerShoot.elementAt(i)).y-1);
if (((patrat) playerShoot.elementAt(i)).tip==1){
}
else{
g.setColor(Color.green);
}
}
}
if (compShoot.size()>0)
{
for(i=0;i<compShoot.size();i++) {
dx=80+15* (((patrat) compShoot.elementAt(i)).x-1);
dy=105+15* (((patrat) compShoot.elementAt(i)).y-1);
if (((patrat) compShoot.elementAt(i)).tip==1){
}
else{
g.setColor(Color.green);
53

}
}
}
if (mouseclicked){
if(mouseX>80 && mouseX<230 && mouseY>105 && mouseY<255 && nrAvion<3){
x=(mouseX-80)/15+1;
y=(mouseY-105)/15+1;
if (player.aseazaAvion(x,y,tipavion)==true ){
avioane.add( new avion(x,y,tipavion));
nrAvion++;
for(j=0;j<10;j++){
x=80+15* ((( (avion)avioane.elementAt(i)).all[j].x)-1);
y=105+15* ((((avion)avioane.elementAt(i)).all[j].y)-1);
g.fillRect(x,y,15,15);
g.setColor(Color.yellow);
g.drawRect(x,y,15,15);
}
}
}
if (start==true){
loveste_player();
loveste_computer();
mouseclicked = false;
}
}
}
private boolean loveste_player(){
boolean dublura = false;
int sx;
int sy;
if (mouseX>80 && mouseX<230 && mouseY>320 && mouseY<470){
sx=(mouseX-80)/15+1;
sy=(mouseY-320)/15+1;
if(playerShoot.isEmpty()==false){
dublura=false;
for(int i=0;i<playerShoot.size();i++){
if (((patrat) playerShoot.elementAt(i)).x==sx && ((patrat)
playerShoot.elementAt(i)).y==sy){
dublura=true;
break;
} //endif
} //endfor
}//endif
if (computer.map[sx][sy]==1){
for(int i=0;i<3;i++)
if((((avion)avioaneAI.elementAt(i)).cap.x)==sx &&
(((avion)avioaneAI.elementAt(i)).cap.y)==sy )
for(int j=0;j<10;j++){
((avion)avioaneAI.elementAt(i)).cap.tip=1;
((avion)avioaneAI.elementAt(i)).all[j].tip=1;
}
}
if (dublura==false){
playerShoot.add(new patrat(sx,sy,computer.map[sx][sy]));
repaint();
return true;
}
}
return false;
}
private void loveste_computer(){
Random generator = new Random();
boolean dublura=false;
int lastGoodShootx=0;
int lastGoodShooty=0;
do{
x=generator.nextInt(11);
54

y=generator.nextInt(11);
System.out.print(x+","+y+"\n");
if(compShoot.isEmpty()==false){
dublura=false;
for(int i=0;i<compShoot.size();i++){
if (((patrat) compShoot.elementAt(i)).x==x && ((patrat)
compShoot.elementAt(i)).y==y){
dublura=true;
break;
} //endif
} //endfor
}//endif
}
while(!(x!=0 && y!=0 && dublura==false));
compShoot.add(new patrat(x,y,player.map[x][y]));
if ( player.map[x][y]==1){
lastGoodShootx=x;
lastGoodShooty=y;
for(int i=0;i<3;i++){
if (((avion)avioane.elementAt(i)).cap.x==x &&
((avion)avioane.elementAt(i)).cap.y==y ){
for(int j=0;j<10;j++){
compShoot.add(new
patrat(((avion)avioane.elementAt(i)).all[j].x,((avion)avioane.elementAt(i)).all[j].y,1));
}//end for
} //end if
} //end for
} //end if
repaint();
}
public void generareAImap(){
Random generator = new Random();
int tipavion=0;
int x,y;
int contor=0;
while(contor<3)
{
do{
x=generator.nextInt(11);
y=generator.nextInt(11);
}while(x==0 && y==0);
tipavion=generator.nextInt(4);
if (true==computer.aseazaAvion(x,y,tipavion)){
avioaneAI.add(new avion(x,y,tipavion));
contor++;
}
}
}
protected void windowClosed() {
System.exit(0);
}
}
/ Fisierul myMap.java
import java.util.*;
public class myMap{
public int map[][] = new int[11][11];
public myMap(){
int i=1; int j=1;
for(i=1;i<=10;i++)
for(j=1;j<=10;j++)
map[i][j]=0;
}
public boolean aseazaAvion(int x, int y, int tip){
switch (tip){
case 0: {
if ( x<3 || x> 8 || y<1 || y>7) return false;
55

if (
(map[x][y]!=0) ||
(map[x-2][y+1]!=0) ||
(map[x-1][y+1]!=0) ||
(map[x][y+1]!=0) ||
(map[x+1][y+1]!=0) ||
(map[x+2][y+1]!=0) ||
(map[x][y+2]!=0) ||
(map[x-1][y+3]!=0) ||
(map[x][y+3]!=0) ||
(map[x+1][y+3]!=0)
) return false ;
else {
map[x][y]=1;
map[x-2][y+1]=1;
map[x-1][y+1]=1;
map[x][y+1]=1;
map[x+1][y+1]=1;
map[x+2][y+1]=1;
map[x][y+2]=1;
map[x-1][y+3]=1;
map[x][y+3]=1;
map[x+1][y+3]=1;
break;
}
}
case 1: {
if (x<3 || x>8 || y<1|| y<4) return false;
if (
map[x][y]!=0 ||
map[x-2][y-1]!=0 ||
map[x-1][y-1]!=0 ||
map[x][y-1]!=0 ||
map[x+1][y-1]!=0 ||
map[x+2][y-1]!=0 ||
map[x][y-2]!=0 ||
map[x-1][y-3]!=0 ||
map[x][y-3]!=0 ||
map[x+1][y-3]!=0
) return false;
else {
map[x][y]=1;
map[x-2][y-1]=1;
map[x-1][y-1]=1;
map[x][y-1]=1;
map[x+1][y-1]=1;
map[x+2][y-1]=1;
map[x][y-2]=1;
map[x-1][y-3]=1;
map[x][y-3]=1;
map[x+1][y-3]=1;
break;
}
}
case 2:
{
if (x<4 || y<3 || y>8) return false;
if (
map[x][y]!=0 ||
map[x-1][y-2]!=0 ||
map[x-1][y-1]!=0 ||
map[x-1][y]!=0 ||
map[x-1][y+1]!=0 ||
map[x-1][y+2]!=0 ||
map[x-2][y]!=0 ||
map[x-3][y-1]!=0 ||
map[x-3][y]!=0 ||
map[x-3][y+1]!=0
) return false;
else {
56

map[x][y]=1;
map[x-1][y-2]=1;
map[x-1][y-1]=1;
map[x-1][y]=1;
map[x-1][y+1]=1;
map[x-1][y+2]=1;
map[x-2][y]=1;
map[x-3][y-1]=1;
map[x-3][y]=1;
map[x-3][y+1]=1;
}
break;
}
case 3: {
if (x<1 || x>7 ||y<3 || y>8) return false;
if (
map[x][y]!=0 ||
map[x+1][y-2]!=0 ||
map[x+1][y-1]!=0 ||
map[x+1][y]!=0 ||
map[x+1][y+1]!=0 ||
map[x+1][y+2]!=0 ||
map[x+2][y]!=0 ||
map[x+3][y-1]!=0 ||
map[x+3][y]!=0 ||
map[x+3][y+1]!=0
) return false;
else{
map[x][y]=1;
map[x+1][y-2]=1;
map[x+1][y-1]=1;
map[x+1][y]=1;
map[x+1][y+1]=1;
map[x+1][y+2]=1;
map[x+2][y]=1;
map[x+3][y-1]=1;
map[x+3][y]=1;
map[x+3][y+1]=1;
break;
}
}
} return true;
}
public void print(){
int i,j;
for (i=1; i<=10;i++){
for(j=1; j<=10;j++)
System.out.print(map[j][i]+" ");
System.out.print("\n");
}
}
}
57

Proiect

Încărcat de

Informații document

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

Proiect

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA TIBISCUS DIN TIMIOARA

FACULTATEA DE CALCULATOARE I INFORMATIC APLICAT

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

2. NOIUNI DESPRE LIMBAJUL JAVA

2.1 Obiecte i clase n programarea pe obiecte

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Subclasa: Echip de fotbal universitar

Subclasa: Echip de fotbal bucuretean

Obiectele se creeaz cu ajutorul unui tip special de funcie numit constructor.

2.2 Organizarea unui program n obiecte

Zona include unde se face legtura cu bibliotecile;

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Declararea constantelor i variabilelor externe;

Funcia main (corpul principal);

La rndul lui corpul principal al programului, denumit funcia main, conine

Declararea variabilelor i constantelor interne;

Alocri de spaiu n memorie;

Operaii cu datele mai sus definite;

n cazul programelor obiectuale cum este C++, spre deosebire de situaia

Zona include unde se face legtura cu bibliotecile;

Expresia funciilor membre off-line;

Declararea funciilor externe;

Funcia main cuprinznd instanieri de obiecte, procesri de date

Expresiile funciilor externe.

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

//declaraie clasa Clasa_unu

declaraii date membre Clasa_unu;

//declaraie clasa Clasa_doi

declaraii date membre Clasa_doi;

//declaraie clasa Clasa_N

declaraii date membre Clasa_N;

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

un editor capabil s creeze fiiere surs .java (preferabil i pagini

un browser capabil s lucreze cu Java.

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

2.3. Definirea unei clase

// zi, luna, an natere

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

//clasa vid evident fr aplicaii

propoziiile funciei print_it

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

declaraia variabilei n interiorul declaraiei clasei

inializarea variabilei la instanierea obiectului

private - limiteaz vizibilitatea variabilelor strict la interiorul clasei, doar

protected - limiteaz vizibilitatea variabilelor la interiorul clasei i al

permite accesul liber la variabile al tuturor funciilor din

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA

Marius Cristian Lighezan

UNIVERSITATEA TIBISCUS DIN TIMIOARA