Scrdownloader.com M3rdvym62j [621655]

UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE MATEMATICĂ ȘI INFORMATICĂ
SPECIALIZAREA INFORMATICĂ
LUCRARE DE LICENȚĂ
Coordonator Științific :
Asist.univ.dr. Claudiu-Ionuț Popîrlan
Absolvent: [anonimizat] 2010-
1

UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE MATEMATICĂ ȘI INFORMATICĂ
SPECIALIZAREA INFORMATICĂ
Aplicatii JAVA Client-Server
BattleShip
Coordonator Științific :
Asist.univ.dr. Claudiu- Ionuț Popîrlan
Absolvent: [anonimizat] 2010-
2

CUPRINS
CAPITOLUL 1 INTRODUCERE …………………………………………………………………………………. 4
Notiuni introductive Jocuri ……………………………………………………………………………………….. 4
Obiective ………………………………………………………………………………………………………………… 6
CAPITOLUL 2: GENERALITATI ……………………………………………………………………………….. 8
2.1. Introducere in limbajul de programare Java ………………………………………………………….. 8
2.3.Elemente Java folosite in dezvoltarea aplicatiei …………………………………………………… 13
2.3.1.Java Sockets …………………………………………………………………………………………… 13
………………………………………………………………………………………………………………………… 23
2.3.2. Java Thread ……………………………………………………………………………………………. 23
2.3.3. Desenarea in Java ……………………………………………………………………………………. 30
2.3.4.Java Swing ……………………………………………………………………………………………… 35
CAPITOLUL 3:PREGĂTIREA MEDIULUI DE LUCRU ……………………………………………… 37
3.1. Instalare NetBeans …………………………………………………………………………………………… 37
3.2. Configurare client-server ………………………………………………………………………………….. 39
……………………………………………………………………………………………………………………………….. 39
CAPITOLUL 4:DESCRIEREA APLICATIEI ………………………………………………………………. 40
4.1. Introducere ……………………………………………………………………………………………………… 40
4.2.Structura aplicatiei ……………………………………………………………………………………………. 41
4.3. Simularea jocului …………………………………………………………………………………………….. 53
CAPITOLUL 5: CONCLUZII …………………………………………………………………………………….. 61
BIBLIOGRAFIE ……………………………………………………………………………………………………….. 62
3

CAPITOLUL 1 INTRODUCERE
Notiuni introductive Jocuri
Un joc este o activitate recreațională în care sunt implicați unul sau mai mulți jucători,
fiind definit printr-un scop pe care jucătorii încearcă să-l atingă și un set de reguli care
determină ce pot face jucătorii.
Jocurile pot implica un singur jucător, dar mai des implică o competiție între doi sau mai
mulți jucători. Cât timp respectă regulile, de obicei sunt mai multe alegeri pe care jucătorul le
poate face. Nerespectarea regulilor se numește trișare.
În cadrul întregii istorii umane, oamenii au jucat jocuri ca o sursă de divertisment pentru
ei înșiși și pentru alții și există o varietate enormă de jocuri.
Un joc video este un joc electronic în care se interacționează cu o interfață grafică
pentru a genera răspuns vizual pe un ecran. Jocurile video în general au un sistem de
recompensare a utilizatorului, de obicei se ține scorul, acest sistem depinzând de îndeplinirea
unor anumite obiective în joc.
Termenul joc pe calculator sau "joc pe PC" se referă la un joc care este jucat pe un PC,
unde monitorul este principalul mijloc de feedback și care folosește dispozitiv de control un
periferic de intrare, de obicei butonarea unui joystick (jocuri din arcade-uri), o combinație
tastatură & maus/trackball sau un controller, ori o combinație dintre cele de mai sus
Jocurile pentru computer constituie o categorie de aplicații software care este destinată
distracției. De la apariția acestora, în lumea computerelor, în anii 1970, până astăzi, industria a
evoluat, astfel că putem vorbi cu ușurință de multe evenimente de prezentare a jocurilor, cum
ar fi E3 sau CeBit la nivel mondial sau CERF în România, precum și de câteva organizații de
jucători profesioniști.
Există mai multe tipuri de jocuri pe calculator:
•RTS (Real Time Strategy – Strategie în timp real)
•RTT (Real Time Tactics)
•RPG (Role Playing Game )
•TBS (Turn Based Strategy )
•Simulatoare
•Action
•Adventure (aventură)
•FPS (First Person Shooter )
4

•TPS (Third Person Shooter )
•MMO (Massive Multiplayer Online Game)
•Arcade
•Board/Card Games (Joc de cărți sau masă)
La unele tipuri de jocuri se poate adăuga prefixul "MMO", care înseamnă "Massively
Multiplayer Online", reprezentând un joc care se poate ju ca numai online, in care sute de mii
de jucatori joaca in acelasi timp, in aceeasi lume. Cele mai multe MMO-uri sunt MMORPG-
uri.
•Railroad Tycoon II
•Call of Duty
•Cossaks – The art of war
•Starcraft
•Tomb Raider
•Hitman
•Hattrick
•Midnight Club II
•Need for Speed
•Broken Sword
Câteva exemple de jocuri strategice sunt:
•Age of Empires I
•Age of Empires II
•Age of Empires III
•Age of Mythology
•Age of Wonders
•Caesar III
•Caesar IV
•Children of the Nile
•Civilization IV
•Empire Earth
•Empire Earth 2
•Empire Earth 3
5

•Pharaoh
•Rome Total War
•Rise of Nation
•Stronghold
•Stronghold Crusader
•Stronghold 2
•Stronghold Legends
•World of Warcraft
•Zeus-Master of Olympus
De i calculatoarele personale au devenit populare o data cu dezvoltareaș
microprocesoarelor i minicalculatoarelor, jocurile pe calculator au existat încă de la 1960. ș
Unul dintre primele jocuri pe computer a fost Spacewar dezvoltat in 1961 de către
studen ii MIT Martin Graetz,Alan Kotok, si Steve Russell. Jocul a fost dezvoltat pe un ț
computer PDP-1, folosit pentru calcule statistice.
Prima generatie de jocuri pentru PC a fost „text adventure” sau „interactive fiction”, în
care jucătorul comunica cu calculatorul prin introducere anumitor comenzi de la tastatură.
Primul text- adventure „Aventura”a fost realizat pentru PDP-11 de Will Crowther în
1976 si a fost dezvoltat de Don Woods in 1977.
Prin anii 1980 calculatoarele personale au devenit suficient de putennice pentru a rula
jocuri precum Adventura, în acest timp grafica începaând sa devina un factor important în
jocuri.
O data cu dezvoltarea internetului la scară foarte largă a crescut i pia a jocurilor online ș ț
si client-server: Counter Strike,Dota, Street Fighter Alpha 2 , FIFA etc. Jocurile multyplayer
sunt mai atractive si acum reprezintă viitorul jocurilor PC deoarece pot userii pot jucua cu
adversari umani ceea ce face aceste jocuri din ce in ce mai atractive pentru toate categoriile de
varsta. De asemenea aceste jocuri sunt i un mod de a cunoa te oameni din diferite zone isunt ș ș ș
un mod de relaxare de asemenea.
Obiective
•Realizarea unei aplica ii client-server in Java ț
•Exemplificarea modului de lucru cu soket-uri i thread-uri ș
•Folosirea limbajului de programare Java pentru a creea o aplica ie stabilă i u or de ț ș ș
folosit
6

•Importan a Internetului realizarea aplica iilor bazate pe arhitectura client-server ț ț
7

CAPITOLUL 2: GENERALITATI
2.1. Introducere in limbajul de programare Java
1. Ce este JAVA ?
este un limbaj de programare dezvoltat de JavaSoft, companie în cadrul firmei Sun
Microsystems.
este complet orientat pe obiecte i oferă posibilitatea reala de refolosire a codului (care ș
este de fapt promisiunea facută la apari ia programării orientate pe obiecte). ț
este neutru din punct de vedere arhitectural, cu alte cuvinte Java este un limbaj
independent de platforma de lucru, aceea i aplica ie rulând, fără nici o modificare, pe ș ț
sisteme diferite cum ar fi Windows, UNIX sau Macintosh, lucru care aduce economii
substan iale firmelor care dezvoltă aplica ii pentru Internet. ț ț
limbajul Java este modelat după C si C++, trecerea de la C, C++ la Java făcându-se foarte
usor.
elimină sursele frecvente de erori ce apar în programare prin eliminarea pointerilor,
administrarea automata a memoriei si eliminarea fisurilor de memorie printr-o procedură
de colectare a “gunoiului” care rulează în fundal;
este cel mai sigur limbaj de programare disponibil în acest moment, asigurând mecanisme
stricte de securitate a programelor concretizate prin: verificarea dinamică a codului pentru
detectarea secven elor periculoase, impunerea unor reguli stricte pentru rularea ț
programelor lansate pe calculatoare aflate la distanta (acestea nu au acces la re eaua ț
locală, la fi ierele stocate în sistemul local i nu pot lansa în executie programe locale), ș ș
etc.
permite creearea unor documente Web îmbunătă ite cu anima ie si multimedia. ț ț
a fost proiectat pentru a fi folosit în medii distribuite si sisteme deschise.
2. Evolutia limbajului JAVA
8

