Sunteți pe pagina 1din 62

UNIVERSITATEA DIN CRAIOVA FACULTATEA DE MATEMATIC I INFORMATIC SPECIALIZAREA INFORMATIC

LUCRARE DE LICEN

Coordonator tiinific : Asist.univ.dr. Claudiu-Ionu Poprlan

Absolvent: Grosu Mihai Constantin

CRAIOVA - 2010-

UNIVERSITATEA DIN CRAIOVA FACULTATEA DE MATEMATIC I INFORMATIC SPECIALIZAREA INFORMATIC

Aplicatii JAVA Client-Server BattleShip

Coordonator tiinific : Asist.univ.dr. Claudiu- Ionu Poprlan

Absolvent: Grosu Mihai Constantin CRAIOVA - 2010-

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:PREGTIREA 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

CAPITOLUL 1 INTRODUCERE
Notiuni introductive Jocuri
Un joc este o activitate recreaional n care sunt implicai unul sau mai muli juctori, fiind definit printr-un scop pe care juctorii ncearc s-l ating i un set de reguli care determin ce pot face juctorii. Jocurile pot implica un singur juctor, dar mai des implic o competiie ntre doi sau mai muli juctori. Ct timp respect regulile, de obicei sunt mai multe alegeri pe care juctorul le poate face. Nerespectarea regulilor se numete triare. n cadrul ntregii istorii umane, oamenii au jucat jocuri ca o surs de divertisment pentru ei nii i pentru alii i exist o varietate enorm de jocuri. Un joc video este un joc electronic n care se interacioneaz cu o interfa grafic pentru a genera rspuns vizual pe un ecran. Jocurile video n general au un sistem de recompensare a utilizatorului, de obicei se ine scorul, acest sistem depinznd 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 folosete dispozitiv de control un periferic de intrare, de obicei butonarea unui joystick (jocuri din arcade-uri), o combinaie tastatur & maus/trackball sau un controller, ori o combinaie dintre cele de mai sus Jocurile pentru computer constituie o categorie de aplicaii software care este destinat distraciei. De la apariia acestora, n lumea computerelor, n anii 1970, pn astzi, industria a evoluat, astfel c putem vorbi cu uurin de multe evenimente de prezentare a jocurilor, cum ar fi E3 sau CeBit la nivel mondial sau CERF n Romnia, precum i de cteva organizaii de juctori profesioniti. 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 cri sau mas)

La unele tipuri de jocuri se poate aduga prefixul "MMO", care nseamn "Massively Multiplayer Online", reprezentnd un joc care se poate juca numai online, in care sute de mii de jucatori joaca in acelasi timp, in aceeasi lume. Cele mai multe MMO-uri sunt MMORPGuri. Railroad Tycoon II Call of Duty Cossaks - The art of war Starcraft Tomb Raider Hitman Hattrick Midnight Club II Need for Speed Broken Sword 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

Cteva exemple de jocuri strategice sunt:

Pharaoh Rome Total War Rise of Nation Stronghold Stronghold Crusader Stronghold 2 Stronghold Legends World of Warcraft Zeus-Master of Olympus Dei 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 ctre studenii 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 juctorul comunica cu calculatorul prin introducere anumitor comenzi de la tastatur. Primul text- adventure Aventuraa 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 ncepand sa devina un factor important n jocuri. O data cu dezvoltarea internetului la scar foarte larg a crescut i piaa 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 cunoate oameni din diferite zone isunt un mod de relaxare de asemenea.

Obiective
Realizarea unei aplicaii client-server in Java Exemplificarea modului de lucru cu soket-uri i thread-uri Folosirea limbajului de programare Java pentru a creea o aplicaie stabil i uor de folosit
6

Importana Internetului realizarea aplicaiilor bazate pe arhitectura client-server

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 apariia programrii orientate pe obiecte).

este neutru din punct de vedere arhitectural, cu alte cuvinte Java este un limbaj
independent de platforma de lucru, aceeai aplicaie rulnd, fr nici o modificare, pe sisteme diferite cum ar fi Windows, UNIX sau Macintosh, lucru care aduce economii substaniale firmelor care dezvolt aplicaii pentru Internet.

