Documente Academic
Documente Profesional
Documente Cultură
Practica în producție
Tema: Crearea unei aplicații calculator științific în limbajul JAVA.
Chişinǎu 2020
Cuprins
Introducere..............................................................................................................................3
1. Scurt Istoric.........................................................................................................................5
2. Principii de funcționare în Java. Tipuri de date și variabile................................................7
2.1. Cuvinte-cheie rezervate........................................................................................9
2.2. Programarea Orientată pe Obiecte și Java............................................................9
2.3. Operatori..............................................................................................................11
2.4. Atribuirea.............................................................................................................11
2.5. Operatori aritmetici..............................................................................................12
2.6. Șiruri de caractere în Java....................................................................................14
2.7. Rularea programelor............................................................................................14
2.8. Metode.................................................................................................................15
2.9. Elemente a claselor..............................................................................................16
3. Domenii de utilizare...........................................................................................................17
4. Aplicația Calculator............................................................................................................19
Concluzie................................................................................................................................22
Bibliografie.............................................................................................................................22
Anexa A (Tabele)...................................................................................................................23
Anexa B (Listingul Programelor exemple)............................................................................24
Introducere
Industria informatică tinde să ocupe întreaga suprafață a serviciilor. Tot mai mulți s-au
convins de acest fapt. În viitorul apropiat, tehnologia va avansa atît de mult, încît va deveni
cea mai căutată și avansată sferă. În orice tehnologie, la baza acesteia, stă un principiu de
funcționare. Însăși acest principiu de funcționare, reprezintă un cod care este un limbaj de
comunicare dintre oameni și tehnică. Orice funcționalitate necesită un plan bine pus la punct
și o testare minuțioasă. Această conexiune este oferită de către diverse instrumente de
dezvoltare. Unul din acestea, este Java. El nu este un instrument perfect, însă este cu siguranță
perfectibil. Chiar dacă limbajul de programare datează din 1995, acesta este pînă în prezent
unul din cele mai întilnite limbaje. El este prezent în majoritate device-urilor mobile și o
mulțime de alte softuri din domenii variate.
În principiu, Java a fost creat ca o alternativă mai accesibilă la complexul C++, ajungînd în
prezent să fie folosit pentru dezvoltarea de aplicații, precum și pentru crearea de sisteme
website backend de către aproximativ 90% dintre cele mai potente companii de IT ale lumii.
Drept exemplu, aplicațiile concepute pentru sistemul Android sunt în cea mai mare parte
create folosind limbajul Java. Un scop al limbajului Java, este de a ușura munca
programatorilor, lucru care în timp, a permis și amatorilor să deprindă meșteșugul construirii
de software. Totuși Java este un limbaj de programare de nivel înalt. Java se ocupă practic de
cele mai complexe detalii ale unui computer, ca de exemplu gestionarea memoriei. Acest
lucru îi permite developer-ului să se concentreze strict pe programare, fără să-şi mai facă alte
griji în privinţa detaliilor. Limbajul Java are în spate o istorie de peste două decenii, astfel că,
la ora actuală, orice întrebare sau neclaritate ai avea despre utilizarea sa a fost deja pusă, s-a
răspuns la ea, iar răspunsul a fost verificat şi validat. Este greu practic, într-o asemenea etapă,
să pui în dificulate un motor de căutare cu o problemă de codare Java. Iar acesta este un
avantaj major în special pentru cei care aleg fie să înveţe programare singuri, fie optează
pentru un curs intensiv. Java dispune de o interfaţă de programare a aplicaţiilor (API) foarte
bogată, precum şi de un ecosistem cu sursă deschisă extrem de ajutător. Java vine, aşadar, la
pachet cu tot felul de unelte care ajută indiferent de produsul software pe care ai vrea să îl
realizezi.
Pentru această lucrare, îmi propun urmatoarele obiective:ț
-Să prezint o scurtă istorie despre apariția Java
-Să studiez principiile de funcționare a limbajului de programare Java
-Să atribui anumite domenii de funcționare pentru Java
-Să fac o comparație față de alte limbaje de programare
-Să execut un mic program în Java în care să aplic în practică toate cele studiate
-Să definesc ce avantaje si dezavantaje oferă Java
-Să îmi formez o concluzie finală despre Java
Pentru a-mi putea îndeplini obiectivele specificate de mine, voi aplica la diverse surse
informaționale precum cărți, articole, experiențele altor programatori care lucrează în
domeniu.
Scopul lucrării este de a face posibilă inițierea unui doritor de a studia limbajul de
programare Java într-un mod simplu și util în care își poate face o părere generală despre
principiile de funcționare acestui limbaj.
Am ales această temă datorită faptului de a studia eu însumi acest limbaj de
programare și de a reuși să creez un mic soft realizat în Java. De ce anume Java? Datorită
faptului căci este un limbaj de nivel înalt ce permite foarte multe posibilități și este utilizat în
diferite domenii globale.
1. Scurt istoric
Limbajul Java împreună cu mediul său de dezvoltare şi execuţie au fost proiectate
pentru a rezolva o parte dintre problemele actuale ale programării. Proiectul Java a pornit cu
scopul declarat de a dezvolta un software performant pentru aparatele electronice de larg
consum. Aceste echipamente se definesc ca: mici, portabile, distribuite şi lucrând în timp real.
De la aceste aparate, ne-am obişnuit să cerem fiabilitate şi uşurinţă în exploatare. Limbajul
luat iniţial în considerare a fost C++. Din păcate, atunci când s-a încercat crearea unui mediu
de execuţie care să respecte toate aceste condiţii s-a observat că o serie de trăsături ale C++
sunt incompatibile cu necesităţile declarate. În principal, problema vine din faptul că C++ este
prea complicat, foloseşte mult prea multe convenţii şi are încă prea multe elemente de
definiţie lăsate la latitudinea celor care scriu compilatoare pentru o platformă sau alta.
În aceste condiţii, firma Sun a pornit proiectarea unui nou limbaj de programare
asemănător cu C++ dar mult mai flexibil, mai simplu şi mai portabil. Aşa s-a născut Java.
Părintele noului limbaj a fost James Gostling care vă este poate cunoscut ca autor al
editorului emacs şi al sistemului de ferestre grafice NeWS. Proiectul a început încă din 1990
dar Sun a făcut publică specificaţia noului limbaj abia în 1995 la SunWorld în San Francisco.
Numele iniţial al limbajului a fost Oak, numele unui copac care creşte în faţa biroului lui
James Gostling. Ulterior, s-a descoperit că numele fusese deja folosit în trecut pentru un alt
limbaj de programare aşa că a fost abandonat şi înlocuit cu Java, spre deliciul programatorilor
care iubesc cafenelele şi aromele exotice. În primul rând, Java încearcă să rămână un
limbaj simplu de folosit chiar şi de către programatorii neprofesionişti, programatori care
doresc să se concentreze asupra aplicaţiilor în principal şi abia apoi asupra tehnicilor de
implementare a acestora. Această trăsătură poate fi considerată ca o reacţie directă la
complexitatea considerabilă a limbajului C++.
Au fost îndepărtate din Java aspectele cele mai derutante din C++ precum
supraîncărcarea operatorilor şi moştenirea multiplă. A fost introdus un colector automat de
gunoaie care să rezolve problema dealocării memoriei în mod uniform, fără intervenţia
programatorului. Colectorul de gunoaie nu este o trăsătură nouă, dar implementarea acestuia
în Java este făcută inteligent şi eficient folosind un fir separat de execuţie, pentru că Java are
încorporate facilităţi de execuţie pe mai multe fire de execuţie. Astfel, colectarea gunoaielor
se face de obicei în timp ce un alt fir aşteaptă o operaţie de intrare-ieşire sau pe un semafor.
Limbajul Java este independent de arhitectura calculatorului pe care lucrează şi
foarte portabil. În loc să genereze cod nativ pentru o platformă sau alta, compilatorul Java
generează o secvenţă de instrucţiuni ale unei maşini virtuale Java. Execuţia aplicaţiilor Java
este interpretată. Singura parte din mediul de execuţie Java care trebuie portată de pe o
arhitectură pe alta este mediul de execuţie cuprinzând interpretorul şi o parte din bibliotecile
standard care depind de sistem. În acest fel, aplicaţii Java compilate pe o arhitectură SPARC
de exemplu, pot fi rulate fără recompilare pe un sistem bazat pe procesoare Intel.
Una dintre principalele probleme ale limbajelor interpretate este viteza de execuţie,
considerabil scăzută faţă de cea a limbajelor compilate. Dacă nu vă mulţumeşte viteza de
execuţie a unei astfel de aplicaţii, puteţi cere mediului de execuţie Java să genereze automat,
plecând de la codul maşinii virtuale, codul specific maşinii pe care lucraţi, obţinându-se astfel
un executabil nativ care poate rula la viteză maximă. De obicei însă, în Java se compilează
doar acele părţi ale programului mari consumatoare de timp, restul rămânând interpretate
pentru a nu se pierde flexibilitatea. Mediul de execuţie însuşi este scris în C respectând
standardele POSIX, ceea ce îl face extrem de portabil.
Interpretorul Java este gândit să lucreze pe maşini mici, precum ar fi procesoarele cu
care sunt dotate aparatele casnice. Interpretorul plus bibliotecile standard cu legare dinamică
nu depăşesc 300 Kocteţi. Chiar împreună cu interfaţa grafică totul rămâne mult sub 1 Moctet,
exact ca-n vremurile bune.
Limbajul Java este orientat obiect. Cu el se pot crea clase de obiecte şi instanţe ale
acestora, se pot încapsula informaţiile, se pot moşteni variabilele şi metodele de la o clasă la
alta, etc. Singura trăsătură specifică limbajelor orientate obiect care lipseşte este moştenirea
multiplă, dar pentru a suplini această lipsă, Java oferă o facilitate mai simplă, numită interfaţă,
care permite definirea unui anumit comportament pentru o clasă de obiecte, altul decât cel
definit de clasa de bază. În Java orice element este un obiect, în afară de datele primare. Din
Java lipsesc funcţiile şi variabilele globale. Ne rămân desigur metodele şi variabilele statice
ale claselor.
Java este distribuit, având implementate biblioteci pentru lucrul în reţea care ne oferă
TCP/IP, URL şi încărcarea resurselor din reţea. Aplicaţiile Java pot accesa foarte uşor reţeaua,
folosindu-se de apelurile către un set standard de clase.
Java este robust. În Java legarea funcţiilor se face în timpul execuţiei şi informaţiile de
compilare sunt disponibile până în momentul rulării aplicaţiei. Acest mod de lucru face ca
sistemul să poată determina în orice moment neconcordanţa dintre tipul referit la compilare şi
cel referit în timpul execuţiei evitându-se astfel posibile intruziuni răuvoitoare în sistem prin
intermediul unor referinţe falsificate. În acelaşi timp, Java detectează referinţele nule dacă
acestea sunt folosite în operaţii de acces. Indicii în tablourile Java sunt verificaţi permanent în
timpul execuţiei şi tablourile nu se pot parcurge prin intermediul unor pointeri aşa cum se
întâmplă în C/C++. De altfel, pointerii lipsesc complet din limbajul Java, împreună cu
întreaga lor aritmetică, eliminându-se astfel una din principalele surse de erori. În plus,
eliberarea memoriei ocupate de obiecte şi tablouri se face automat, prin mecanismul de
colectare de gunoaie, evitându-se astfel încercările de eliberare multiplă a unei zone de
memorie.
Java este un limbaj cu securitate ridicată. El verifică la fiecare încărcare codul prin
mecanisme de CRC şi prin verificarea operaţiilor disponibile pentru fiecare set de obiecte.
Robusteţea este şi ea o trăsătură de securitate. La un al doilea nivel, Java are incorporate
facilităţi de protecţie a obiectelor din sistem la scriere şi/sau citire. Variabilele protejate într-
un obiect Java nu pot fi accesate fără a avea drepturile necesare, verificarea fiind făcută în
timpul execuţiei. În plus, mediul de execuţie Java poate fi configurat pentru a proteja reţeaua
locală, fişierele şi celelalte resurse ale calculatorului pe care rulează o aplicaţie Java.
Limbajul Java are inclus suportul nativ pentru aplicaţii care lucrează cu mai multe fire
de execuţie, inclusiv primitive de sincronizare între firele de execuţie. Acest suport este
independent de sistemul de operare, dar poate fi conectat, pentru o performanţă mai bună, la
facilităţile sistemului dacă acestea există.
Java este dinamic. Bibliotecile de clase în Java pot fi reutilizate cu foarte mare
uşurinţă. Cunoscuta problemă a fragilităţii superclasei este rezolvată mai bine decât în C++.
Acolo, dacă o superclasă este modificată, trebuie recompilate toate subclasele acesteia pentru
că obiectele au o altă structură în memorie. În Java această problemă este rezolvată prin
legarea târzie variabilelor, doar la execuţie. Regăsirea variabilelor se face prin nume şi nu
printr-un deplasament fix. Dacă superclasa nu a şters o parte dintre vechile variabile şi
metode, ea va putea fi refolosită fără să fie necesară recompilarea subclaselor acesteia. Se
elimină astfel necesitatea actualizării aplicaţiilor, generată de apariţia unei noi versiuni de
bibliotecă aşa cum se întâmplă, de exemplu, cu MFC-ul Microsoft (şi toate celelalte ierarhii
C++).
Figura 1.1 – Etapele creării unui program Java
În Java tipurile de date se impart în doua categorii: tipuri primitive şi tipuri referinţa.
Java porneşte de la premiza ca ’’orice este un obiect”, prin urmare tipurile de date ar trebui sa
fie de fapt definite de clase şi toate variabilele ar trebui sa memoreze instanţe ale acestor clase
(obiecte). In principiu acest lucru este adevarat, însa, pentru usurinta programarii, mai exista si
asa numitele tipurile primitive de date, care sunt cele uzuale:(Vezi Anexa A, tabelul A.1)
-aritmetice
-întregi: byte (1 octet), short (2), int (4), long (8)
-reale: float (4 octeti), double (8)
-caracter: char (2 octeti)
-logic: boolean (true si false)
În alte limbaje de programare formatul si dimensiunea tipurilor primitive de date pot depinde
de platforma pe care ruleaza programul. In Java acest lucru nu mai este valabil, orice
dependenta de o anumită platforma specifica fiind eliminata.
Vectorii, clasele si interfetele sunt tipuri referinta. Valoarea unei variabile de acest tip este,
spre deosebire de tipurile primitive, o referinta (adresa de memorie) catre valoarea sau
multimea de valori reprezentata de variabila respectiva.
Exista trei tipuri de date din limbajul C care nu sunt suportate de limbajul Java. Acestea sunt:
pointer, struct si union. Pointerii au fost eliminat din cauza ca erau o sursa constanta de erori,
locul lor fiind luat de tipul referinta, iar struct si union nu îsi mai au rostul atat timp cat
tipurile compuse de date sunt formate în Java prin intermediul claselor.
Variabilele pot fi de tip primitiv sau referinţe la obiecte (tip referinţă). Indiferent de tipul lor,
pentru a putea fi folosite variabilele trebuie declarate si, eventual, initializate.
-Declararea variabilelor: Tip numeVariabila;
-Initializarea variabilelor: Tip numeVariabila = valoare;
-Declararea constantelor: final Tip numeVariabila;
Evident, exista posibilitatea de a declara si initializa mai multe variabile sau constante de
acelasi tip într-o singura instructiune astfel:Tip variabila1[=valoare1],
variabila2[=valoare2],...;
Anumite reguli de numire a variabilelor în Java include, printre altele, urmatoarele criterii:
-variabilele finale (constante) se scriu cu majuscule;
-variabilele care nu sunt constante se scriu astfel: prima literaa micaa iar daca numele
variabilei este format din mai multi atomi lexicali, atunci primele litere ale celorlalt
atomi se scriu cu majuscule.
In functie de locul în care sunt declarate variabilele se împart în urmatoatele categorii:
-Variabile membre, declarate în interiorul unei clase, vizibile pentru toate metodele
clasei respective cat si pentru alte clase în functie de nivelul lor de acces (vezi
’’Declararea variabilelor membre”).
-Parametri metodelor, vizibili doar în metoda respectiva.
-Variabile locale, declarate într-o metoda, vizibile doar în metoda respectiva.
-Variabile locale, declarate într-un bloc de cod, vizibile doar în blocul respectiv.
-Parametrii de la tratarea exceptiilor
2.3. Operatori
2.4. Atribuirea
În limbajul Java orice expresie produce un rezultat, iar tipul rezultatului este
determinat de operatorul folosit si de catre tipul operanzilor. Daca analizam expresia a + b,
atunci a si b se numesc operanzi,iar + operator; efectul operatorului este acela de adunare, iar
rezultatul lui este suma valorilor numerice stocate în variabilele a si b. Atribuirea, care are
simbolul =, este un operator, asemenea lui + astfel, când undeva în program se scrie a = b el
va avea un efect si un rezultat. Efectul este cel de evaluare
a expresisei din drepta lui =, la noi aceasta este valoarea stocata în b si de copiere a valorii
expresiei
evaluate în a, iar rezultaul este valoarea copiata, adica valoarea lui b. Deseori, acest rezultat nu
este
folosit mai departe, desi utilizarea lui ar fi corecta.
Majoritatea operatorilor Java produc un rezultat fara a modifica valorile operanzilor.
Exista însa
operatori, asemenea celui de atriburie, care modifica valoarea unui operand. Aceasta actiune
poarta
denumirea de efect secundar, în engleza “side effect”. În cazul operatorului = , denumirea este
fortata
deoarece aici efectul de modificare este cel primar. Java are însa o clasa întreaga de operatori
care
produc efecte secundare ce vor fi discutati în continuare (atribuirea compusa).
Atribuirea poate fi si multipla, situatie în care asociativitatea operatorului de atribuire este de
la dreapta
la stânga.
2.8. Metode
Operațiile unei clase se definesc cu ajutorul metodelor. Metodele din Java sunt
echivalentul
procedurilor si funcțiilor din alte limbaje de programare, cu excepția ca ele trebuie scrie
obligatoriu în
interiorul definiție de clasă (nu există conceptul de metodă globală în Java). Vizibilitatea
controlează
cine anume va putea apela metoda. Pentru public acesta va fi apelabilă din toată aplicația,
pentru private
numai de alte metode din clasa în care s-a definit. Daca˘ metoda întoarceo valoare, adică este
o funcție,
ea va avea specificat unul dintre tipurile deja discutate si o instrucțiune de salt necondiționat
return
expresie ce va genera întoarcerea în codul apelant cu valoarea lui expresie. Dacă metoda nu
întoarce valoare, adică este o procedură, tipul ei va fi obligatoriu void si nu va conține
instrucțiune
return. Pentru ca operația implementată la nivelul unei metode să aibă loc aceasta trebuie
apelată.
Prin apel, va se realiza rularea instrucțiunilor cuprinse în corpul metodei. Terminarea metodei
se face
la rularea unei instrucțiuni return, din corpul ei sau, în lipsa lui return, la atingerea acoladei de
inchidera a corpului ciclului. La terminarea rulării unei metode rularea aplicației va continua
cu
instrucțiunea imediat următoare celei de apel a metodei. Porțiune de cod din care se face
apelul metodei
se numeste cod apelant, iar porțiune de cod corespunzătoare metodei apelate se numeste cod
apelat.
Metoda poate avea zero sau mai mulți parametri. Parametrii sunt valori transferate metodei în
momentul apelului acesteia. Aceste valori, dacă există, vor putea fi prelucrate în corpul
metodei pentru
a produce rezultatele întoarse cu return.
Apelul unei metode se face se face cu ajutorul operatorului punct. Forma generală a unui apel
de metodă este refObiect.nume_met(argumente), în situația exemplului de mai sus apelul de
metodă este p1.setX(12). Metodele nu au nevoie de parametri. Folosirea parametrilor permite
însă o generalizare a meteodei în sensul că aceasta va putea opera cu mai multe date de intrare
si/sau în mai multe situații ușor distincte. Termenul de parametru se foloseste pentru o
variabilă definită la nivelul metodei care primește o valoare în momentul apelării metodei.
Persistența și vizibilitatea parametrilor este limitată la corpul metodei. Termenul de argument
se foloseste pentru o valoarea care se transferă metodei atunci când aceasta este apelată.
Astfel, în exemplul prezentat abscisa este parametru, iar 12 este argument.
Exită două tipuri de parametri în Java: tipuri primitive si referințe la obiecte. În cazul
ambelor categorii de parametri apelul se face întotdeauna prin valoare. Respectiv metoda
primeste o copie a argumentelor prin stivă si nu va putea să modifice conținutul inițial al
argumentelor ce se transferă în parametrii din interiorul metodei. În cazul parametrilor de tipul
referință la obiect se poate modifica starea obiectului utilizând metodele puse la dispoziție în
acest scop, dar nu se pot modifica referințele originale ale argumentelor de tipul referință la
obiect în corpul metodei.
3. Domenii de utilizare
În cea mai mare parte, Java este utilizat pentru dezvoltarea aplicațiilor web, dar se pot
crea de la simple aplicații pentru mobil până la programe destinate unor centre de date imense.
În topuri, indiferent că vorbim de număr de utilizatori, număr programatori, locuri de muncă
sau altele, Java este pe locurile fruntașe. Această popularitate este datorată unor 3 mari factori:
-Este disponibil pe cele mai multe dispozitive. Aici nu ne referim doar la computere, console,
smartphone-uri, supercomputere, centre de data etc. Aproximativ 3 miliarde de aparate
utilizează Java.
-Este creat astfel încât să elimine cele mai multe erori de programare – bug-uri. De aceea
programatorii îl preferă.
-Este un limbaj foarte sigur, iar programele executate pe internet nu prezintă riscul de a fi
infectate.
Într-un grafic publicat de Github.com este prezentat clasamentul popularității limbajelor de
programare de-a lungul anilor.
Unde poți folosi Java ? Aproape orice fel de program la care te poți gândi. Java este un
limbaj care poate fi compilat atât local, cât și la distanță prin intermediul unui server. O dată
cu revoluția telefoanelor inteligente, Java a prins aripi și a devenit programul numărul unu în
crearea de aplicații. Să enumerăm câteva domenii de aplicare:
-Dezvoltarea aplicațiilor mobile: Câte aplicații aveți pe telefon? Singur ați jucat un
CandyCrush în drum spre serviciu. Aceste aplicații au fost create într-o combinație de Java/C.
-Dezvoltarea site-urilor: Dacă vreți să puneți la punct un site care așteaptă milioane de click-
uri zilnice, Java este soluția. Însuși Twitter utilizează o mașină virtuală Java (JVM).
-Conectarea la baze de date: Este util și pentru memorarea și extragerea datelor dintr-o bază
de date. Java utilizează aici interfața JDBC special creată pentru lucrul cu baze de date.
-Dezvoltarea interfețelor grafice: Java îți dă voie să creezi programe care au aceeași interfață
indiferent de sistemul de operare. Acest lucru se realizează cu ajutorul claselor Java Swing. Și
lista poate continua. Java este programul pe care te poți baza în orice domeniu.
Miniaplicații Java
O mare parte din popularitatea lui Java pornește de la posibilitatea dezvoltării unor aplicații
mici
(applets, în engleză) care pot fi înglobate în pagini HTML s-i descărcate prin rețea atunci cînd
pagina
este vizualizată într-un navigator de Web.
Există două tipuri de miniaplicații Java: cu și fară încredere (trusted și untrusted, în engleza˘).
Miniaplicațiile “fără încredere” sînt restricționate din punctul de vedere al accesului local, cele
“de
încredere” au permisiunea accesării resuselor locale.
Caracteristicile miniaplicațiilor
Miniaplicațiile sînt de natură grafică, tinzînd să conțină controale cum sînt butoanele, cutiile
de text,
listele de selecție. Totuși, miniaplicațiile pot să facă mult mai mult decît simpla afișarea unor
controale
(obiecte de interfață grafice). Iată o listă cu cîteva dintre posibilitățile miniaplicațiilor:
-vizualizarea de animații, imagini și redare de sunete;
-conectarea la baza de date aflată pe serverul de Web de pe care s-a descărcat miniaplicația;
-comunicația cu un server de Web prin socketuri
-comunicația cu o aplicația Java rulată pe sereverul de Web;
-pot utiliza CORBA (Common Object Request Broket Architecture) pentru a comunica
cu Java sau cu aplicații ne-Java de pe server-ul de Web.
Aplicații client
Miniaplicațiile Java pot fi rulate pe un sistem de operare local sub forma unor aplicații de sine
stătătoare. Acest mod de lucru este specific dezvoltării de aplicații client (aplicația este
descarcată de
pe un server dar rulata în navigator, care este clientul serverului de Web) și este, uzual, fară
restricțiile
de securitate specifice miniaplicat-iilor. De exemplu, aplicațiile Java pot accesa sistemul local
de fișiere
sau să stabilească conexiuni cu alte mașini prin rețea. Miniaplicațiile pot beneficia de aceste
facilități
doar dacă au fost înregistrate că sînt de încredere; restricția previne coruperea sistemului local
de fișiere
de către miniaplicații malițioase. Caracteristici adiționale ale miniaplicațiilor de încredere sînt:
-accesul la sistemul de fișiere local;
-accesul la o mașină distinctă de server-ul de pe care s-a descărcat miniaplicația;
-lansarea în execuție a unor programe noi sau încărcarea de biblioteci locale.
Aplicații sever
Aplicațiile Java pot fi, de asemenea, rulate pe o mașină server dacă JVM este disponibilă pe
platforma
respectivă. Rularea pe server asigură dezvoltarea de aplicații după modelul celor 3 nivel
specifice
calculului pe Internet. Aplicatia server ruleaza în mod continuu pe server și trimite un raspuns
unui
client ca urmare a unei cerei efectuate de acesta.
4. Aplicația Calculator
Pentru a aplica în practică toate cunoștințele obținute, am realizat în final un mic soft
care permite care permite efectuarea diverselor operații cu numere, realizat într-o interfață
grafică comodă și ușor de utilizat (Vezi Anexa B, Cod Sursă B.3). Pentru construirea interfeței
grafice, am folosit JavaFX. Drept IDE, am folosit Eclipse. Un mic istoric despre JavaFX.
JavaFX este urmașa lui F3 (Form Follows Function) ce îl are ca părinte pe Chris
Oliver. În 2010 Oracle a anunțat că dezvoltarea lui JavaFX Script language va fi întreruptă, în
schimb aceasta se va porta pe Java, formând platforma JavaFX 2. Prin aceasta se puneau
bazele ca JavaFX să devină cel mai important mediu pentru aplicații rich client.
API-ul JavaFX este rulat de un engine compus din subcomponente. Acesta cuprinde noul
engine grafic de înaltă performanță numit Prism, sistemul eficient de windowing numit Glass
și un engine media.
Glass Windowing Toolkit este responsabil cu furnizarea unui serviciu nativ ce include
gestiunea ferestrelor, a timer-elor și a suprafețelor. De asemenea, leagă platforma JavaFX de
sistemul de operare nativ. Mai mult, Glass este responsabil de gestiunea cozii de evenimente.
Dacă AWT își gestionează propria coadă de evenimente, Glass utilizează coada nativă a
sistemului de operare. Glass Toolkit rulează în același fir ca și aplicația JavaFX. În AWT se
crea un fir de execuție paralel cu cel al Javei.
O aplicație rich client este o aplicație ce are o interfață care reprezintă backend-ul fără a
aglomera astfel interfața utilizator. JavaFX are un set complet de butoane, diagrame, tabele și
container-e de layout pe care le folosim pentru a crea interfețe utilizator rich. În plus, putem
folosi stiluri CSS. Toate componentele se conectează și afișează date din backend. O aplicație
JavaFX este o aplicație Java de bază, ce permite feature-uri JavaFX. Codul minim necesar
pentru a rula o aplicație JavaFX constă din:
-O clasă ce extinde clasa abstractă javafx.application.Application.
-O metodă main() ce apelează metoda launch() și suprascrie metoda abstractă start(). Ca bună
practică apelul metodei launch() este singurul apel din main()
-Un stage primar ce este vizibil, ca argument al metodei start()
Avem trei tipuri de aplicații JavaFX:
-Aplicații propriu zise, ce folosesc sintaxa Java tradițională și API-ul JavaFX.
-Aplicații FXML. FXML se bazează pe XML și este folosit pentru a defini interfețe-utilizator
în aplicații JavaFX. Cu FXML vom defini layout-uri statice precum formulare, controale sau
tabele. Putem construi, de asemenea, layout-uri dinamice prin includerea unui script.
-Aplicații preloader, folosite în procesul de deployment.
Aplicația MyCalculator, este compusă din 4 fișiere. Main.java, MainController.java,
application.css și MainInterface.fxml.
Concluzie:
În urma acestui stagiu de practică, sub denumirea de Practica în Producție, am
acumulat o experiență în care am reușit să însușesc un nou limbaj de programare Java, iar într-
un final să formez o aplicație cu o interfață plăcută pentru utilizator. Studiind pînă la moment
diverse cursuri în care am studiat diverși algoritmi, alte limbaje, am simțit o oarecare ușurință
în studierea materialului nou. Astfel ase formează o percepere în care reușești să procesezi
etapele prin care e nevoie de trecut pentru a crea o aplicație. În cazul meu am reușit să formez
aplicația MyCalculator. La începerea stagiului de practică, eram puțin familiarizat cu noul
limbaj. Studiind teoria despre Java, lucrurile au început să capete o valoare și treptat prin
mini-programe s-a ajuns în a crea un mic soft mai avansat. Pentru viitor, voi continua să
întăresc cunoștințele căpătate prin diverse proiecte. În viitor plănuiesc să caut un job în care se
va utiliza limbajul de programare Java.
Bibliografie:
1 https://docs.oracle.com/javase/tutorial/java/index.html - Learning the Java Language
2 http://docs.oracle.com/javase/8/javase-clienttechnologies.htm - JavaFX
3 https://www.youtube.com/ - Tutoriale
Anexa A
Tabele
Tabelul A.1 – Tipuri de date primitive
Tip de date Valoare Valori cu semn Tip
primitiv default
byte 0 -128 -> 127 întreg
short 0 -32768 –> 32767 întreg
int 0 -2147483648 –> 2147483647 întreg
long 0L -9,223,372,036,854,775,808 –> întreg
9,223,372,036,854,775,807
float 0.0f 7 cifre semnificative real simpla
precizie
double 0.0d 15 cifre semnificative real dublă precizie
char ‘\u0000’ ‘\u0000’ -> ‘\ffff’ caracter Unicode
0 -> 65535 pe 16 biți
boolean false true sau false logic
Anexa B
Listingul Programelor exemple
Cod Sursă B.1 – Exemplul creare o clasă
//Definitia unei clase
public class Punct {
//Campuri
private double x;
private double y;
//Constructori
Punct() {
setX(0);
setY(0);
}
Punct(double abscisa, double ordonata) {
setX(abscisa);
setY(ordonata);
}
// Metode
public void setX(double abscisa) {
x = abscisa;
}
public void setY(double ordonata) {
y = ordonata;
}
public double x() {
return x;
}
public double y() {
return y;
}
public double distantaOrigine() {
return Math.sqrt(x*x+y*y);
}
public String toString() {
return "<" + x + "," + y + ">";
}
}
public class Grafica {
public static void main(String[] args) {
Punct p1; //declararea var. obiect p1 de tipul clasa Punct
Punct p2 = new Punct(-1,7); //decl. + creare + initializare
p1 = new Punct(); //creare + initializare obiecte p1
System.out.println("p1 = " + p1);
System.out.println("p2 = " + p2);
p1.setX(12);
p2.setY(13.345);
System.out.println("p1 = " + p1.toString());
System.out.println("p2 = " + p2);
}
}
Cod sursă B.2 – Polimorfismul
Coordonate c1 = new Coordonate();
Coordonate c2 = new Coordonate(1,2);
Punct p1 = new Punct();
c1 = p1; //atribuire polimorfica
System.out.println(c1);
c1 = c2;
System.out.println(c1);
P(0.0,0.0) //c este un p
(1.0,2.0) // c este un c
Cod sursă B.3 – MyCalculator
Main.java
package application;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.stage.Stage;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;
scene.getStylesheets().add(getClass().getResource("/application/application.css").to
ExternalForm());
primaryStage.setScene(scene);
primaryStage.show();
} catch(Exception e) {
e.printStackTrace();
}
}
MainController.java
package application;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.*;
@FXML
private Label display;
private double firstNum = 0;
private double secondNum;
private String operatorInput;
private double result;
private String text;
private boolean isDel = false;
private boolean decimal = false;
private boolean multiply = false;
private boolean start = false;
@FXML
public void processDel (ActionEvent event){
if (display.getText().equals("")) return;
isDel = true;
processNum(event);
}
@FXML
public void processNum (ActionEvent event) {
text = ((Button)event.getSource()).getText();
start = true;
if (isDel == true){
text = display.getText();
text = text.substring(0, text.length() - 1);
isDel = false;
display.setText(text);
}else{
if(display.getText().equals("0") || display.getText().equals("ErDivide
by zero") || display.getText().equals("ErrSqrtFromNegative")){
display.setText(text);
}
display.setText(display.getText() + text);
text = display.getText();
}}
@FXML
public void processOperators (ActionEvent event) {
double value = 0;
decimal = false;
operatorInput = ((Button)event.getSource()).getText();
switch (operatorInput){
case "C":
display.setText("");
start = false;
break;
case "±":
if (multiply == false){
value =
BigDecimal.valueOf(Double.parseDouble(display.getText())).doubleValue();
value = value * (-1);
display.setText(String.valueOf(value));
}
else {
value =
BigDecimal.valueOf(Double.parseDouble(display.getText())).doubleValue();
value = value * (-1);
secondNum = value;
display.setText(String.valueOf(value));
}
break;
case "√":
firstNum =
BigDecimal.valueOf(Double.parseDouble(display.getText())).doubleValue();
if (firstNum < 0){
display.setText("ErrSqrtFromNegative");
}else {
result = Math.sqrt(firstNum);
if(String.valueOf(result).endsWith(".0"))
display.setText(String.valueOf((int)result));
else
display.setText(String.valueOf(result));
}
break;
case "%":
if(multiply == true){
secondNum =
BigDecimal.valueOf(Double.parseDouble(display.getText())).doubleValue();
result = firstNum * secondNum / 100;
display.setText(String.valueOf(result));
multiply = false;
}else{
firstNum =
BigDecimal.valueOf(Double.parseDouble(display.getText())).doubleValue();
result = firstNum / 100;
display.setText(String.valueOf(result));
}
break;
case "÷":
case "x":
case "-":
case "+":
case "x^":
multiply = true;
firstNum = Double.parseDouble(display.getText());
result = firstNum;
display.setText("");
break;
}
}
@FXML
public void processDecimal (ActionEvent event) {
if(decimal == false){
display.setText(display.getText() +
((Button)event.getSource()).getText());
decimal=true;
}
}
@FXML
public void processEqual (ActionEvent event) {
if(start == false) {
display.setText("0");
return;
}
if (multiply == true){
secondNum = Double.parseDouble(display.getText());
multiply = false;
}
switch (operatorInput){
case "÷":
if(secondNum == 0){
display.setText("ErDivide by zero");
return;
}
else{
result = BigDecimal.valueOf(result / secondNum).setScale(9,
RoundingMode.HALF_UP).doubleValue();
}
break;
case "x":
result = BigDecimal.valueOf(result * secondNum).setScale(9,
RoundingMode.HALF_UP).doubleValue();
break;
case "-":
result = BigDecimal.valueOf(result - secondNum).setScale(9,
RoundingMode.HALF_UP).doubleValue();
break;
case "+":
result = BigDecimal.valueOf(result + secondNum).setScale(9,
RoundingMode.HALF_UP).doubleValue();;
break;
case "x^":
result = BigDecimal.valueOf(Math.pow(result,
secondNum)).setScale(9, RoundingMode.HALF_UP).doubleValue();
break;
default:
display.setText("Invalid symbol");
break;
}
if (String.valueOf(result).endsWith(".0"))
display.setText(String.valueOf((int)result));
else
display.setText(String.valueOf(result));
}
}
application.css
/* JavaFX CSS - Leave this comment until you have at least create one rule which
uses -fx-Property */
#operator{
-fx-background-color:
linear-gradient(#ffd65b, #e68400),
linear-gradient(#ffef84, #f2ba44),
linear-gradient(#ffea6a, #efaa22),
linear-gradient(#ffe657 0%, #f8c202 50%, #eea10b 100%),
linear-gradient(from 0% 0% to 15% 50%, rgba(255,255,255,0.9),
rgba(255,255,255,0));
-fx-background-radius: 0;
-fx-background-insets: 0,1,2,3,0;
-fx-text-fill: #654b00;
-fx-font-weight: bold;
-fx-font-size: 25px;
-fx-padding: 10 20 10 20;
}
#operator:hover{
-fx-border-style:solid;
-fx-border-width:2px;
-fx-border-color:#f57a00;
-fx-border-radius:1px;
}
#nums:hover{
-fx-border-style:solid;
-fx-border-width:2px;
-fx-border-color:#62c8d5;
-fx-border-radius:1px;
}
#nums{
-fx-background-color:
#c3c4c4,
linear-gradient(#d6d6d6 50%, white 100%),
radial-gradient(center 50% -40%, radius 200%, #e6e6e6 45%,
rgba(230,230,230,0) 50%);
-fx-background-radius: 0;
-fx-background-insets: 0,1,1;
-fx-text-fill: black;
-fx-effect: dropshadow( three-pass-box , rgba(0,0,0,0.6) , 3, 0.0 , 0 , 1 );
}
MainInterface.fxml
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.geometry.Insets?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.ColumnConstraints?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.RowConstraints?>
<?import javafx.scene.text.Font?>