In 1991, firma SUN, mergând pe direc ia dezvoltării sistemelor deschise de lucru în ț
re ea, a creat un proiect de lucru numit Green, care avea drept scop punerea la punct a unorț
procesoare care să poată rula pe diferite tipuri de aparate si punerea la punct a unui sistem
care sa poata rula pe platforme diferite. Planul initial prevedea dezvoltarea proiectului în C++,
dar au apărut foarte multe probleme în încercarea de dezvoltare acompilatorului de C++. Ca
urmare, James Gosling, membru al grupului Green, a început să lucreze la dezvoltarea unui
nou limbaj, numit Oak, care, mai târziu, avea să se numească Java. De asemenea grupul
Green avea sa-si schimbe numele întâi în FirstPerson, apoi în JavaSoft.
Abia dupa ce a fost înfiin ata compania Netscape Communications Corporation, cei de ț
la JavaSoft s-au orientat către Internet si Web, mediul multiplatforma distribuit al retelei
Internet fiind perfect pentru testarea proiectului.
In prezent licen a pentru tehnologia Java a fost acordată unor firme precum IBM, ț
Microsoft, Sillicon Graphics, Adobe si Netscape.
3. Java : un limbaj compilat si interpretat
In func ie de modul de execu ie al programelor, limbajele de programare se împart în două ț ț
categorii :
•interpretate : instructiunile sunt citite linie cu linie de un program numit interpretor
si traduse în instruc iuni masină; avantaj : simplitate; dezavantaje : viteza de ț
execu ie redusa ț
•compilate : codul sursa al programelor este transformat de compilator într-un cod
ce poate fi executat direct de procesor; avantaj : executie rapida; dezavantaj : lipsa
portabilitatii, codul compilat într-un format de nivel scazut nu poate fi rulat decât
pe platforma pe care a fost compilat.
Programele Java pot fi atât interpretate cât si compilate.
Cod sursa Java →(compilare)→ Cod de octeti
Codul de octeti este diferit de codul masină. Codul masină este reprezentat de o
succesiune de 0 si 1; codurile de octeti sunt seturi de instruc iuni care seamănă cu codul scris ț
în limbaj de asamblare.
Codul ma ină este executat direct de către procesor i poate fi folosit numai pe ș ș
platforma pe care a fost creat; codul de octeti este interpretat de mediul Java i de aceea poate ș
fi rulat pe orice platforma care foloseste mediul de execu ie Java ț→ neutralitatea limbajului
Java din punct de vedere arhitectural.
9

Cum este rulat un program Java ? Interpretorul Java transformă codul de octe într-un ț
set de instruc iuni masină, întârzierea interpretarii fiind însa foarte mică datorită asemănării ț
dintre codul de octeti si limbajul de asamblare i din acest motiv execu ia se face aproape la ș ț
fel de repede ca în cazul programelor compilate.
Cum este obtinută neutralitatea arhitecturala a limbajului Java ? Cu alte cuvinte, cum
este posibilă portarea codului de octeti pe calculatoare diferite? Truc : codul sursă este
compilat nu pentru calculatorul pe care se lucrează ci pentru un calculator inexistent , acest
calculator imaginar fiind numit Masina virtuală Java (Java Virtual Machine ). Interpretorul
ac ionează apoi ca un intermediar între Masina virtuala Java si ma ina reală pe care este rulatț ș
programul.
Aplicatia utilizatorului
Obiecte Java
Masina virtuala Java
UNIX Windows Macintosh
Sisteme de operare
4. Java si conceptele programarii orientate pe obiecte
Limbajul Java este urmatorul pas logic în domeniul limbajelor de programare i se bazează pe ș
cel mai popular limbaj de programare al momentului C++. In Java se pot ob ine programe cu ț
aspectul si comportarea programelor C++, dar beneficiind de avantajele oferite de un limbaj
proiectat special pentru POO. Java renun ă complet la programarea procedurală specifică C- ț
ului si va obligă să folosi i conceptele solide ale POO. ț
Conceptele programarii orientate pe obiecte cuprind :
•Obiectele
•Încapsularea si transmiterea de mesaje
•Clasele
•Bibliotecile (numite pachete, în Java)
•Mo tenireaș
•Modificatorii de acces
Obiectele :
10

unitatea elementara a POO
starea obiectului este dată de variabile de instan ă ț
comportamentul obiectului este dat metode
u or de refolosit, actualizat, întretinutș
Încapsularea si transmiterea de mesaje :
Clasele :
încapsuleaza obiecte
o singură clasă poate fi folosită pentru instantierea mai multor obiecte
Pachetele: colectie de clase înrudite
Mostenirea : permite
extinderea functionalitatii unor clase existente
refolosirea codului
Modificatorii de acces : controlează accesul la metodele si variabilele obiectelor. Acestea pot
fi :
1. Private – accesibile doar obiectelor din aceeasi clasă
2. Protejate- accesibile obiectelor din aceeasi clasă si din subclasele clasei
respective
3. Prietenosase – (nivelul de accesibilitate prestabilit) accesibile tuturor claselor din
pachetul curent
4. Publice- accesibile tuturor claselor din orice pachet
Programarea în limbajul Java
5. Caracteristicile de baza al limbajului Java
A. Folosirea în medii de re ea distribuite ț
Java a fost proiectat pentru un mediu complex cum este Internetul si de aceea trebuie să poată
rula pe platforme eterogene distribuite. Acest lucru este posibil deoarece :
•este neutru din punct de vedere arhiectural = programele pot fi rulate pe orice
platformă care are instalat mediul Java
•are un grad ridicat de portabilitate = contine obictecte care pot fi folosite pe
platforme eterogene si respectă standardele IEEE (Institue of Electrical and
Electronics Engineers) pentru structurile de date (folosirea întregilor, a numerelor
în virgulă mobilă, a irurilor, etc) ș
11

•este distribuit = poate folosi atât obiecte memorate local cât si obiecte stocate pe
calculatoare aflate la distantă
•este compatibil cu mediile de lucru în re ea ț (poate fi utilizat în re ele complexe) i ț ș
acceptă direct protocoalele de re ea obisnuite cum ar fi FTP si HTTP ț
B. Asigurarea performan ei ridicate ț
•compilatorul si sistemul de executie oferă o viteza ridicată rularii programelor
•are încorporate posibilită i de țexecu ie multifilară ț (rularea simultană a mai multor
procese) folosind un sistem de acordare de priorita i proceselor ce trebuie ț
executate. Printre procesele care rulează în fundal sunt cele de “colectare a
gunoiului” si de gestionare a memoriei.
C. Refolosirea codului si fiabilitatea
•Java este un limbaj dinamic, lucru asigurat prin întârzierea legării obiectelor i ș
legarea dinamică a claselor în timpul execu iei, ceea ce împiedică apari ia erorilor ț ț
în cazul schimbării mediului de lucru dupa compilarea programului sursă.
•Fiabilitatea este asigurata prin eliminarea pointerilor , prin folosirea verificării
dinamice a limitelor i prin gestionarea automată a memoriei, înlaturându-se ș
posibilitatea fisurilor i violărilor de memorie. O altă cale de evitare a erorilor este ș
verificarea structurilor de date atât la compilare cât si în timpul executiei.
D. Asigurarea securitatii
•Interzice accesul la stiva sistemului, la zona libera de memorie si la sectiunile
protejate de memorie
•Verifica validitatea codului semnalând urmatoarele:
Violările de acces
Conversiile ilegale de date
Valori si parametri incorec i ț
Modificarea claselor sau folosirea incorectă a acestora
Depă irea stivei în partea superioară sau inferioară ș
Activităti suspecte sau neautorizate
12

2.3.Elemente Java folosite in dezvoltarea aplicatiei
2.3.1.Java Sockets
O rețea este formată dintr-o mulțime de calculatoare și periferice (imprimante, plotere,
scannere, modemuri etc.) conectate între ele.
Un sistem distribuit este o colecție de calculatoare și/sau procesoare autonome (având
o unitate de comandă proprie), interconectate (capabile de a schimba informații între ele).
Elementele colecției poartă numele de noduri. Un astfel de sistem poate fi programat pentru a
rezolva probleme de concurență și de paralelism.
Sistemele distribuite au apărut ca o necesitate pentru:
– schimbul de informații între noduri;
– partajarea unor resurse (printere, memorie backup, unități de disc etc.);
– siguranța în funcționare: dacă un nod "cade", întregul sistem trebuie (dacă este
posibil) să fie capabil să asigure în continuare funcționarea, prin redirijarea ( rutarea)
mesajelor prin nodurile funcționale.
Tipuri de rețele
O primă clasificare a rețelelor este constituită de împărțirea lor în rețele LAN (Local
Area Network) și rețele WAN (Wide Area Network ).
Rețelele LAN sunt folosite de obicei pentru a partaja resurse (fișiere și periferice) și de
a facilita schimbul de informații între nodurile componente. Conectarea tipică este realizată
prin cablu, cu o limită dată pentru un drum între două noduri (de exemplu 10 km).
La fiecare moment de timp, într-o astfel de rețea este transmis un singur mesaj.
Numele rețelei desemnează produsul și nu rețeaua (așa cum se întâmplă la rețelele
WAN). De exemplu Ethernet este un produs al companiei XEROX.
Probleme algoritmice pentru astfel de rețele:
1) sincronizarea: așteptarea îndeplinirii unei condiții;
2) difuzarea totală (broadcasting) : transmiterea unui mesaj către toate celelalte
noduri;
3) selectarea unui proces pentru îndeplinirea anumitor acțiuni;
13

4) detectarea terminării : un nod ce întreprinde o acțiune, în care antrenează și alte
noduri, trebuie să fie capabil să detecteze momentul încheierii acțiunii;
5) excluderea reciprocă : utilizarea unor resurse sub excludere reciprocă (de exemplu
modificarea unui fișier sau scrierea la imprimantă);
6) detectarea și prevenirea blocării totale (deadlock);
7) gestionarea distribuită a fișierelor .
Rețelele WAN permit comunicarea pe distanțe mai mari, prin legături directe între
noduri, realizate prin linie telefonică, fibră optică, legătură via satelit etc. Ele sunt grafuri
orientate.
Probleme algoritmice pentru astfel de rețele:
1) siguranța schimbului de informații pe fiecare arc al grafului. Informația eronată
trebuie recunoscută ca atare și corectată. Menționăm că este posibil ca mesajele să sosească
într-un nod în altă ordine decât cea în care au fost transmise, pot fi duplicate etc.;
2) selectarea de căi de comunicare (rutare) între nodurile care schimbă informații,
deoarece un graf complet este prea costisitor și în general nici nu este realizabil. Modul de
rutare trebuie actualizat în cazul în care un nod al rețelei cade (devine nefuncțional);
3) evitarea congestionării unor căi de comunicație, realizată tot prin (re)rutare;
4) evitarea blocării totale ;
5) securizarea datelor și a transmisiilor .
Deosebirile esențiale între cele două tipuri de rețele se referă la:
1) securizare: în rețele LAN se presupune că transmiterea este corectă, pe când în
rețelele WAN trebuie presupus că în timpul transmiterii mesajelor se poate întâmpla "ceva
rău";
2) timpul de comunicare : în rețelele WAN timpul de comunicare este mult mai mare
(de 10k ori mai mare, k ≥ 1) decât în rețelele LAN; aceast timp este la rândul său mult mai
mare decât cel cerut de prelucrările locale;
3) omogeneitatea: în rețelele WAN trebuie presupus că sunt utilizate simultan mai
multe protocoale (vezi paragraful următor), ceea ce pune problema recunoașterii și conversiei
între ele;
4) încrederea reciprocă : nu este presupusă în rețelele WAN și drept urmare trebuie
luate măsuri de securitate adecvate.
Protocoale
Comunicarea între componentele unei rețele (respectiv unui sistem distribuit) se face
prin mulțimi de reguli, numite generic protocoale.
14