limbajul Java este modelat dup C si C++, trecerea de la C, C++ la Java fcndu-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, asigurnd mecanisme
stricte de securitate a programelor concretizate prin: verificarea dinamic a codului pentru detectarea secvenelor periculoase, impunerea unor reguli stricte pentru rularea programelor lansate pe calculatoare aflate la distanta (acestea nu au acces la reeaua local, la fiierele stocate n sistemul local i nu pot lansa n executie programe locale), etc.

permite creearea unor documente Web mbuntite cu animaie si multimedia. a fost proiectat pentru a fi folosit n medii distribuite si sisteme deschise. 2.
Evolutia limbajului JAVA

In 1991, firma SUN, mergnd pe direcia dezvoltrii sistemelor deschise de lucru n reea, 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 aprut 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 trziu, avea s se numeasc Java. De asemenea grupul Green avea sa-si schimbe numele nti n FirstPerson, apoi n JavaSoft. Abia dupa ce a fost nfiinata compania Netscape Communications Corporation, cei de la JavaSoft s-au orientat ctre Internet si Web, mediul multiplatforma distribuit al retelei Internet fiind perfect pentru testarea proiectului. In prezent licena pentru tehnologia Java a fost acordat unor firme precum IBM, Microsoft, Sillicon Graphics, Adobe si Netscape.

3.

Java : un limbaj compilat si interpretat

In funcie de modul de execuie 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 instruciuni masin; avantaj : simplitate; dezavantaje : viteza de execuie 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 dect pe platforma pe care a fost compilat. Programele Java pot fi att interpretate ct 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 instruciuni care seamn cu codul scris n limbaj de asamblare. Codul main este executat direct de ctre 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 execuie 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 instruciuni masin, ntrzierea interpretarii fiind nsa foarte mic datorit asemnrii dintre codul de octeti si limbajul de asamblare i din acest motiv execuia 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 acioneaz apoi ca un intermediar ntre Masina virtuala Java si maina real pe care este rulat programul.

Aplicatia utilizatorului Obiecte Java Masina virtuala Java UNIX Windows Sisteme de operare

Macintosh

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 obine 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 Cului si va oblig s folosii conceptele solide ale POO. Conceptele programarii orientate pe obiecte cuprind :

Obiectele ncapsularea si transmiterea de mesaje Clasele Bibliotecile (numite pachete, n Java) Motenirea Modificatorii de acces
Obiectele :
10

unitatea elementara a POO starea obiectului este dat de variabile de instan comportamentul obiectului este dat metode uor 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
respective

- accesibile doar obiectelor din aceeasi clas

2. Protejate - accesibile obiectelor din aceeasi clas si din subclasele clasei 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 reea 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 att obiecte memorate local ct si obiecte stocate pe
calculatoare aflate la distant

este compatibil cu mediile de lucru n reea (poate fi utilizat n reele complexe) i


accept direct protocoalele de reea obisnuite cum ar fi FTP si HTTP

B.

Asigurarea performanei ridicate

compilatorul si sistemul de executie ofer o viteza ridicat rularii programelor are ncorporate posibiliti de execuie multifilar (rularea simultan a mai multor
procese) folosind un sistem de acordare de prioritai 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 ntrzierea legrii obiectelor i
legarea dinamic a claselor n timpul execuiei, ceea ce mpiedic apariia erorilor n cazul schimbrii mediului de lucru dupa compilarea programului surs.

Fiabilitatea este asigurata prin eliminarea pointerilor, prin folosirea verificrii


dinamice a limitelor i prin gestionarea automat a memoriei, nlaturndu-se posibilitatea fisurilor i violrilor de memorie. O alt cale de evitare a erorilor este verificarea structurilor de date att la compilare ct 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 semnalnd urmatoarele: Violrile de acces Conversiile ilegale de date Valori si parametri incoreci Modificarea claselor sau folosirea incorect a acestora Depirea stivei n partea superioar sau inferioar Activitti suspecte sau neautorizate

12

2.3.Elemente Java folosite in dezvoltarea aplicatiei