Un protocol cuprinde atât formatul mesajului ce este efectiv transmis, cât și modul în
care trebuie răspuns la mesajul respectiv.
Protocolul folosit pe Internet este IP (Internet Protocol). Mesajele circulă în pachete,
ce pot fi:
– pachete Internet, pentru care protocolul este TCP (Transmission Control Protocol );
– datagrame, pentru care protocolul este UDP (User Datagram Protocol ); nu vom
vorbi despre ele.
Internetul folosește nume (adrese) simbolice pentru rețele și pentru mașinile gazdă; ele
se mai numesc nume de domeniu. Lor li se asociază în mod biunivoc adrese (numerice) IP ,
folosite efectiv la comunicarea între nodurile rețelei. Asocierea cade în sarcina unui sistem de
nume de domeniu (DNS = Domain Name System).
O adresă numerică IP are foma:
a.b.c.d
unde a, b, c, d sunt numere naturale din mulțimea {0, 1, …, 255}.
Modelul Client/Server
După cum știm, comunicarea între nodurile unei rețele constă în transmiterea
(recepționarea) de pachete către (de la) gazde ale aceleași rețele sau ale unei alte rețele.
Modelul utilizat pe scară largă în sistemele distribuite (și care va fi cel folosit în
continuare) este sistemul Client/Server . În acest model există:
– o mulțime de procese Server, fiecare jucând rolul de gestionar de resurse pentru o
colecție de resurse de un anumit tip;
– o mulțime de procese Client; fiecare execută activități care necesită acces la resurse
hard/soft disponibile (partajate) de servere.
Un gestionar de resurse poate avea și el nevoie de resurse gestionate de un alt proces
Server. Drept urmare, unele procese pot fi atât de tip Client, cât și de tip Server. Dar doar
serverele gestionează resurse.
Serverele sunt cele care își încep primele activitatea. În mod tipic, un server oferă
succesiv clienților posibilitatea de a se conecta la el (spunem că acceptă conexiuni de la
clienți). La început clientul își manifestă dorința de a se conecta și, dacă serverul este gata să
accepte conexiunea, aceasta se realizează efectiv; este vorba deci de o acțiune de la client
către server. Apoi transmisia informațiilor devine bidirecțională, fluxul de informații putând
circula acum în ambele sensuri.
15

Teoretic, activitatea unui server se desfășoară la infinit.
Pentru conectare la server, clientul trebuie să cunoască adresa serverului (fie cea
numerică, fie cea simbolică), precum și numele portului pus la dispoziție de server. Portul nu
este o locație fizică, ci o extensie software corespunzătoare unui serviciu. Serverul poate oferi
mai multe servicii, pentru fiecare existând un număr de port. Cel standard sunt:
7 : ping (ecou)21 : ftp (transfer de fișiere) 23 : telnet
25 : email79 : finger 80 : Web
110 : POP3 (Post Office Protocol)
Porturile din intervalul 0..1023 sunt în general rezervate pentru servicii speciale (de
genul celor de mai sus) și pentru clienți privilegiați.
Clientul inițiază conexiunea prin rețea, specificând adresa serverului și portul prin care
dorește să comunice. Serverul trebuie să precizeze numai portul; apoi el trebuie să execute o
comandă prin care să anunțe că este gata să accepte conexiuni pe portul respectiv; drept
urmare el rămâne în așteptare până când un client dorește să se conecteze și conexiunea este
stabilită cu succes. Un server poate accepta conexiuni de la mai mulți clienți: pentru fiecare
crează un fir de executare.
Clasa InetAddress
Această clasă, aflată în pachetul java.net, furnizează informații asupra adreselor
(simbolică și numerică) unui calculator gazdă.
Clasa nu are constructori publici. Principalele metode sunt:
public static InetAddress getLocalHost()
returnează numele calculatorului gazdă (pe care se află în curs de executare aplicația). Acest
nume, convertit la String, are forma: adresă_simbolică/adresă_IP;
public static InetAddress getByName(String s)
dându-se ca argument adresa simbolică sau numerică a calculatorului gazdă, metoda întoarce
un obiect de tipul InetAddress; metoda poate lansa excepția UnknownHostException;
public String getHostName()
întoarce adresa simbolică a calculatorului gazdă;
public byte[] getAddress()
întoarce un tablou de 4 octeți, ce compun adresa numerică.
Exemplul 1. Determinarea adreselor unui calculator și obținerea uneia dintre aceste
adrese cunoscând-o pe cealaltă:
16

import java.net.*;
class Adrese {
public static void main(String[] sss) throws Exception {
InetAddress gazda = null;
gazda = InetAddress.getLocalHost();
System.out.println(gazda.toString());
}
}
Întrebare. "Are sens să studiem facilitățile oferite de Java pentru lucru în rețea dacă
avem la dispoziție un singur calculator ?". DA! Putem de exemplu deschide mai multe ferestre
de comandă. Adresa IP: numele calculatorului, numele standard "localhost" sau "127.0.0.1".
Comunicare prin socket-uri
Socket-urile sunt folosite pentru transmiterea de date folosind protocolul TCP/IP. Ele
sunt obiecte ce trebuie create la ambele capete ale conexiunii. Socket-urile client sunt obiecte
de tipul clasei Socket, iar socket-urile server sunt obiecte de tipul clasei ServerSocket; ambele
clase fac parte din pachetul java.net. Socket-urilor li se pot atașa un flux de intrare și unul de
ieșire, prin care pot recepționa/ transmite, date.
Prezentăm în continuare schema generală a lucrului cu socket-uri, apelând la
facilitățile de intrare/ieșire la nivel de octet.
Un mod tipic de creare a unui socket client este următorul:
try {
Socket cs = null; cs = new Socket("adresa",nrport);
DataInputStream is = new DataInputStream(cs.getInputStream());
DataOutputStream os = new DataOutputStream(cs.getOutputStream());
}
catch(UnknownHostException e) { … }
catch(IOException e) { … }
17

unde adresa este adresa IP a serverului, iar nrport este numărul portului ales pentru
comunicare. Socket-ului îi sunt atașate fluxul os ce va fi folosit pentru a transmite date
serverului, precum și fluxul is ce va fi folosit pentru recepționarea datelor transmise de server.
Un mod tipic de creare a unui socket server este următorul:
ServerSocket ss = null; Socket cs = null;
try {
ss = new ServerSocket(nrport);
// System.out.println("Serverul a pornit");
}
catch(IOException e) { … }
try {
cs = ss.accept();
DataInputStream is =
new DataInputStream(cs.getInputStream());
DataOutputStream os =
new DataOutputStream(cs.getOutputStream());
}
catch(UnknownHostException e) { … }
catch IOException e) { … }
Observăm că pentru server nu este necesară precizarea unei adrese IP, ci numai a unui
port, care trebuie să coincidă cu cel folosit de client.
Metoda accept: se așteptă ca un client să încerce să se lege la server; în momentul în
care acest lucru se întâmplă și legătura s-a stabilit, metoda creează și întoarce un socket cs de
tip client. Acestuia îi atașăm un flux de intrare și unul de ieșire.
18csos
iscs ssis
osClie
ntServ
er

În final toate socket-urile și fluxurile trebuie închise explicit prin invocarea metodei
close.
.
•Clasa URL
Clasa URL este declarată în pachetul java.net prin:
public final class URL extends Object
implements Serializable
Un obiect de tip URL, numit și locație URL, este o referință la o resursă Web. Resursa
poate fi un fișier, un director, dar și un obiect mai complex ca de exemplu o cerere către o
bază de date sau un motor de căutare. Ca sintaxă, o astfel de adresă cuprinde 4 părți:
protocol://adresa:port/cale
unde protocol desemnează serviciul exportat de server sau căutat de client (de exemplu http
sau ftp), adresa este adresa simbolică sau numerică a mașinii gazdă referite, port portul folosit
pentru comunicare, iar cale identifică resursa.
Un exemplu este următorul:
http://www.ncsa.uiuc.edu:8080/demoweb/url-primer.html
Sunt folosite și locații URL parțiale, ce specifică doar unele părți din forma completă
a locației; acest lucru este posibil în situațiile în care celelalte părți sunt implicite sau se deduc
din context. De exemplu poate lipsi numele mașinii gazdă (dacă facem referire la mașina
locală) sau portul (dacă este folosit un port implicit).
Constructorul "complet" are forma:
public URL(String protocol, String gazda,
int port, String fisier)
Metode (publice), ale clasei URL :
String getPath()
întoarce calea din locația URL;
int getPort()
întoarce numărul portului din locația URL;
String getProtocol()
întoarce protocolul din locația URL;
String getHost()
întoarce adresa mașinii gazdă din locația URL;
String getFile()
19

întoarce numele fișierului din locația URL;
String toString()
întoarce reprezentarea sub formă de șir de caractere a locației URL.
Exemplul 2. Dorim să aflăm dacă un server având o adresă dată oferă sau nu servicii
Web.
Va fi creat un socket de tip client. Adresa este furnizată în comanda ja va.
// Executarea se face prin: java WebCheck adresa
import java.io.*; import java.net.*;
public class WebCheck {
public static void main(String[] adresa) {
Socket web = null;
System.out.print("Serverul " + adresa[0]);
try {
web = new Socket(adresa[0],80);
System.out.println(" ofera servicii Web"); web.close();
}
catch(IOException e) {
System.out.println(" nu ofera servicii Web");
}
}
}
Exemplul 3. Chat (o conversație) între două calculatoare.
20

Pentru simplificare, considerăm că fiecare mesaj trimis de la un calculator la celălalt
se reduce la o linie de text .
Serverul este primul care trebuie pornit. Apoi clientul este cel care începe discuția,
transmițând un mesaj și așteptând să primească mesajul de răspuns, activități care se repetă
până când clientul transmite mesajul "STOP". Serverul repetă și el succesiunea de activități
recepție + transmisie până când primește mesajul "STOP".
Clientul va folosi unitatea de compilare Client.java, iar serverul va folosi unitatea de
compilare Server.java.
// Unitatea de compilare Client.java
import java.net.*; import java.io.*;
class Client {
public static void main (String[] sir)
throws IOException {
Socket cs = null;
DataInputStream is=null; DataOutputStream os=null;
try {
cs = new Socket("localhost",5678);
is = new DataInputStream(cs.getInputStream());
os = new DataOutputStream(cs.getOutputStream());
}
catch(UnknownHostException e) {
System.out.println("Host inexistent");
}
DataInputStream stdin =
new DataInputStream(System.in);
String linie;
for( ; ; ) {
linie = stdin.readLine()+"\n"; os.writeBytes(linie);
System.out.println("Transmisie :\t" + linie);
if (linie.equals("STOP\n")) break;
linie = is.readLine();
21

System.out.println("Receptie :\t" + linie);
}
System.out.println("GATA");
cs.close(); is.close(); os.close();
}
}
// Unitatea de compilare Server.java
import java.net.*; import java.io.*;
class Server {
public static void main (String[] sir)
throws IOException {
ServerSocket ss = null; Socket cs = null;
DataInputStream is=null; DataOutputStream os=null;
ss = new ServerSocket(5678);
System.out.println("Serverul a pornit !");
cs = ss.accept();
is = new DataInputStream(cs.getInputStream());
os = new DataOutputStream(cs.getOutputStream());
DataInputStream stdin =
new DataInputStream(System.in);
String linie;
for( ; ; ) {
linie = is.readLine();
System.out.println("Receptie :\t" + linie);
if (linie.equals("STOP")) break;
linie = stdin.readLine()+"\n";
os.writeBytes(linie);
22

}
cs.close(); is.close(); os.close();
}
}

2.3.2. Java Thread
Un sistem multiprocesor (SM) este un mecanism ce permite unui sistem de a folosi
mai mult de un procesor. Sistemul Mutiprocesor Simetric (SMS) este o parte a Calculului
Paralel unde toate procesoarele sunt identice. Intr-un SMS, procesoarele sunt dirijate in asa fel
încât sarcinile sunt împartite de către sistemul de operare iar aplica iile sunt executate pe mai ț
multe procesoare ce împart acela i spatiu de memorie. SMS garantează că întreg numărul de ș
procesoare deserve te sistemul de operare. Fiecare sub-proces poate fi executat pe orice ș
procesor liber. Astfel se poate realiza echilibrarea încarcării între procesoare. Java con ine ț
câteva caracteristici care-l fac un limbaj ideal pentru SMS. Este un limbaj orientat obiect
foarte simplu i este conceput să suporte programarea multiprocesor. ș
Multitasking-ul este o metodă prin intermediul căreia mai multe procese utilizează în
comun resursele calculatorului (inclusiv procesorul). În situația unui calculator cu un singur
procesor, se spune că în orice moment rulează cel mult un proces, ceea ce înseamnă că
procesorul execută instrucțiunile unui singur proces la un moment dat. Sarcina alegerii
procesului care să se afle în execuție la un moment dat este o problemă de planificare.
Operația de a opri un proces aflat în execuție, pentru a-i aloca un timp procesor altui proces
aflat în așteptare se numește schimbare de context (context switch). Realizarea frecventă a
acestor schimbări de context crează iluzia excuției în paralel a mai multor programe.
În cazul unui calculator cu mai multe procesoare, multitasking-ul permite execuția
unui număr de procese mai mare decât numărul de procesoare.
Sistemul de operare este cel care se ocupă de planificarea proceselor, planificare ce se
încadrează într-una din următoarele strategii:
23

•în cazul sistemelor cu multiprogramare , procesul current se află în execuție până în
momentul în care realizează o operație ce presupune așteptarea după un eveniment
extern (o operație de I/O), sau până când planificatorul de procese forțează eliberarea
procesorului.
•într-un sistem de tip time-sharing , fiecare process va elibera procesorul în mod
voluntar după expirarea cuantei de timp alocate acestuia sau în urma apariției unui
eveniment hardware cum ar fi o întrerupere.
•în cadrul sistemelor real-time, unui proces aflat în stare de așteptare i se garantează
accesul la procesor în cazul apariției unui eveniment extern. Astfel de sisteme sunt
proiectate pentru controlul unor dispozitive mecanice cum ar fi roboții industriali.
Comutarea între procese consumă timp procesor pentru ca planificatorul de procese să
înghețe starea unui proces și să dezghețe starea altui proces (schimbare de context). Dacă mai
multe procese concurente sunt executate pe același procesor și toate execută calcule atunci
timpul total de execuție va fi mai mare decât timpul de execuție al unui program secvențial
echivalent.
Creșterea vitezei sistemului se poate realiza prin întrețeserea diferitelor faze ale mai
multor procese.
În cadrul unui proces se pot identifica două tipuri de faze din punct de vedere logic: faza
de calcul și faza de I/O. Faza de calcul se realizează exclusiv la nivelul procesorului
utilizându-se la maxim funcțiunile acestuia. Faza de I/O (intrare/ieșire) presupune un aport
mai mare din partea perifericelor (imprimante, hard discuri, plăci de rețea, etc), procesul
așteptând ca un periferic să-și termine sarcina. În timp ce un proces se află într-o fază de I/O
așteptând după finalizarea unei operații de către un dispozitiv periferic, un proces aflat în faza
de calcul poate ocupa procesorul.
În cazul multitasking-ului preemtiv planificatorul de procese alocă cuante de timp
procesor egale fiecărui proces, asigurândule astfel un tratament echitabil. De asemenea,
sistemul poate răspunde rapid unui eveniment extern (cum ar fi sosirea unor date) ce
presupune procesarea de către procesul curent sau de către un altul.
În cazul multitasking-ului non-preemtiv , planificatorul îi dă controlul unui proces
până când acesta se termină, sau eliberează singur procesorul.
Ce sunt thread-urile?
Thread-ul reprezintă execu ia liniară a unei singure secven e de instruc iuni ce rulează ț ț ț
in interiorul programului nostru. Toti programatorii sunt familiarizati cu scrierea programelor
secven iale. Programele secven iale au un punct de start, o secventa de executie si un punct ț ț
24

terminal. Caracteristica cea mai importanta la un program secvential este aceea ca în orice
moment se execută o singură instructiune. Thread-ul este similar cu un program secvential:
are si el un punct de start, o secventa de execu ie si un punct terminal. De asemenea intr-un ț
thread se execută doar o singură instructiune la un moment dat. Si totusi un thread nu este la
fel ca un program obisnuit.
Spre deosebire de programe, thread-ul nu poate exista de unul singur. Thread-urile
coexistă in interiorul unui program. Prin urmare putem avea mai multe thread-uri care se
execută simultan.
De ce sa folosim thread-uri?
Un singur thread nu oferă nimic nou. Orice program scris pâna acum avea cel putin un
thread in interiorul său. Noutatea apare atunci când vrem sa folosim mai multe thread-uri,
ceea ce inseamna că aplica ia noastră poate să facă mai multe lucruri in acelasi timp. Fiecare ț
thread poate sa facă altceva in acelasi timp: unul sa încarce o pagină Web, altul sa animeze o
icoana sau toate pot colabora la acelasi job (generarea unei imagini 3D). Când se folose te ș
corespunzator multithreading-ul performan ele applet-ului sau a aplica iei unde este folosit ț ț
cresc simtitor.
Multithreading-ul poate simplifica fazele de proiectare si planificare a tuturor
sarcinilor greu de implementat într-un program secven ial. Un exemplu de thread-uri este un ț
procesor de text care poate sa tipărească o pagină (paginare, încadrare si trimitere către
imprimantă) in background. Se poate continua editarea în timp ce pagina este trimisă către
imprimantă.
Alt exemplu este acela a unui browser Web care permite defilarea unui text al unei
pagini pe care tocmai a i incarcat-o în timp ce browser-ul se ocupă cu aducerea imaginilor. ț
Thread-urile pot face calculul mai rapid. Prin segmentarea unui task in subtask-uri i ș
apoi având câte un thread pentru fiecare subtask se poate creste mult viteza de execu ie. ț
Aceasta afirmatie este general valabila pentru un SMS. Când se executa doua threaduri, ele
vor fi executate simultan, fiecare pe câte un procesor i astfel se realizează o cre tere ș ș
semnificativă a vitezei. Avantaje similare se ob in când se utilizează Java pe alte platforme de ț
calcul paralel i distribuit cum ar fi ș Sistemele cu Memorie Distribuita (SMD).
Concurenta thread-urilor .
25