2.3.1.Java Sockets
O reea este format dintr-o mulime de calculatoare i periferice (imprimante, plotere, scannere, modemuri etc.) conectate ntre ele. Un sistem distribuit este o colecie de calculatoare i/sau procesoare autonome (avnd o unitate de comand proprie), interconectate (capabile de a schimba informaii ntre ele). Elementele coleciei poart numele de noduri. Un astfel de sistem poate fi programat pentru a rezolva probleme de concuren i de paralelism. Sistemele distribuite au aprut ca o necesitate pentru: - schimbul de informaii ntre noduri; - partajarea unor resurse (printere, memorie backup, uniti de disc etc.); - sigurana n funcionare: dac un nod "cade", ntregul sistem trebuie (dac este posibil) s fie capabil s asigure n continuare funcionarea, prin redirijarea (rutarea) mesajelor prin nodurile funcionale. Tipuri de reele O prim clasificare a reelelor este constituit de mprirea lor n reele LAN (Local Area Network) i reele WAN (Wide Area Network). Reelele LAN sunt folosite de obicei pentru a partaja resurse (fiiere i periferice) i de a facilita schimbul de informaii 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 reea este transmis un singur mesaj. Numele reelei desemneaz produsul i nu reeaua (aa cum se ntmpl la reelele WAN). De exemplu Ethernet este un produs al companiei XEROX. Probleme algoritmice pentru astfel de reele: 1) sincronizarea: ateptarea ndeplinirii unei condiii; 2) difuzarea total (broadcasting) : transmiterea unui mesaj ctre toate celelalte noduri; 3) selectarea unui proces pentru ndeplinirea anumitor aciuni;

13

4) detectarea terminrii: un nod ce ntreprinde o aciune, n care antreneaz i alte noduri, trebuie s fie capabil s detecteze momentul ncheierii aciunii; 5) excluderea reciproc: utilizarea unor resurse sub excludere reciproc (de exemplu modificarea unui fiier sau scrierea la imprimant); 6) detectarea i prevenirea blocrii totale (deadlock); 7) gestionarea distribuit a fiierelor. Reelele WAN permit comunicarea pe distane mai mari, prin legturi directe ntre noduri, realizate prin linie telefonic, fibr optic, legtur via satelit etc. Ele sunt grafuri orientate. Probleme algoritmice pentru astfel de reele: 1) sigurana schimbului de informaii pe fiecare arc al grafului. Informaia eronat trebuie recunoscut ca atare i corectat. Menionm c este posibil ca mesajele s soseasc ntr-un nod n alt ordine dect cea n care au fost transmise, pot fi duplicate etc.; 2) selectarea de ci de comunicare (rutare) ntre nodurile care schimb informaii, 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 reelei cade (devine nefuncional); 3) evitarea congestionrii unor ci de comunicaie, realizat tot prin (re)rutare; 4) evitarea blocrii totale; 5) securizarea datelor i a transmisiilor. Deosebirile eseniale ntre cele dou tipuri de reele se refer la: 1) securizare: n reele LAN se presupune c transmiterea este corect, pe cnd n reelele WAN trebuie presupus c n timpul transmiterii mesajelor se poate ntmpla "ceva ru"; 2) timpul de comunicare: n reelele WAN timpul de comunicare este mult mai mare (de 10k ori mai mare, k 1) dect n reelele LAN; aceast timp este la rndul su mult mai mare dect cel cerut de prelucrrile locale; 3) omogeneitatea: n reelele WAN trebuie presupus c sunt utilizate simultan mai multe protocoale (vezi paragraful urmtor), ceea ce pune problema recunoaterii i conversiei ntre ele; 4) ncrederea reciproc: nu este presupus n reelele WAN i drept urmare trebuie luate msuri de securitate adecvate. Protocoale Comunicarea ntre componentele unei reele (respectiv unui sistem distribuit) se face prin mulimi de reguli, numite generic protocoale.
14

Un protocol cuprinde att formatul mesajului ce este efectiv transmis, ct i modul n care trebuie rspuns 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 folosete nume (adrese) simbolice pentru reele i pentru mainile gazd; ele se mai numesc nume de domeniu. Lor li se asociaz n mod biunivoc adrese (numerice) IP, folosite efectiv la comunicarea ntre nodurile reelei. 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 mulimea {0, 1, ..., 255}. Modelul Client/Server Dup cum tim, comunicarea ntre nodurile unei reele const n transmiterea (recepionarea) de pachete ctre (de la) gazde ale aceleai reele sau ale unei alte reele. 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 mulime de procese Server, fiecare jucnd rolul de gestionar de resurse pentru o colecie de resurse de un anumit tip; - o mulime de procese Client; fiecare execut activiti 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 att de tip Client, ct i de tip Server. Dar doar serverele gestioneaz resurse. Serverele sunt cele care i ncep primele activitatea. n mod tipic, un server ofer succesiv clienilor posibilitatea de a se conecta la el (spunem c accept conexiuni de la clieni). La nceput clientul i manifest dorina de a se conecta i, dac serverul este gata s accepte conexiunea, aceasta se realizeaz efectiv; este vorba deci de o aciune de la client ctre server. Apoi transmisia informaiilor devine bidirecional, fluxul de informaii putnd circula acum n ambele sensuri.
15