Fară a intra intr-o discutie pe teme hardware, este bine de spus ca procesoarele
calculatoarelor pot executa doar o instructiune la un moment dat. De ce spunem ca thread-uri
diferite se execută in acelasi timp?
Pe o masina multiprocesor, thread-urile pot exista pe procesoare diferite in acelasi
timp fizic, aceasta mentinându-se valabil chiar daca procesoarele sunt pe calculatoare diferite
conectate într-o re ea. Dar i pe o masină cu un singur procesor, thread-urile pot împăr i ț ș ț
acela i procesor, rulând într-o manieră intretesuta, competi ia pentru timpii CPU creând iluzia ș ț
ca ele se execută simultan.
Aceasta iluzie pare reală atunci cind, de exemplu, 30 de imagini distincte pe secundă
captate de ochiul uman sunt percepute intr-un flux continuu de imagine. Aceasta comutare
între thread-uri are si ea un pret. Consumă timp CPU pentru ca acesta să înghe e starea unui ț
thread i să dezghete starea unui alt thread (schimbare de context). Dacă thread-urile ș
concurente sunt executate pe acelasi procesor i toate execută calcule atunci timpul total de ș
execu ie nu va lua mai mult decât timpul de execu ie al unui program secvential care ț ț
realizează acela i lucru. ș
Din moment ce într-un sistem monoprocesor thread-urile concură la timpul procesor
cum este posibila cresterea vitezei sistemului? Aceasta se realizează prin intreteserea unor
faze diferite ale mai multor thread-uri. Multe task-uri pot fi segmentate logic in tipuri de faze:
faza de calcul si faza I/O.
Faza de calcul necesita atentia maximă din partea CPU-ului prin utilizarea unor
metode de calcul.
Faza de I/O (intrare/iesire) necesita atentie maxima din partea perifericelor
(imprimante, hard discuri, plăci de retea, etc) i în aceste situa ii procesorul este în general ș ț
liber, asteptând ca perifericul să- i termine sarcina. Cresterea vitezei este obtinută prin ș
intreteserea fazelor. In timp ce un thread se află într-o fază de I/O asteptând ca o secven ă de ț
date sa fie încarcată de pe hard disk, un thread cu o fază de calcul poate ocupa procesorul i ș
când ajunge la o faza I/O, celălalt thread (care tocmai a terminat faza I/O proprie)poate începe
sa utilizeze CPU-ul.
Contextul thread-urilor si memoria distribuita
Thread-urile rulează în contextul unui program, folosind resursele acestuia. Fiecare
thread are propriile variabile i puncte de execu ie, dar variabilele globale sunt împăr ite de ș ț ț
toate thread-urile. Deoarece împart acela i spa iu (variabilele globale i alte resurse) toate ș ț ș
firele de execu ie pot accesa la un moment dat aceeasi dată. Pentru un programator într-un ț
sistem cu memorie distribuită, împartirea memoriei este un lucru transparent, realizat la un
26

nivel ascuns al sistemului de operare. Oricum, în cazul unor asemenea sisteme, trebuie avută o
aten ie sporită pentru minimizarea utilizării concurentă a variabilelor comune de către maiț
multe thread-uri, deoarece această situa ie ar putea degenera într-o sufocare a aplica iei. ț ț
Thread-urile Java sunt implementate de clasa Thread, iar actuala implementare a
thread-urilor este realizată de catre sistemul de operare.
In Java, fiecare thread este încapsulat intr-o clasă i rulează prin intermediul unor ș
metode specifice în instan a unei clase. ț
Aceasta instan ă nu este o instan ă a clasei ț ț Thread ci este o instan ă a unei clase ț
derivată din clasa Thread sau a unei clase care implementează interfata Runnable (Runnable
Interface).
Clasele care instantiază astfel de obiecte sunt numite "runnable classes" i obiectele ș
sunt numite "runnable objects". Executia unui thread începe cu apelarea unei metode din clasa
Runnable sau dintr-o subclasa a acesteia. Aceasta metodă se execută atâta timp cât ea există
i apoi thread-ul moare (aceasta implică faptul că pentru o metodă ce execută o bucla infinită,ș
thread-ul asociat nu moare niciodata).
Un thread poate sa fie terminat drept urmare a unui eveniment extern. Limbajul Java
ofera doua căi pentru crearea firelor de executie :
•Crearea unei clase care extinde clasa Thread din biblioteca de clase java.lang
•Crearea unei clase care implementeaza interfa a țRunnable din biblioteca de clase
java.lang
Clasa Thread de asemenea implementeaza interfata Runnable.
class TestThread extends Thread {
public void run() {
System.out.println ("Hello World!");
}
}
Exemplul de clasa derivată din clasa Thread suprascrie una din metodele sale – metoda
run(). Metoda run() este cea mai importantă deoarece con ine codul pe care thread-ul il va ț
executa. Pentru majoritatea thread-urilor aceasta metodă contine o bucla infinită. Pentru a
lansa in executie metoda run() mai întâi trebuie creată o instan ă a acestei clase, apoi se ț
apeleză metoda start() ce face thread-ul activ si invoca metoda run().
27

class Test {
public static void main(String Args[]) {
new TestThread().start();
}
}
Secven a de cod anterioară combinată cu clasa ț TestTread va afi a mesajul ș"Hello
world!" pe ecran. Ce se intampla de fapt aici? Metoda main() va porni thread-ul i se va ș
termina; thread-ul nu se va termina însă în acest moment. El va executa metoda run() până
când aceasta se termină. Metoda run() va afisa efectiv mesajul " Hello world!" pe ecran si apoi
va iesi. Cand si metoda main() i metoda șrun() se vor fi terminat, se poate reda controlul
sistemului. O alta modalitate de a crea thread-uri este aceea ca o clasă sa implementeze
interfa a ț
Mai există si alti constructori în clasa Thread, cum ar fi: Thread (ThreadGroup
,Runnable, String). Parametrul ThreadGroup asigneaza thread-ul la un grup de thread-uri –
multime de thread-uri ce permite tratarea unitara a tuturor thread-urile componente.
Parametrul de tip String suporta un nume pentru acest nou thread. Acest nume poate fi
folosit impreuna cu metoda getName() a clasei Thread pentru o referire de tip mnemonic a
unui thread. Acesti parametrii sunt optionali (de altfel exista 7 tipuri diferite de constructori
pentru clasa Thread).
Thread-uri daemon
Multe sisteme prezinta thread-uri cu scopul de a facilita diverse servicii (servicii de
I/O, ascultare pe socket, etc). Aceste thread-uri se afla majoritatea timpului in starea idle si
numai cind primesc un mesaj incep sa-si execute sarcina specifica. Aceste thread-uri sunt
cunoscute sub numele de "Daemon Threads". Orice thread poate deveni daemon prin apelarea
metodei proprii setDaemon() cu valoarea true. Se poate verifica starea unui thread prin
intermediul metodei isDaemon().
Starile thread-urilor
Creand o instanta a unui thread acesta nu este lansat. Sarcina de a lansa thread-ul in
executie este realizata de metoda start().
Un thread se poate gasi in diferite stari in functie de evenimentele petrecute.
28

1.Thread nou creat – Metoda run() nu este in executie, timpul procesor nu este inca
alocat. Pentru a porni un thread trebuie apelata functia start(). In aceasta stare se poate
apela de asemenea metoda stop(), care va distruge thread-ul.
2.Thread in executie – Thread-ul a fost lansat in executie cu metoda start(). Este thread-
ul pe care procesorul il executa in acest moment.
3.Thread gata de executie (runnable) – Thread-ul a fost startat dar nu se afla in executie
in acest moment.
4.Motivul ar fi acela ca thread-ul a renuntat la procesor apeland metoda yield(), sau din
cauza unui mecanism de programare a timpului procesor care a decis sa distribuie
acest timp altui thread. Thread-ul va putea trece in executie cind mecanismul de
programare va decide acest lucru. Atita timp cit exista un alt thread cu o prioritate mai
mare, thread-ul nu va trece in executie.
5.Thread nepregatit pentru executie (blocked) – Thread-ul nu poate fi executat din
anumite motive. Ar putea sa astepte terminarea unei operatii de tip I/O, sau s-a
apelat.una din metodele wait(), sleep() sau suspend().
Prioritatile thread-urilor
Fiecarui thread ii este atribuita o prioritate cuprinsa intre MIN_PRIORITY (egala cu
1) si MAX_PRIORITY (egala cu 10). Un thread mosteneste prioritatea de la thread-ul care l-a
creat, dar aceasta prioritate se poate modifica apelind metoda setPriority(); valoarea acestei
prioritati se poateobtine in urma apelului metodei getPriority().
Algoritmul de planificare intodeauna va lansa thread-ul cu prioritatea cea mai mare in
executie. Daca exista mai multethread-uri cu aceeasi prioritate maxima atunci procesorul le va
executa in maniera round-robin. Astfel un thread cu prioritate mai mica se poate executa
numai atunci cind toate thread-urile de prioritate mai mare sunt in starea non-runnable.
Prioritatea thread-ului
main() este NORM_PRIORITY (egala cu 5).
Grupuri de thread-uri
Fiecare thread apartine unui grup de thread-uri. Un grup de thread-uri este o multime
de thread-uri (si posibil grupuri de thread-uri) impreuna cu un mecanism de realizare a
operatiilor asupra tuturor membrilor multimii. Grupul implicit de thread-uri este implicit
numit main, si fiecare group de thread-uri nou creat apartine acestui grup, mai putin acelea
specificate in constructorul sau.
29

Pentru a afla pentru un thread la ce grup de thread-uri apartine se poate folosi metoda
getThreadGroup(). Pentru a crea propriul nostru grup de thread-uri, trebuie mai intii sa cream
un obiect ThreadGroup. Se poate folosi unul din acesti constructori:
•ThreadGroup(String) – creaza un nou ThreadGroup cu numele specificat.
•ThreadGroup(threadGroup, String) – creaza un nou ThreadGroup cu numele
specificat si apartinind la un anumit grup de thread-uri.
Dupa cum arata si al doilea constructor, un grup de thread-uri poate fi creat in interiorul
altui grup de thread-uri. Cel mai nou grup de thread-uri creat devine membru la cel mai vechi
realizindu-se astfel o ierarhie de grupuri. Pentru a crea un thread in interiorul unui grup de
thread-uri, altul decit grupul main trebuie
doar mentionat numele grupului atunci cind se apeleaza constructorul thread-ului.
In momentul in care avem mai multe thread-uri organizate intr-un grup de thread-uri
putem apela la operatii comune pentru toti membrii acestui grup.
Aceste operatii sunt in principal stop(), supend() and resume() care au aceeasi
semnificatie ca atunci cind se foloseste unsingur thread. Pe langa aceste operatii mai exista si
alte operatii specifice grupului de thread-uri.
2.3.3. Desenarea in Java
In afara posibilită ii de a utiliza componente grafice standard, Java oferă i ț ș
posibilitatea de control la nivel de punct (pixel) pe dispozitivul grafic, respectiv desenarea a
diferite forme grafice direct pe suprafata unei componente.
Desi este posibil, în general nu se deseneaza la nivel de pixel direct pe suprafata
ferestrelor. In Java a fost definit un tip special de componenta numita Canvas (pânza de
pictor), al carui scop este de a fi extins pentru a implementa componente cu o anumita
înfatisare. Asadar clasa Canvas este o clasa generica din care se deriveaza subclase pentru
crearea suprafetelor de desenare.
Constructorul Canvas() creeaza o plansa, adica o componenta pe care se poate desena.
Plansele nu pot contine alte componente grafice, ele fiind utilizate doar ca suprafete de
desenat sau ca fundal pentru animatie.
Constructor
Canvas ()
Metode
addNotify () Creates the peer of the canvas.
30