Teoretic, activitatea unui server se desfoar la infinit. Pentru conectare la server, clientul trebuie s cunoasc adresa serverului (fie cea numeric, fie cea simbolic), precum i numele portului pus la dispoziie de server. Portul nu este o locaie fizic, ci o extensie software corespunztoare unui serviciu. Serverul poate oferi mai multe servicii, pentru fiecare existnd un numr de port. Cel standard sunt: 7 : ping (ecou) 25 : email 21 : ftp (transfer de fiiere) 79 : finger 23 : telnet 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 clieni privilegiai. Clientul iniiaz conexiunea prin reea, specificnd adresa serverului i portul prin care dorete s comunice. Serverul trebuie s precizeze numai portul; apoi el trebuie s execute o comand prin care s anune c este gata s accepte conexiuni pe portul respectiv; drept urmare el rmne n ateptare pn cnd un client dorete s se conecteze i conexiunea este stabilit cu succes. Un server poate accepta conexiuni de la mai muli clieni: pentru fiecare creaz un fir de executare. Clasa InetAddress Aceast clas, aflat n pachetul java.net, furnizeaz informaii 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 aplicaia). Acest nume, convertit la String, are forma: adres_simbolic/adres_IP; public static InetAddress getByName(String s) dndu-se ca argument adresa simbolic sau numeric a calculatorului gazd, metoda ntoarce un obiect de tipul InetAddress; metoda poate lansa excepia UnknownHostException; public String getHostName() ntoarce adresa simbolic a calculatorului gazd; public byte[] getAddress() ntoarce un tablou de 4 octei, ce compun adresa numeric. Exemplul 1. Determinarea adreselor unui calculator i obinerea uneia dintre aceste adrese cunoscnd-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 facilitile oferite de Java pentru lucru n reea dac avem la dispoziie 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 ataa un flux de intrare i unul de ieire, prin care pot recepiona/ transmite, date. Prezentm n continuare schema general a lucrului cu socket-uri, apelnd la facilitile de intrare/ieire la nivel de octet. Un mod tipic de creare a unui socket client este urmtorul: 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 numrul portului ales pentru comunicare. Socket-ului i sunt ataate fluxul os ce va fi folosit pentru a transmite date serverului, precum i fluxul is ce va fi folosit pentru recepionarea datelor transmise de server. Un mod tipic de creare a unui socket server este urmtorul: 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) { ... }

Observm 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 atept ca un client s ncerce s se lege la server; n momentul n care acest lucru se ntmpl i legtura s-a stabilit, metoda creeaz i ntoarce un socket cs de tip client. Acestuia i atam un flux de intrare i unul de ieire.

Clie nt
os cs is is os

Serv er

cs

ss

18

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 locaie URL, este o referin la o resurs Web. Resursa poate fi un fiier, un director, dar i un obiect mai complex ca de exemplu o cerere ctre o baz de date sau un motor de cutare. Ca sintax, o astfel de adres cuprinde 4 pri: protocol:// adresa :port /cale unde protocol desemneaz serviciul exportat de server sau cutat de client (de exemplu http sau ftp), adresa este adresa simbolic sau numeric a mainii gazd referite, port portul folosit pentru comunicare, iar cale identific resursa. Un exemplu este urmtorul: http://www.ncsa.uiuc.edu:8080/demoweb/url-primer.html Sunt folosite i locaii URL pariale, ce specific doar unele pri din forma complet a locaiei; acest lucru este posibil n situaiile n care celelalte pri sunt implicite sau se deduc din context. De exemplu poate lipsi numele mainii gazd (dac facem referire la maina 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 locaia URL; int getPort() ntoarce numrul portului din locaia URL; String getProtocol() ntoarce protocolul din locaia URL; String getHost() ntoarce adresa mainii gazd din locaia URL; String getFile()
19