paint(Graphics) Paints the canvas in the default background color.
Metoda paint() a clasei Canvas() picteaza plansa în culoarea implicita a fundalului.
Pentru a redesena plansa cu un alt continut, se recomanda supradefinirea acestei metode
implicite.
class Tablou extends Canvas {
public void paint(Graphics g) {
//…desenare continut
}
}
Toate desenele care trebuie sa apara pe o suprafata de desenare se realizeaza în metoda
public void paint(Graphics g), în general apelata intern în urma unui apel repaint(), ori de câte
ori componenta respectiva trebuie reafisata. In general desenarea se poate face :
•pe o portiune de ecran,
•la imprimanta sau
•într-o zona virtuala de memorie
Inainte ca utilizatorul sa poata desena el trbuie sa obtina un context de desenare pentru
fereastra careia îi apartine regiunea pe care se va desena. Acest context grafic este specificat
prin intermediul obiectelor de tip Graphics primite ca parametru în functia paint(). In functie
de dispozitivul fizic pe care se face afisarea (ecran, imprimanta, plotter, etc) metodele de
desenar au implementari interne diferite, transparente utilizatorului.
Asadar, clasa Graphics ofera posibilitatea de a desena linii, forme geometrice, imagini
si caractere.
Constructor
Graphics ()
Constructs a new Graphics Object.
Metode
clearRect (int, int, int, int)
Clears the specified rectangle by filling it with the current background color of the
current drawing surface.
clipRect(int, int, int, int)
31

Clips to a rectangle.
copyArea(int, int, int, int, int, int)
Copies an area of the screen.
create()
Creates a new Graphics Object that is a copy of the original Graphics Object.
create(int, int, int, int)
Creates a new Graphics Object with the specified parameters, based on the original
Graphics Object.
dispose()
Disposes of this graphics context.
draw3DRect(int, int, int, int, boolean)
Draws a highlighted 3-D rectangle.
drawArc(int, int, int, int, int, int)
Draws an arc bounded by the specified rectangle from startAngle to endAngle.
drawBytes(bytest, int, int, int, int)
Draws the specified bytes using the current font and color.
drawChars(charst, int, int, int, int)
Draws the specified characters using the current font and color.
drawImage(Image, int, int, ImageObserver)
Draws the specified image at the specified coordinate (x, y).
drawImage(Image, int, int, int, int, ImageObserver)
Draws the specified image inside the specified rectangle.
drawImage(Image, int, int, Color, ImageObserver)
Draws the specified image at the specified coordinate (x, y), with the given solid
background Color.
drawImage (Image, int, int, int, int, Color, ImageObserver)
Draws the specified image inside the specified rectangle, with the given solid
background Color.
drawLine(int, int, int, int)
Draws a line between the coordinates (x1,y1) and (x2,y2).
drawOval(int, int, int, int)
Draws an oval inside the specified rectangle using the current color.
drawPolygon(intst, intst, int)
Draws a polygon defined by an array of x points and y points.
32

drawPolygon(Polygon)
Draws a polygon defined by the specified point.
drawRect(int, int, int, int)
Draws the outline of the specified rectangle using the current color.
drawRoundRect(int, int, int, int, int, int)
Draws an outlined rounded corner rectangle using the current color.
drawString(String, int, int)
Draws the specified String using the current font and color.
fill3DRect(int, int, int, int, boolean)
Paints a highlighted 3-D rectangle using the current color.
fillArc(int, int, int, int, int, int)
Fills an arc using the current color.
fillOval(int, int, int, int)
Fills an oval inside the specified rectangle using the current color.
fillPolygon(intst, intst, int)
Fills a polygon with the current color using an even-odd fill rule (otherwise known as
an alternating rule).
fillPolygon(Polygon)
Fills the specified polygon with the current color using an even-odd fill rule
(otherwise known as an alternating rule).
fillRect(int, int, int, int)
Fills the specified rectangle with the current color.
fillRoundRect(int, int, int, int, int, int)
Draws a rounded rectangle filled in with the current color.
finalize()
Disposes of this graphics context once it is no longer referenced.
getClipRect()
Returns the bounding rectangle of the current clipping area.
getColor()
Gets the current color.
getFont()
Gets the current font.
getFontMetrics()
Gets the current font metrics.
33

getFontMetrics(Font)
Gets the current font metrics for the specified font.
setColor(Color)
Sets the current color to the specified color.
setFont(Font)
Sets the font for all subsequent text-drawing operations.
setPaintMode()
Sets the paint mode to overwrite the destination with the current color.
setXORMode(Color)
Sets the paint mode to alternate between the current color and the new specified color.
toString()
Returns a String object representing this Graphic's value.
translate(int, int)
Translates the specified parameters into the origin of the graphics context.
Prin dreptunghi de decupare (clip area) se întelege zona din suprafata componentei de
afisare în care sunt vizibile operatiile efectuate. Orice operatie efectuata în afara acestui
dreptunghi nu are nici un efect. Stabilirea unui dreptunghi de decupare se realizeaza prin :
clipRect(int x, int y, int width, int height)
Proprietatile contextului grafic
•culoarea de desenare
Color getColor()
void setColor(Color)
•originea coordonatelor – poate fi modificata prin :
translate(int x, int y)
•modul de desenare
void setXorMode() – scriere “sau exclusiv”
(culoare + fundal = culoare,
culoare + culoare = fundal,
(culoare + culoare1) + culoare = culoare1 )
void setPaintMode() – suprascriere
•fontul curent pentru desenarea caracterelor
Font getFont()
34

void setFont(Font)
•zona de decupare (în care sunt vizibile modificarile)
Shape getClip()
void setClip(Shape)
void setClip(int x, int y, int w, int h)
In Swing, pentru a eficientiza desenarea, obiectul de tip Graphics primit
ca argument de metoda paintComponent este refolosit pentru desenarea componentei, a
chenarelor ¸si a fiilor sai. Din acest motiv este foarte important ca atunci cand supradefinim
metoda paintComponent sa ne asiguram ca la terminarea metodei starea obiectului Graphics
este aceea¸si ca la inceput.
Acest lucru poate fi realizat fie explicit, fie folosind o copie a contextului
grafic primit ca argument:
// 1.Explicit
Graphics2D g2d = (Graphics2D)g;
g2d.translate(x, y); // modificam contexul
…
g2d.translate(-x, -y); // revenim la starea initiala
// 2. Folosirea unei copii
Graphics2D g2d = (Graphics2D)g.create();
g2d.translate(x, y);
…
g2d.dispose();
2.3.4.Java Swing
Tehnologia Swing face parte dintr-un proiect mai amplu numit JFC (Java
Foundation Classes) care pune la dispozitie o serie intreaga de facilitati pentru
scrierea de aplicatii cu o interfata grafica mult imbogatita functional si
35

estetic fata de vechiul model AWT.
In JFC sunt incluse urmatoarele:
•Componente Swing
Sunt componente ce inlocuiesc si in acelasi timp extind vechiul set oferit de
modelul AWT.
• Look-and-Feel
Permite schimbarea iınfatisarii si a modului de interactiune cu aplicatiain functie
de preferintele fiecaruia. Acelasi program poate utiliza diversemoduri Look-and-
Feel, cum ar fi cele standard Windows, Mac,Java, Motif sau altele oferite de
driver si dezvoltatori, acestea putand fiinterschimbate de catre utilizator chiar la
momentul executiei .
•Accessibility API
Permite dezvoltarea de aplicatii care sa comunice cu dispozitive utilizatede catre
persoane cu diverse tipuri de handicap, cum ar fi cititoarede ecran, dispozitive de
recunoastere a vocii, ecrane Braille, etc.
• Java 2D API
Folosind Java 2D pot fi create aplicatii care utilizeaza grafica la unnivel avansat.
Clasele puse la dispozitie permit crearea de desene complexe,efectuarea de
operatii geometrice (rotiri, scalari, translatii, etc.),prelucrarea de imagini, tiparire,
etc.
• Drag-and-Drop
Ofera posibilitatea de a efectua operatii drag-and-drop intre aplicatiiJava si
aplicatii native.
•Internationalizare
Internationalizarea si localizarea aplicat¸iilor sunt doua facilitati extremde
importante care permit dezvoltarea de aplicatii care sa poata fi configuratepentru
exploatarea lor in diverse zone ale globului, utilizandlimba si particularitatile
legate de formatarea datei, numerelor sau amonedei din zona respectiva.
36

CAPITOLUL 3:PREGĂTIREA MEDIULUI DE LUCRU
3.1. Instalare NetBeans
NetBeans este un proiect open-source, cu o bază de utilizatori foarte mare, o
comunitate în creștere și peste 100 de parteneri (în creștere!) din toată lumea. Sun
Microsystems a fondat proiectul open source NetBeans în iunie 2000 și continuă să fie
principalul sponsor al proiectului.
Astăzi există două produse: NetBeans IDE și platforma NetBeans.
NetBeans IDE este un mediu de dezvoltare – un instrument pentru programatori,
pentru scrierea, compilarea, testarea, depanarea, proiectarea și instalarea programelor. Este
scris în Java – dar poate accepta orice limbaj de programare. De asemenea, există un număr
imens de module pentru extinderea NetBeans IDE. NetBeans IDE este un produs gratuit, fără
restricții legate de modul de utilizare.
De asemenea, este disponibilă Platforma NetBeans ; o bază modulară și extensibilă,
utilizată drept conector software pentru crearea aplicațiilor desktop puternice. Partenerii ISV
oferă Plugin-uri cu valoare adăugată, care se integrează ușor în platformă și care pot fi
utilizate, de asemenea, la dezvoltarea propriilor instrumente și soluții.
Ambele produse sunt open-source și gratuite pentru uz comercial și necomercial.
Codul sursă este disponibil pentru reutilizare, conform Common Development and
Distribution License (CDDL – Licența de distribuție și dezvoltare comună).
Aplicatia BattleShip a fost realizată in mediul de dezvoltare NetBeans IDE 6.7.
Acesta se downloadeaza gratut de pe www.netbeans.org.
Pentru a putea lucre in acest mediu trebuie sa fie instalat impreuna cu JDK, această
platform fiind necesară pentru a putea realiza aplicatii Java. JDK poate fi downloadează
gratuit de pe java.sun.com.
NeatBeans IDE se instaleaza pe computer in functie de preferintele utilizatorului
(unde sa fie instalat, update-uri). Dup ace a fost instalat la rularea in executie a mediului
Netbeans IDE va aprea un splashscreen cum este aratat mai jos:
37

Dupa incarcarea modulelor necesare rulării, va incepre execu ia propriu-zisă a medului ț
de dezvoltare.
38

Dupa această etapă, utilizatorul poate să: creeze noi aplicatii java, să deschidă proiecte
(realizate in NeatBeans), sa vizualizede demo-uri pentru a întelege cum se lucreaza cu
NetBeans etc.
Cu ajutorul acesui mediu se pot crea foarte usor fisiere executabile (jar), cu ajutorul
cărora aplica ia poate fi rulata independent, singura condi ie fiind ca pe calculatorul unde este ț ț
rulată să existe instalat JVM(Java Virtual Machine).
Pentru aplicatii mai complexe pot fi adaugate librarii, jar-uri (JMathTools,
metadataextractor etc), in functie de cerintele aplicatie
3.2. Configurare client-server
Pentru a rula aplica ia Battleship este necesar ca pe calculatorul unde se va executa ț
server-ul,dacă este instalat sistemul de oprare Windows, firewall-ul sistemului de oprare să fie
dezactivat pentru a permite conectarea cilentilor la server.
Pentru această aplica ie nu trebuie instalat nici un program, doar JVM pe computer. ț

39

CAPITOLUL 4:DESCRIEREA APLICATIEI
4.1. Introducere
Cel mai întâlnit model de programare a aplicațiilor de rețea poartă numele și de
aplicații Client-Server . Conceptul este simplu: o mașină client face o cerere pentru o
informație sau trimite o comandă la un server; ca răspuns, serverul trimite datele cerute sau
rezultatul comenzii. De cele mai multe ori, serverul răspunde numai la clienți; nu inițiază
comunicațiile.
Așadar, funcția serverului este de asculta pentru o conexiune. Aceste lucru este
realizat printr-un obiect server care a fost special creat. Funcția clientului este de a încerca să
stabilească o conexiune cu serverul pentru care este creat un obiect client. Odată stabilită
conexiunea, se poate observa că la cele două capete (server și client), conexiunea este
transformată într-un obiect IO Stream și din acel moment aceasta poate fi tratată ca și cum s-
ar scrie sau s-ar citi dintr-un fișier.
La nivelul transport, internetul are două protocoale principale: User Datagram
Protocol (UDP, neorientat – conexiune) si Transmission Control Protocol (TCP, orientat –
conexiune).
UDP este un protocol simplu, care nu asigură verificarea erorilor sau controlul
fluxului, astfel fiind necesar ca aplicația să efectueze aceste verificări; se folosește cu
precădere la streaming multimedia. TCP este un protocol care asigură corectitudinea datelor,
efectuând atât verificarea erorilor cât și controlul fluxului; este protocolul de bază pentru
transmiterea informațiilor în rețea .
Avantajele utilizării acestui protocol:
este un protocol de rețea rutabil suportat de majoritatea sistemelor de operare;
reprezintă o tehnologie pentru conectarea sistemelor diferite;
Utilizează utilitare de conectivitate standard pentru a accesa și transfera date între sisteme
diferite;
este un cadru de lucru robust, scalabil între platforme client / server;
reprezintă o metodă de acces la resursele Internet;
permite comunicarea într-un mediu eterogen, deci se pretează foarte bine pentru
conexiunile din Internet (care este o rețea de rețele eterogene atât din punct de vedere
hardware, cât și software);
40

furnizează un protocol de rețea rutabil, pentru rețele mari, fiind folosit din acest motiv
drept protocol de interconectare a acestor rețele;
TCP/IP este o suită de protocoale, dintre care cele mai importante sunt TCP și IP, care a
fost transformat în standard pentru Internet de către Secretariatul pentru Apărare al Statelor
Unite, și care permite comunicația între rețele eterogene (interconectarea rețelelor).
În această lucrare am exemplificat modul de funcționare al protocololului TCP prin
intermediul unor aplicații client-server(BattleShip).
4.2.Structura aplicatiei
Aplicatia con ine de fapt două aplica ii care rulează separat: un server si un client, ț ț
fiind realizată in acest mod deoarece pe calucaltorul pe care este rulat Serverul, nu e
obligatoriu sa fie rulat Clientul si invers.
Aplicatia Server
BattleShipServer este o aplica ie realizată in Java având următoarele atribu ii: ț ț
-Creează uun socket pentru a comunica cu clien ii ț
-Prime te date de la clien i ș ț
-Trimite date la clien i ț
Aceasta aplica ie este o aplica ie multi-client, adcă la un moment dat la server pot fi ț ț
conecta i mai mul i clien i, ț ț ț
BattleShipServer are in componen ă un singur pachet PacServer care con ine patru ț ț
clase Java:
-ChatCommunication
-ChatServer
-ClientObject
-CommonSettings
Structura claselor:
ChatComunication
41

ChatServer
ClientObject
42

CommonSettings
În acest modul au fost definite anumite comenzi pentru a putea distinge clien ii ț
conecta i, pentru a trimite mesaje la to i clien ii sau numai la naumi i clien i etc astfel: ț ț ț ț ț
-HELO- ini ializaeza conexiunea la server. ț
-QUIT- inchide conexiunea pentru clientul de la care s-a primit comanda
-MESS – trimite un mesaj general la to i clien ii ț ț
-PRIV – trimite un mesaj la un anumit client
Aplica ia este responsabilă cu eviden a clin ilor conecta i, usernam-ul si ț ț ț ț
primirea,trimiterea de mesaje.
Clasa principală a acestei aplica ii este ChatServer, care implementeaza interfa a ț ț
grafică pentru comunicarea cu utilizatorul, thread-urile pentru comuncarea cu clien ii, ț
trimiterea mesajelor către clien i, adăgarea clien ilor conecta i, stergerea clien ilor in ț ț ț ț
momentucl cand conexiunea către ace tia a fost închisă. ș
Aplica iei BattleShipServer va arăta, in momentul execu iei, astfel: ț ț
43