ntoarce numele fiierului din locaia URL; String toString() ntoarce reprezentarea sub form de ir de caractere a locaiei URL.

Exemplul 2. Dorim s aflm dac un server avnd o adres dat ofer sau nu servicii Web. Va fi creat un socket de tip client. Adresa este furnizat n comanda java. // 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 conversaie) ntre dou calculatoare.

20

Pentru simplificare, considerm c fiecare mesaj trimis de la un calculator la cellalt se reduce la o linie de text. Serverul este primul care trebuie pornit. Apoi clientul este cel care ncepe discuia, transmind un mesaj i ateptnd s primeasc mesajul de rspuns, activiti care se repet pn cnd clientul transmite mesajul "STOP". Serverul repet i el succesiunea de activiti recepie + transmisie pn cnd primete 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 nct sarcinile sunt mpartite de ctre sistemul de operare iar aplicaiile sunt executate pe mai multe procesoare ce mpart acelai spatiu de memorie. SMS garanteaz c ntreg numrul de procesoare deservete sistemul de operare. Fiecare sub-proces poate fi executat pe orice procesor liber. Astfel se poate realiza echilibrarea ncarcrii ntre procesoare. Java conine cteva 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 creia mai multe procese utilizeaz n comun resursele calculatorului (inclusiv procesorul). n situaia unui calculator cu un singur procesor, se spune c n orice moment ruleaz cel mult un proces, ceea ce nseamn c procesorul execut instruciunile unui singur proces la un moment dat. Sarcina alegerii procesului care s se afle n execuie la un moment dat este o problem de planificare. Operaia de a opri un proces aflat n execuie, pentru a-i aloca un timp procesor altui proces aflat n ateptare se numete schimbare de context (context switch). Realizarea frecvent a acestor schimbri de context creaz iluzia excuiei n paralel a mai multor programe. n cazul unui calculator cu mai multe procesoare, multitasking-ul permite execuia unui numr de procese mai mare dect numrul de procesoare. Sistemul de operare este cel care se ocup de planificarea proceselor, planificare ce se ncadreaz ntr-una din urmtoarele strategii:
23

n cazul sistemelor cu multiprogramare, procesul current se afl n execuie pn n momentul n care realizeaz o operaie ce presupune ateptarea dup un eveniment extern (o operaie de I/O), sau pn cnd planificatorul de procese foreaz 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 apariiei unui eveniment hardware cum ar fi o ntrerupere.

n cadrul sistemelor real-time, unui proces aflat n stare de ateptare i se garanteaz accesul la procesor n cazul apariiei unui eveniment extern. Astfel de sisteme sunt proiectate pentru controlul unor dispozitive mecanice cum ar fi roboii industriali.

Comutarea ntre procese consum timp procesor pentru ca planificatorul de procese s nghee starea unui proces i s dezghee starea altui proces (schimbare de context). Dac mai multe procese concurente sunt executate pe acelai procesor i toate execut calcule atunci timpul total de execuie va fi mai mare dect timpul de execuie al unui program secvenial echivalent. Creterea vitezei sistemului se poate realiza prin ntreeserea 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 utilizndu-se la maxim funciunile acestuia. Faza de I/O (intrare/ieire) presupune un aport mai mare din partea perifericelor (imprimante, hard discuri, plci de reea, etc), procesul ateptnd ca un periferic s-i termine sarcina. n timp ce un proces se afl ntr-o faz de I/O ateptnd dup finalizarea unei operaii de ctre 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 fiecrui proces, asigurndule astfel un tratament echitabil. De asemenea, sistemul poate rspunde rapid unui eveniment extern (cum ar fi sosirea unor date) ce presupune procesarea de ctre procesul curent sau de ctre un altul. n cazul multitasking-ului non-preemtiv, planificatorul i d controlul unui proces pn cnd acesta se termin, sau elibereaz singur procesorul. Ce sunt thread-urile? Thread-ul reprezint execuia liniar a unei singure secvene de instruciuni ce ruleaz in interiorul programului nostru. Toti programatorii sunt familiarizati cu scrierea programelor secveniale. Programele secveniale 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 execuie 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 pna acum avea cel putin un thread in interiorul su. Noutatea apare atunci cnd vrem sa folosim mai multe thread-uri, ceea ce inseamna c aplicaia 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). Cnd se folosete corespunzator multithreading-ul performanele applet-ului sau a aplicaiei unde este folosit cresc simtitor. Multithreading-ul poate simplifica fazele de proiectare si planificare a tuturor sarcinilor greu de implementat ntr-un program secvenial. Un exemplu de thread-uri este un procesor de text care poate sa tipreasc o pagin (paginare, ncadrare si trimitere ctre imprimant) in background. Se poate continua editarea n timp ce pagina este trimis ctre imprimant. Alt exemplu este acela a unui browser Web care permite defilarea unui text al unei pagini pe care tocmai ai 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 avnd cte un thread pentru fiecare subtask se poate creste mult viteza de execuie. Aceasta afirmatie este general valabila pentru un SMS. Cnd se executa doua threaduri, ele vor fi executate simultan, fiecare pe cte un procesor i astfel se realizeaz o cretere semnificativ a vitezei. Avantaje similare se obin cnd 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 mentinndu-se valabil chiar daca procesoarele sunt pe calculatoare diferite conectate ntr-o reea. Dar i pe o masin cu un singur procesor, thread-urile pot mpri acelai procesor, rulnd ntr-o manier intretesuta, competiia pentru timpii CPU crend 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 nghee 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 execuie nu va lua mai mult dect timpul de execuie al unui program secvential care realizeaz acelai 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, plci de retea, etc) i n aceste situaii procesorul este n general liber, asteptnd 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 asteptnd ca o secven de date sa fie ncarcat de pe hard disk, un thread cu o faz de calcul poate ocupa procesorul i cnd ajunge la o faza I/O, cellalt 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 execuie, dar variabilele globale sunt mprite de toate thread-urile. Deoarece mpart acelai spaiu (variabilele globale i alte resurse) toate firele de execuie 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 atenie sporit pentru minimizarea utilizrii concurent a variabilelor comune de ctre mai multe thread-uri, deoarece aceast situaie ar putea degenera ntr-o sufocare a aplicaiei. 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 instana 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 atta timp ct 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 ci pentru crearea firelor de executie : Crearea unei clase care extinde clasa Thread din biblioteca de clase java.lang Crearea unei clase care implementeaza interfaa 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 conine 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 nti 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(); } }

Secvena de cod anterioar combinat cu clasa TestTread va afia 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() pn cnd 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 interfaa 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 apela de asemenea metoda stop(), care va distruge thread-ul.

inca

alocat. Pentru a porni un thread trebuie apelata functia start(). In aceasta stare se poate 2. Thread in executie - Thread-ul a fost lansat in executie cu metoda start(). Este threadul 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 posibilitii 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 (pnza 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 cte 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 aceeasi 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 infatisarii si a modului de interactiune cu aplicatiain functie de preferintele fiecaruia. Acelasi program poate utiliza diversemoduri Look-andFeel, 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 aplicatiilor 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:PREGTIREA MEDIULUI DE LUCRU


3.1. Instalare NetBeans
NetBeans este un proiect open-source, cu o baz de utilizatori foarte mare, o comunitate n cretere i peste 100 de parteneri (n cretere!) din toat lumea. Sun Microsystems a fondat proiectul open source NetBeans n iunie 2000 i continu s fie principalul sponsor al proiectului. Astzi 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 numr imens de module pentru extinderea NetBeans IDE. NetBeans IDE este un produs gratuit, fr restricii legate de modul de utilizare. De asemenea, este disponibil Platforma NetBeans; o baz modular i extensibil, utilizat drept conector software pentru crearea aplicaiilor desktop puternice. Partenerii ISV ofer Plugin-uri cu valoare adugat, care se integreaz uor n platform i care pot fi utilizate, de asemenea, la dezvoltarea propriilor instrumente i soluii. 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 - Licena de distribuie 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 rulrii, va incepre execuia 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 crora aplicaia poate fi rulata independent, singura condiie 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 aplicaia 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 aplicaie nu trebuie instalat nici un program, doar JVM pe computer.

39

CAPITOLUL 4:DESCRIEREA APLICATIEI


4.1. Introducere
Cel mai ntlnit model de programare a aplicaiilor de reea poart numele i de aplicaii Client-Server. Conceptul este simplu: o main client face o cerere pentru o informaie sau trimite o comand la un server; ca rspuns, serverul trimite datele cerute sau rezultatul comenzii. De cele mai multe ori, serverul rspunde numai la clieni; nu iniiaz comunicaiile. Aadar, funcia serverului este de asculta pentru o conexiune. Aceste lucru este realizat printr-un obiect server care a fost special creat. Funcia 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 sar scrie sau s-ar citi dintr-un fiier. 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 aplicaia s efectueze aceste verificri; se folosete cu precdere la streaming multimedia. TCP este un protocol care asigur corectitudinea datelor, efectund att verificarea erorilor ct i controlul fluxului; este protocolul de baz pentru transmiterea informaiilor n reea . Avantajele utilizrii acestui protocol: este un protocol de reea 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 reea de reele eterogene att din punct de vedere hardware, ct i software);