După apasarea butonului START SERVER, serverul este pornit fiind disponibil celor
care doresc să joace acest joc, si care au aplica ia client. ț
In acest moment, aplica ia a creat un socket pe portul 1436, si a teaptă clientii care ț ș
doresc să se conecteze.
Dacă un client se conectează la server, acesta av creea un thread (fir de execu ie) ț
separat pentru deserirea lui, iar când clientul trimite comanda QUIT i firul de execu ie ș ț
corespunzător va fi inchis.
Acest lucru se realizeaza prin intermediul clasei ChatCommunication, care
gestioneaza mesajele primite, lanseaza in execu ie thread-ul corespunzator fiecărui client ț
folosind metota run(), metodă apelata in momentul lansării în execu ie a unui thread si ț
răspunde cererilor clientului:
public void run()
{
while(thread != null)
{
try {
RFC = inputstream.readLine();
if(RFC.startsWith("HELO"))
44

{
Parent.AddUser(socket,RFC.substring(5));
}
if(RFC.startsWith("QUIT"))
{
Parent.RemoveUser(RFC.Substring(5,RFC.indexOf("~")),
RFC.substring (RFC .indexOf("~")+1),REMOVE_USER);
QuitConnection();
}
{
if(RFC.startsWith("MESS"))
{
Parent.SendGeneralMessage(socket,RFC.substring(RFC.indexOf(":")
+1) ,RFC.substring(RFC.indexOf("~")
+1,RFC.indexOf(":")),RFC.substring(5, RFC.indexOf("~")));
}
if(RFC.startsWith("PRIV"))
{
Parent.SendPrivateMessage(RFC.substring(RFC.indexOf("~")+1),
RFC.substring(5,RFC.indexOf("~")));
}
}
Clasa ClientObject con ine metode care returnează variabilele necesare pentruț
eviden a clientilor: username,socket,thread. ț
public void setSocket(Socket socket)
{
ClientSocket = socket;
}
45

public void setUserName(String UserName)
{
ClientUserName = UserName;
}
public Socket getSocket()
{
return ClientSocket;
}
public String getUserName()
{
return ClientUserName;
}
Aplica ia Client ț
BattleShipClient este, de fapt, aplica ia cu ajutorul căreia utilizatorul paote sa joace ț
BattleShip. Pentru conectarea la server folose te socket-uri i thread-uri, iar pentru desenarea ș ș
navelor, desenarea intei, a loviturilor foloseste API-ul Java2D. ț
Aceasta aplica ie con ine patru pachete: ț ț
-BattleShipSingle:con ine clasele Java necesare utilizatorului sa joace jocul ț
singur,cu calculatorul.
-Main: in acest pachet este prezentă clasa principala a aplica iei. ț
-PacClient: clasele necesare conexiunii la server
-BattleShip: clasele pentru jocul în re ea. ț
Pachetul BattleShipSingle con ie clasele: ț
-BattleShipSingle este clasa principală pentru acest pachet, aceasta fiind lansată
în execu ie când utilizatorul joacă cu computerul. În această clasă este ț
implementată intefa a grafică cu utilizatorul si sunt adaugate celelate ț
componente.
-Game adaugă componentele necesare jocului
-GridArea este clasa care con ine matricea cu pozi iile navelor, event-urile ț ț
pentru click si metodele pentru validare pozi iilor navelor. ț
46

-PlayingField este o clasă cu ajutorul căreia se pozi ionează navele i con ine ț ș ț
metodele care verifică daca o afost lovită sau nu o nava, metodele de desenare
a navelor si doua clase care extind clasa GridArea (LeftField,RightField)
pentru a putea juca jocul.
-RunGame este clasa cu ajutorul căreia je jocaă jocul Battleship. Aceasta clasă
con ine un thread care gestioneaza evenimente i desenarea.ț ș
-Sound este clasa care implementeaza sunetele pentru diferite ac iuni ale ț
jucătorului.
Structura claselor:
BattleShipSingle Game
GridArea PlayingField
47

RunGame Sound
Desenarea navelor i a intei precum i a imaginiilor cu lovit sau nu este realizată cu ș ț ș
ajutorul API-ului Java2D prin intermediul metodei paint() care este apelată ori de cate ori se
modifică ceva.
Pentru desenarea imaginilor cu lovit sau nu i a intei: ș ț
48

public void paintComponent(Graphics g)
{
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
int current;
for (int y=0; y<10; y++) for (int x=0; x<10; x++)
{
if (area[x][y]!=0&&bturn==1)
{
current = area[x][y]/10;
if ((current/10)%10!=0) /
{
if (current%10!=0) g2.drawImage(PlayingField.fire, 25*x, 25*y, this);
else g2.drawImage(PlayingField.splash, 25*x, 25*y, this);

}
}
}
if (cursorLocation!=null&&bturn==1)
g2.drawImage(PlayingField.target, 25*(int)cursorLocation.getX(),
25*(int)cursorLocation.getY(), this);
}
Pachetul Main con ie o singura clasă: MainGui: Această clasă este folosită in ț
momentul pornirii aplica iei pentru ca utilizatorul să aleaggă modul cum va juca: vs computer ț
sau multyplayer.
49

Pachetul PacClient are în componen ă următoarele clase: ț
-ChatClient clasa principala cu ajutorul căreia se implementează interfa a pentru ț
conectarea la server i thread-urile necesare acestei conexiuni. ș
-CommonSettings con ine setări pentru client: portul de ascultare, titlui, ț
dimensiuni
-ListViewCanvas metodele pentru adăugarea clien ilor conecta i la server, ț ț
stergerea lor, trimiterea de mesaje
-PrivateChat2 este clasa care trimite mesaje la anumi i useri, prime te mesaje de ț ș
la anumi i useri. Cu ajutorul acestei clase jocul poate fi jucat de doar doi ț
clien i, char dacă la server sunt conecta i mai mul i useri. ț ț ț
-Game este clasa cu ajutorul căreia utilizatorul pote sa aleaga dacă doreste să
joce jocul cu userul de la care a venit cererea sau nu.
-NoGame apare in momentul când userul la către care utilizatorul a trimis
cererea pentru a juca nu a fost de acord.
-InformationDialog cu ajutorul acestei clase clientul introduce usernam-ul si
adresa server-ului
-TapPannel este calsa care afi eaza userii conectatii si cu ajutorul căreia pot fi ș
trimise cereri pentru a juca BattleShip în re ea. ț
Structura claselor
ChatClient CommonSettings
50

ListViewCanvas PrivateChat2
51

TapPannel Game
Pachetul BattleShip con ine aceelea i clase ca i pachetul BattleShipSingle singura ț ș ș
difere ă fiind în clasa RunGame, care nu mai ia rezultatetele de pe calculatorul gazda ci ț
asteatptă sa primească de la server.
Structura acestei clase este:
52

4.3. Simularea jocului
Pentru inceput trebuie pornit serverul:
După ce serverul a fost pornit, la acesta se pot conecta mai mul i client. Jaocul se ț
poate juca în re ea dacă există cel pu in doi client conecta i la un moment dat. ț ț ț
La lansarea in execu ie a aplica iei BattleShipClient se va deschide o fereastră din care ț ț
utilizatorul trebuie sa aleaga modul in care va juca:
53

-Cu computer-ul
-Multiplayer
Dacă va allege “New game”, se va deschide fereastra pentru a juca BattleShip cu computer-ul
i cu ajutorul căreia va a eza navele.ș ș
După ce navele au fost a ezate, se poate începe jocul. ș
54

După ce utilizatorul dă click pe o căsu ă aceasta se colorează în func ie dacă a fost ț ț
lovită o navă a computer-ului sau nu. După ce utilizatorul a a dat click este randul computer-
ului.
Jocul se termină când computerul sau utilizatorul a lovit toate navele celuilat.
Dacă utilizatorul vrea să joace în re ea i alege op iunea “Multyplayer”, se va deschide ț ș ț
o fereastră unde trebuie să introducă username-ul i adresa serverului. ș
55

După ce a fost introdus Nickanme-ul si adresa server-ului, la apăsarea butonului
Connect, aplica ia se va conecta la server dacă acesta este pornit. Dacă serverul nu este pornit, ț
se va afi a un meaj de eroare. ș
După conectare, vor fi afi a i to i clien ii conecta i iar pentru a juca BattleShip cu unul ș ț ț ț ț
din ei, se selectează numele acestuia i se apasă butonul “Start game”. ș
56

La apăsarea butonului ‘Start game” un mesaj va trimis catre utilizatorul al cărui nume
este selectat. La randul lui acesta va primi un mesaj cu întrebarea dacă dore te sa joace ș
BattleShip cu clientul de la care s-a primit mesajul
Dacă acesta este de acord se va deschid o nouă fereastră unde cei doi trebuie sa î i ș
a eze navele, iar după ce amândoi -au a ezat navele pot începe joculș ș ș
Lovitura de început o are cel care trimite cererea pentru joc.
Fereastra pentru jucătorul care are lovitura de început va arăta astfel:
57

După ce a dat click pe o pozi ie de câmpul oponentului, pe acea pozi ie va apărea o ț ț
imagine in func ie dacă a lovit o navă sau nu. După ce a dat click va trebui să astepte ca i ț ș
celalat jucător să facă o mutare.
Utilizatorul care a fost de acord să joce BattleShip, după ce a a ezat navele va trebui sa ș
a tepte prima lovitură de la celălalt. ș
58

După ce acesta a efectuat prima mutare, pe campul sau va apărea locul unde a dat click
celalat si dacă a lovit o navă sau nu. În acest moment, va fi randul lui sa lovească.
A a va arăta tabla de joc a utilizatorului Mihai dupa câteva mutări.ș
59

Jocul se va termina când unul dintre cei doi jucători a reu it să lovească toate navele ș
celuilat. În acel moment, la fiecare utilizator va fi afi ată o fereastră care îl anun ă ca a ș ț
castigat sau a pierdut.
După apăsarea butonului OK se va deschide fereastra principala cu userii i pot începe ș
alt joc in modul explicat mai sus.
60

CAPITOLUL 5: CONCLUZII
În ultimul deceniu, arhitectura client/server a ajuns cel mai cunoscut model pentru
aplicatiile de retea. Astăzi, multe dintre aplicațiile cu care suntem familiarizați sunt
client/server: Web-ul, e-mail, ftp, telnet, și așa mai departe.
Chiar dacă tot mai mulți gameri își îndreaptă atenția către console , viitorul jocurilor
pentru PC pare unul din ce în ce mai sumbru curile pentru PC vor evolua in tandem cu
procesoarele, placile grafice si monitoarele. Conform viziunii lui Taylor, ecrane cu rezolutii
impresionante, de 3800 x 2400 px, vor fi disponibile in anii urmatori, avand dimensiuni de cel
putin 30". Jocurile si motoarele ce stau la baza lor vor evolua si ele, ajungand pana la a simula
indeaproape realitatea, dar pentru aceasta vor fi necesare procesoare grafice foarte puternice.
Taylor considera vital sa se accorde atentie viziunilor creatorilor de jocuri si simularea
dorintelor si ideilor lor cat mai fidel, adaugand din plin elemente "eye candy" pentru a atrage
si capta utilizatorul printr-o grafica de senzatie.
Taylor uită că principalul consumator de jocuri pentru PC are o varstă cuprinsă intre 15 si 25
de ani și nu dispune de conturi in banca cu multe zerouri. Pentru el, a avea nevoie de un
sistem de zeci de mii de dolari pentru a putea rula ultimele titluri din Diablo sau Need for
Speed nu este o optiune viabilă. Deloc. Asadar, conform planurilor de viitor ale
reprezentantului Nvidia, jocul pentru PC se va transforma dintr-un produs de masă intr-unul
exclusivist, ce va fi admirat dar si urat in acelasi timp de cei multi, care nu il vor putea rula pe
sistemele lor de acasa.
Reteta jocurilor cu grafica extraordinara nu este neaparat una de succes. A se vedea
cazul actual al consolelor PlayStation 3, de departe cele mai potente și calitative, care sunt cu
mult mai prost vandute decat concurentele Nintendo Wii? De ce? Pentru ca un joc este un
angrenaj complex intre grafică, costuri, cerinte și mai ales gameplay. Abia in momentul în
care vor exista produse care sa bifeze toate acestea puncte, vom putea spune ca viitorul
jocurilor pentru PC va fi altfel decat acum.
Jocurile care folosesc o arhitectură client-server au reprezintă viitorul jocurilor pc,
video, console find folosite de toate categoriile de vasta de la copii de 4 ani si pana la
varstnici. Jocurile multyplayer reprezinta viitorul jocurilor video indiferent pe ce vor fi ele
jucate: PC sau console.
61

BIBLIOGRAFIE
•M. Tim Jones – BSD Sockets Programming from a Multi-Language Perspective,
Charles River Media, 2004
•G. Stoian, C.-I. Popirlan, Tehnologii java pentru dezvoltarea aplicatiilor . Editura
Universitaria, Craiova, 2009.
•Michael Morrison – Internet Game Programming with Java, Sams.net Publishing,
1996
•Bruce Eckel-Thinking in Java, Prentice Hall,2006
•Jerry Ablan –Developing Intranet Applications with Java, Sams.net Publishing, 1996
•Kenneth L. Calvert -TCP/IP Sockets in Java, The Morgan Kaufmann Practical Guides
Series
•http://www.calsoftlabs.com/whitepapers/java-networking.html
62