40

furnizeaz un protocol de reea rutabil, pentru reele mari, fiind folosit din acest motiv drept protocol de interconectare a acestor reele; 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 ctre Secretariatul pentru Aprare al Statelor Unite, i care permite comunicaia ntre reele eterogene (interconectarea reelelor). n aceast lucrare am exemplificat modul de funcionare al protocololului TCP prin intermediul unor aplicaii client-server(BattleShip).

4.2.Structura aplicatiei
Aplicatia conine de fapt dou aplicaii 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 aplicaie realizat in Java avnd urmtoarele atribuii: Creeaz uun socket pentru a comunica cu clienii Primete date de la clieni Trimite date la clieni

Aceasta aplicaie este o aplicaie multi-client, adc la un moment dat la server pot fi conectai mai muli clieni, BattleShipServer are in componen un singur pachet PacServer care conine 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 clienii conectai, pentru a trimite mesaje la toi clienii sau numai la naumii clieni etc astfel: HELO- iniializaeza conexiunea la server. QUIT- inchide conexiunea pentru clientul de la care s-a primit comanda MESS trimite un mesaj general la toi clienii PRIV trimite un mesaj la un anumit client este responsabil cu evidena clinilor conectai, usernam-ul si

Aplicaia

primirea,trimiterea de mesaje. Clasa principal a acestei aplicaii este ChatServer, care implementeaza interfaa grafic pentru comunicarea cu utilizatorul, thread-urile pentru comuncarea cu clienii, trimiterea mesajelor ctre clieni, adgarea clienilor conectai, stergerea clienilor in momentucl cand conexiunea ctre acetia a fost nchis. Aplicaiei BattleShipServer va arta, in momentul execuiei, astfel:

43

Dup apasarea butonului START SERVER, serverul este pornit fiind disponibil celor care doresc s joace acest joc, si care au aplicaia client.

In acest moment, aplicaia a creat un socket pe portul 1436, si ateapt clientii care doresc s se conecteze. Dac un client se conecteaz la server, acesta av creea un thread (fir de execuie) separat pentru deserirea lui, iar cnd clientul trimite comanda QUIT i firul de execuie corespunztor va fi inchis. Acest lucru se realizeaza prin intermediul clasei ChatCommunication, care gestioneaza mesajele primite, lanseaza in execuie thread-ul corespunzator fiecrui client folosind metota run(), metod apelata in momentul lansrii n execuie a unui thread si rspunde 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) } if(RFC.startsWith("PRIV")) { Parent.SendPrivateMessage(RFC.substring(RFC.indexOf("~")+1), RFC.substring(5,RFC.indexOf("~"))); } } ,RFC.substring(RFC.indexOf("~") +1,RFC.indexOf(":")),RFC.substring(5, RFC.indexOf("~")));

Clasa ClientObject conine metode care returneaz variabilele necesare pentru evidena 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; }

Aplicaia Client BattleShipClient este, de fapt, aplicaia cu ajutorul creia utilizatorul paote sa joace BattleShip. Pentru conectarea la server folosete socket-uri i thread-uri, iar pentru desenarea navelor, desenarea intei, a loviturilor foloseste API-ul Java2D. Aceasta aplicaie conine patru pachete: BattleShipSingle:conine clasele Java necesare utilizatorului sa joace jocul singur,cu calculatorul. Main: in acest pachet este prezent clasa principala a aplicaiei. PacClient: clasele necesare conexiunii la server BattleShip: clasele pentru jocul n reea. BattleShipSingle este clasa principal pentru acest pachet, aceasta fiind lansat n execuie cnd utilizatorul joac cu computerul. n aceast clas este implementat intefaa grafic cu utilizatorul si sunt adaugate celelate componente. Game adaug componentele necesare jocului GridArea este clasa care conine matricea cu poziiile navelor, event-urile pentru click si metodele pentru validare poziiilor navelor.
46

Pachetul BattleShipSingle conie clasele:

PlayingField este o clas cu ajutorul creia se poziioneaz navele i conine 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 creia je joca jocul Battleship. Aceasta clas conine un thread care gestioneaza evenimente i desenarea. Sound este clasa care implementeaza sunetele pentru diferite aciuni ale juctorului.

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 conie o singura clas: MainGui: Aceast clas este folosit in momentul pornirii aplicaiei pentru ca utilizatorul s aleagg modul cum va juca: vs computer sau multyplayer.

49

Pachetul PacClient are n componen urmtoarele clase: ChatClient clasa principala cu ajutorul creia se implementeaz interfaa pentru conectarea la server i thread-urile necesare acestei conexiuni. CommonSettings conine setri pentru client: portul de ascultare, titlui, dimensiuni ListViewCanvas metodele pentru adugarea clienilor conectai la server, stergerea lor, trimiterea de mesaje PrivateChat2 este clasa care trimite mesaje la anumii useri, primete mesaje de la anumii useri. Cu ajutorul acestei clase jocul poate fi jucat de doar doi clieni, char dac la server sunt conectai mai muli useri. Game este clasa cu ajutorul creia utilizatorul pote sa aleaga dac doreste s joce jocul cu userul de la care a venit cererea sau nu. NoGame apare in momentul cnd userul la ctre 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 afieaza userii conectatii si cu ajutorul creia pot fi trimise cereri pentru a juca BattleShip n reea. Structura claselor ChatClient CommonSettings

50

ListViewCanvas

PrivateChat2

51

TapPannel

Game

Pachetul BattleShip conine aceeleai 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 muli client. Jaocul se poate juca n reea dac exist cel puin doi client conectai la un moment dat. La lansarea in execuie a aplicaiei 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 creia va aeza navele.

Dup ce navele au fost aezate, se poate ncepe jocul.

54

Dup ce utilizatorul d click pe o csu aceasta se coloreaz n funcie dac a fost lovit o nav a computer-ului sau nu. Dup ce utilizatorul a a dat click este randul computerului. Jocul se termin cnd computerul sau utilizatorul a lovit toate navele celuilat.

Dac utilizatorul vrea s joace n reea i alege opiunea 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 apsarea butonului Connect, aplicaia se va conecta la server dac acesta este pornit. Dac serverul nu este pornit, se va afia un meaj de eroare. Dup conectare, vor fi afiai toi clienii conectai iar pentru a juca BattleShip cu unul din ei, se selecteaz numele acestuia i se apas butonul Start game.

56

La apsarea butonului Start game un mesaj va trimis catre utilizatorul al crui nume este selectat. La randul lui acesta va primi un mesaj cu ntrebarea dac dorete 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 aeze navele, iar dup ce amndoi -au aezat navele pot ncepe jocul Lovitura de nceput o are cel care trimite cererea pentru joc. Fereastra pentru juctorul care are lovitura de nceput va arta astfel:

57

Dup ce a dat click pe o poziie de cmpul oponentului, pe acea poziie va aprea o imagine in funcie dac a lovit o nav sau nu. Dup ce a dat click va trebui s astepte ca i celalat juctor s fac o mutare.

Utilizatorul care a fost de acord s joce BattleShip, dup ce a aezat navele va trebui sa atepte prima lovitur de la cellalt.

58

Dup ce acesta a efectuat prima mutare, pe campul sau va aprea locul unde a dat click celalat si dac a lovit o nav sau nu. n acest moment, va fi randul lui sa loveasc.

Aa va arta tabla de joc a utilizatorului Mihai dupa cteva mutri.


59

Jocul se va termina cnd unul dintre cei doi juctori a reuit s loveasc toate navele celuilat. n acel moment, la fiecare utilizator va fi afiat o fereastr care l anun ca a castigat sau a pierdut.

Dup apsarea 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. Astzi, multe dintre aplicaiile cu care suntem familiarizai sunt client/server: Web-ul, e-mail, ftp, telnet, i aa mai departe. Chiar dac tot mai muli gameri i ndreapt atenia ctre 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