FIŞA DE ACTIVITATE

Săptâmâna 29 iunie -3 iulie

Sarcini planificate: ___________ Crearea raportului de practică
___________________________________________________
______________________________________________________________________________
______________________________________________________________________________
Activităţi desfăşurate, observaţii personale

MINISTERUL EDUCAŢIEI al REPUBLICII MOLDOVA

UNIVERSITATEA TEHNICĂ a MOLDOVEI
FACULTATEA CALCULATOARE, INFORMATICǍ
şi MICROELECTRONICǍ
CATEDRA AUTOMATICĂ şi TEHNOLOGII INFORMAŢIONALE

Practica în producție
Tema: Crearea unei aplicații calculator științific în limbajul JAVA.

Conducătorul practicii de la catedră:Sava Nina

Conducătorul practicii de la întreprindere:Răducanu Octavian

Executant: Turculet Victor

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

2.Principii de funcționare în Java. Tipuri de date și variabile

Î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.1. Cuvinte-cheie rezervate

Se numește gramatică o mulțime de definiții formale ce alcătuiesc structura sintactică
(numită, pe scurt și sintaxă) a unui limbaj. Gramatica este definită în termenii unor reguli de
generare ce descriu ordinea constituenților dintr-o propoziție. Fiecare regulă are o parte stîngă,
numită categorie sintactică și o parte dreaptă formată dintr-o secvență de simboluri.
Simbolurile pot fi terminale sau neterminale. Un simbol terminal corespunde unui constituent
de limbaj care nu mai are o structură sintactică internă. Cuvintele cheie reprezintă o mulțime
de simboluri terminale care fac parte din sintaxa limbajului Java. Restricția de bază referitoare
la acesta este cea conform căreia nu se pot da nume de variabile care să aibă aceeași scriere cu
acestea. Pe lîngă cuvintele cheie numele const și goto sunt și ele rezervate și nu pot fi folosite
ca nume de variabile.
Cuvintele cheie rezervate sunt:
-Tipuri primitive (boolean, byte, char, double, float, int, long, short, void, false, null,
true)
-Modificatori (abstract, final, native, private, protected, public, static, synchronized,
transient, volatile)
-Instrucțiuni (break, case, catch, continue, default, do, else, finally, for, if, return,
switch, throw, try, while)
-Tipuri definite de utilizator ( class, extends, implements, interface, throws, import,
package, instanceof, new, super, this)

2.2. Programarea Orientată pe Obiecte și Java

Programarea Orientată pe Obiecte este o paradigmă de programare care utilizează
obiecte și interacțiuni între acestea pentru a modela arhitectura unui program.
Până în anii '60, paradigma cea mai utilizată era cea a programării structurate.
Programarea structurată este tipul de programare pe care l-ați folosit până acum, la cursul de
Programare și la cel de SD. Această paradigmă constă în utilizarea funcțiilor și procedurilor
pentru a realiza un program (cu eliminarea apelurilor GOTO). Totuși, în anii '60, deja pe
măsură ce programale deveneau din ce în ce mai mari, randamentul programatorilor scădea și
în consecință TTM-ul (time-to-market) creștea. Stilul de programare structurată nu mai făcea
față unor programe de dimensiuni mereu în creștere.
Fiecare paradigmă de programare propune un nivel de împărțire a taskului de realizat
(adică a programului) în taskuri mai mici pentru a micșora complexitatea. Astfel, într-un
program monoprocedural, unitatea de abstractizare este instrucțiunea. În programarea
structurată este funcția/procedura. Programarea Orientată Obiect (POO) propune pentru acest
lucru obiectul. Obiectele în POO modelează (sau ar trebui să modeleze dacă arhitectură
aplicației este corectă) obiecte din lumea reală.
Obiectele din POO sunt instanțe ale unui tip de date numit clasă. Relația dintre clasă și
obiect-instanță a acelei clase este exemplificată de relația între conceptul de masă și masă din
sufragerie. Adică:
-conceptul de masă implică existența anumitor caracteristici (un număr de picioare și
un blat, totul de o anumită culoare)
-conceptul de masă implică realizarea potențială a unor acțiuni (se poate mânca pe
masă)
-obiectul masă are caracteristicile respective (4 picioare, culoare neagră)
-obiectul masă permite realizarea practică a acțiunilor respective (se poate mânca doar
pe masă fizică, nu pe ideea de masă)
Clasa descrie un model sau un șablon de stare si de comportament pentru obiecte.
Definiția unei clase constă în date (cîmpuri) și metode (proceduri de calcul). Clasa este un tip
de date definit de utilizator pe baza careia se vor crea noi obiecte din respectiva clasa.
Definitia unei clase consta în:
-modificatori de acces: definesc vizibilitatea clasei în raport cu alte clase (public);
-class: cuvânt cheie care anunta Java ca urmeaza un bloc pentru definirea unei clase;
-câmpuri: variabile sau constante care sunt folosite de obiectele clasei (x si y);
-constructori: metode care controleaza starea initiala a oricarui obiect din
clasa(Punct() si Punct(double abscisa, double ordonata));
-metode: functii care controleaza valorile stocate în câmpuri (setX(), setY() ...).
(Pentru a urmări un exemplu, Vezi Anexa B, Cod Sursă B.1)
Ce remarcăm este că există niște tipare în lumea reală, care grupează în mintea noastră
niște atribute ale obiectelor cu acțiunile lor, pentru a forma un tot ce definește obiectul
respectiv. Pe acest concept, numit încapsulare, se sprijină programarea orientată obiect.
Folosirea POO permite realizarea de sisteme informatice de dimensiuni mărite, cu
timpi de dezvoltare, testare și mentenanță reduși față de paradigmele anterioare. Totuși, pentru
a creă un sistem funcțional este necesară înțelegerea corectă a conceptelor care stau în spatele
POO. Cu aceste concepte se ocupă cursul și laboratoarele de POO.
Orientată pe Obiecte se poate aplică în orice limbaj care permite acest lucru. Cele mai
cunoscute asemenea limbaje astăzi sunt C++, Java, C#, chiar și PHP. În acest semestru vom
ilustra conceptele de POO folosind limbajul Java.
Java a pornit că o platformă de programare pentru sisteme embedded. Țelurile principale ale
proiectului erau:
-independența de sistem
-utilizarea POO.
Astăzi, Java este folosită mai mult ca o platformă pentru Internet și a atins o utilizare
impresionantă.
Java este un mediu (platformă) de programare care constă în:
-un limbaj de programare (Java) care descrie programatorului ce instrucțiuni sunt
valide și ce face fiecare
-un compilator (javac.exe (Windows) / javac (Linux)) care transformă fișierul sursă
într-un limbaj intermediar numit bytecode
-o mașină virtuală, Java Virtual Machine (JVM), care permite transformarea codului
intermediar în instrucțiuni executabile pe procesorul curent.
-o bibliotecă puternică ce răspunde foarte bine nevoilor apărute în practică (class
library)

2.3. Operatori

Variabilele și constantele se folosesc pentru stocarea datelor la nivelul aplicației.

Operatorii sunt
caractere speciale prin care Java este anunțat despre operația ce trebuie să o facă cu operanzii
asupra
cărora acționeaza. Operatorii au un efect și întorc un rezultat. Ei combina datele în expresii
pentru a
produce valori noi.
Operatorul de atribuire
Operatorul de atribuire da unei variabile o valoarea a unui literal sau o valoarea ce se obtine ca
urmare
a evaluarii unei expresii.
Operatorii aritmetici
Operatorii aritmetici realizeaza operatiile aritmetice de baza (adunare, scadere, înmultire si
împartire)
cu operanzii. Pot fi utilizati pentru toate tipurile numerice.
Operatorii pe biti
Operatorii pe biti permit interactiunea cu reprezentarea interna pe biti ale tipurilor numerice
întregi
permitând actiunea la nivel de bit. Daca operatorii aritmetici trateaza o valoare numerica
unitar, cei pe
biti permit modificarea individuala a fiecarui bit din valoarea întreaga.
Operatorii relationali
Operatorii relationali permit compararea a doua valori. Rezultatul comparatiei este bolean si
poate fi
utilizat pentru setarea unor valori sau pentru controlul executiei programului.
Operatori booleeni (logici)
Operatori booleeni pot fi utilizati numai cu valori boleene sau ca rezultat întotdeauna o
valoare boleana.

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.5. Operatori aritmetici

Operanzii unei operatii aritmetice trebuie sa fie numerici, iar rezultatul va fi si el
numeric. Câteva dintre problemele arimeticii simple în Java sunt:
-în expresiile în care participa operatorii aritmetici, ordinea evaluarii lor este data de
prioritatea si asociativitatea lor. *, / si % au prioritatea mai mare decât + si -, motiv pentru
care aceste operatii vor fi evaluate înainte de adunare si scadere;
-parantezele rotunde modifica prioritatea evaluarilor aritmetice, aceasta începând de la
parantezele cele mai interioare;
-împartirea între întregi întoare rezultat întreg (eventuala parte zecimala este ignorata);
-împartirea întreaga cu 0 genereaza o exceptie;
-împarțirea reală cu 0. întoarce infinit (Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY) sau rezultat nenumerice (Not A Number Double.NaN).
Aritmetica numerelor întregi
Toate operatiile aritmetice se fac cu tipurile int sau long, valorile byte, char sau short fiind
automat promovate la int înainte de efectuarea operatiilor, rezultatul fiind si el un int. Similar,
daca
un operand este de tipul long, iar celalat nu, acesta va fi automat promovat la long, iar
rezultatul va
fi long. Daca însa se încerca atribuirea unui rezultat cu reprezentare mai lunga unei variabile
ce are
un tip cu reprezentare (în octeti) mai scurta se primeste o eroare la compilare. Terminologia
folosita în
situatia în care se doreste stocarea unei valori de un tip într-o variabila de un alt tip se numeste
fortare
de tip (type casting). Fortarea de tip poate produce rezultate ciudate, fie codul:
byte b1 = 1, b2 = 2, b3;
b3 = b1+b2; // eroare, rezultatul este de tip int
b3 = (byte) (b1+b2) // aici avem fortare de tip - asa merge, dar pot
// aparea ciudatenii
daca, b1 si b2 iau valoarea 120 fiecare, rezultaul va fi incorect. Fortarea de tip face ca
reprezentarea pe
biti a valorii sa fie copiata din sursa în destinatie. Daca rezultatul nu “încape” în destinatie se
pierd date.
Una dintre necesitatile curente la nivelul aplicatiilor este aceea de adunare sau de
scadere a lui 1 din valoarea unei variabile. Rezultatul poate fi obtinut sprin folosirea
operatorilor + si – după cum urmează:
varsta = varsta + 1;
zileconcediu = zileconcediu - 1;
Totusi, incrementarea sau decrementarea sunt operatii atât de comune încât exista
opratori unari (au un singur operand) specifici în acest scop: incrementarea (++) si
decrementarea (--). Ei pot fi scrisi în fata (pre-increment, pre-decrement) sau dupa (post-
increment, post-decrement) o variabila. În forma
prefixată operația (incrementarea sau decrementarea) este realizată înainte de orice alte
calcule sau
atribuiri. În forma prefixată, operația este realizată după toate calculele sau eventualele
atribuiri, astfel
încât valoarea originală este cea folosită în calcule si nu cea actualizată.
Operatorii relationali, unori numiti si de comparare a expresiilor, se folosesc la testarea
unor conditii
între doua expresii si întorc un rezultat de tipul boolean. Sintaxa generala a unei comparatii
este:
rezultat = expresie1 operator relațional expresie2.
Operatorii relaționali sunt:
-(>, mai mare)
-(>=, mai mare sau egal)
-(<, mai mic)
-(<=, mai mic sau egal)
-(!=, diferit)
-(= =, egal)
Operatorii logici, uneori numiți si booleeni, trebuie să aibă operanzi booleeni (adică de
tipul boolean)
si genereaza rezultate booleene. Denumirea lor a fost data în cinstea matematicianului britanic
George
Boole (1815-1864). El a pus la punct un sistem matematic ce opereaza valorile de adevar: true
(adevarat), flase (fals) si functiile logice: AND (SI), OR (SAU) si NOT (NU). Funcțiile logice
au fost
implementate, în Java, sub forma operatorilor logici care au scrierea && pentru AND , ||
pentru OR
și ! pentru NOT. Operatorii logici se definesc prin tabele de adevar. Acestea reprezinta toate
combinatiile posibile ale operanzilor împreuna cu rezultatele corespondente operatorului
logic.
Expresiile care contin operatori logici se evalueaza cu scurtcircuitare. Evaluarea se
face de la stânga la dreapta (aceasta ordine de evaluare este garantata numai pentru operatorii
logici) si imediat ce valoarea expresiei logice devine cunoscuta evaluarea celorlati operanzi se
termina. && si || permit utilizarea evaluarii cu scurtcircuitare, daca expresia din stânga
operatorului a a determinat deja valoarea întregii expresii logice, expresia din dreapta lui nu se
mai evalueaza. Dacă în e1 && e2, e1 ia valoarea
false, e2 nu se mai evalueaza deoarece oricum rezultatul va fi false. Daca în e1 || e2, e1 ia
valoarea true, e2 nu se mai evalueaza deoarece rezultatul este oricum true. Exista si operatori
logici care se evalueaza fara scurtcircuitare. Ei au o scriere diferită, astfel pentru ȘI se scrie &
iar pentru SAU se scrie |. Utilizarea lor se face în situatii în care scurtcircuitarea poate produce
rezultate ciudate, de exemplu fie expresia func1() && func2(), daca functia func1() va
întoarce rezultatul false functia func2() nu va mai fi apelata. Vor exista, deci, cazuri în care
func2() nu va fi apelata, iar daca aceasta face ceva semnificativ în cod lipsa apelului va duce
la rezultate eronare.
Prioritatea operatorilor Java. (Vezi Anexa A, Tabelul A.2). În Java orice expresie are
un tip (primitiv sau referință) determinat în faza de compilare. În cazul unor expresii
complexe într-o singuraˇ linie de program, Java foloseste un grup de reguli numite "de
precedență" pentru a determina ordinea de rezolvare a operatorilor. Aceste reguli asigură
consistența operațiilor aritmetice în cadrul programelor Java.

2.6. Șiruri de caractere în Java

Șir de caractere – este o secvență de caractere de lungime arbitrară. Java nu are implementat
un tip primitiv șir de caractere. Clasa String – clasă Java predefinită în pachetul
java.lang.String pentru manipularea șirurilor de caractere. Declarația:
String string; // declarația unei variabile șir
String hello = ”Hello”; //declararea unei variabile cu conținut
Operatorii, sunt: atribuirea(=), concatenarea(+), atribuirea compusă(+=). Această clasă conține
mai mult de 50 de metode. Pentru a le vizualiza și studia, e nevoie de utilizat documentația
JDK. Clasa String nu are o metoda pentru modificarea unui caracter al sirului, se zice ca
obiectele clasei sir sunt imuabile (immutable) - stabile, de neschimbat. Pentru modficarea
continutului unei variabile șir trebuie să creăm un șir nou.

2.7. Rularea programelor

O aplicație Java este formată din instrucțiuni. Procesul prin care JVM îndeplineste o
instrucțiune se numește rulare sau execuție. În Java terminarea rulării unei instructiuni se
poate face cu succes, cu
excepție sau cu eroare. O instructiune este formată din una sau mai multe expresii care se
ruleaza ca o singură acțiune. De exemplu x = 5 este expresie, în timp ce x = 5; este deja o
instructiune. O expresie terminată în caraterul ; se numește instrucțiune, iar caracterul ; se
numește terminator de instrucțiune. Tot
instrucțiuni sunt: x = 5.3*(4.1/Math.cos(0.2*y)); respectiv System.out.println(x);. Instrucțiuni
sunt inclusiv declaratiile simple sau multiple, cu sau fara initializare. Instructiunile vor fi
plasate în clase pentru alcatuirea aplicatiei functionale. Implicit, aplicatia Java începe din
metoda main, iar instructiunile se ruleaza secvential, adica de sus în jos, în ordinea scrierii lor
în aplicatie pâna la terminarrea rularii tutror instructiunilor. În situatia unei aplicații complexe
rularea poate devia de la prelucrarea secvențiala astfel, exista posibilitatea ramificarii la
nivelul rularii unor portiuni de cod pe baza unor conditii (if, switch), repetarea unui grup de
instructiuni atânt timp cât o expresie de control este adevarata (while, do while, for), saltul de
la o instructine la o alta în program (break, continue).

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.

2.9. Elemente a claselor

Constructori – definesc starea inițială a obiectelor. Acesta are același nme cu clasa și este
apelat automat după crearea obiectului, înainte ca operatorul new să se termine. Ele nu întorc
o valoare de un anumit tip, nici măcar void. Sintaxa: public nume_clasa(){... };
Supraîncărcarea – permite folosirea aceleiași sintaxe pentru obiecte de tip diferit. La nivel de
metode de clasă, apare atunci cînd avem mai multe metode cu același nume, dar cu declarații
de parametri distincte. Supraîncărcarea este o formă de polimorfism. Java se folosește de tipul
parametrilor din apel pentru a determina care dintre metodele supraîncărcate să le apeleze.
Referința this – este argument implicit al oricărei metode sau a obiectului curent. El poate fi
folosit în corpul oricărei metode ale obiectului curent. Sintaxa: public void setX(double x)
{this.x = x;}
Moștenirea – permite crearea unor ierarhii de clasificare. extends – se folosește în Java pentru
a descrie moștenirea între clase.
Referința super – este o referință la clasa de bază. Se utilizează la apelul constructorilor din
clasa de bază.
Polimorfism – definește abilitatea de a avea mai multe forme. Acesta generează subclase între
care avem o dependență de tipul ”is-a”.(Vezi anexa B, Cod sursă B.2)
Excepții – este o condiție de eroare ce modifică rularea normală a programului. Se face o
împărțire cu zero, se introduc date de intrare greșite, ș.a. Java are un mecanism de tratare a
acestor situații cu instrucțiunile try – catch.
Tablouri - pentru a putea utiliza un tablou cu tipul de baza dintre cele primitive trebuie să:
- declarăm o variabila de tipul tablou având nume_tablou, ce v-a stoca o referință către tablou
prin: tip [] nume_tablou; sau tip nume_tablou []; în acest moment
nume_tablou se inițializează cu valoarea specială null; această valoare se modifică la
adresa tabloului după utilizarea operatorului new;
- creăm tabloul folosind operatorul new specificînd lungimea acestuia (numărul maxim de
elemente pe care îl poate stoca); lungimea trebuie să fie o valoare întreaga de tipul int
(constanta sau expresie care se calculeaza în momentul rularii aplicatiei)
- inițializăm tabloul cu valori diferite de cele cu care acesta se inițializaeză implicit de către
Java.
Cele multidimensionale sunt un tablou de tablouri. Se folosesc mai mulți indici pentru
accesare.

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.

Figura 4.1 – Ierarhia proiectului

Fișierul Main.java, este fișierul în care se va executa fereastra noastra principală. Un
stage (javafx.stage.Stage) este un container GUI top level pentru toate obiectele grafice, iar un
scene (javafx.scene.Scene) este container-ul de bază. Stage-ul primar este construit de
platformă, dar pot fi construite și alte obiecte stage de către aplicație. Obiectele stage trebuie
să fie construite și modificate în firul aplicației JavaFX. Articolele individuale care se află în
interiorul scenei grafice sunt numite noduri. Fiecare nod este clasificat ca fiind:
-Branch sau un părinte, ceea ce înseamnă că poate avea descendenți.
-O frunză.
Primul nod din arbore este numit rădacină și nu are părinte.
Scena grafică este așadar o structură arborescentă. API-ul JavaFX face ca interfața grafică să
fie mai ușor de creat, mai ales când sunt implicate efecte vizuale complexe și transformări.
Fișierul application.css este fișierul ce conține stiluri CSS pentru interfața noastră
grafică, iar acesta este inclus în Main.java.
Fișierul MainInterface.fxml, conține fiecare detaliu folosit pentru crearea interfeței
grafice. Acesta este redactat în Scene Builder, iar apoi în final se actualizează detaliile
adaugate în fișier prin intermediul softului adăugător.
Fișierul MainController.java conține toate funcțiile care face ca programul să
funcționeze după anumite reguli. Funcțiile folosite și rolul lor vor fi enumerate mai în jos:
public void processNum (ActionEvent event) – se prelucrează fiecare tastare a unui
buton (de la 0-9) în soft oferindui fiecărui buton o valoare anumită (doar numerele).
public void processOperators (ActionEvent event) – se prelucrează fiecare tastare a
unui operator, precum (+,-,*,/,ș.a).
public void processDecimal (ActionEvent event) – oferă suportul cifrelor cu virgulă,
atunci cînd este tastată (.)
public void processEqual (ActionEvent event) – prelucrează rezultatul în urma tastării
(=), și afișîndul în display.
Ca și oricare aplicație, conține cazuri cînd programul poate da crash. Astfel am
prevăzut situații precum:
-împărțirea la zero
-radical dintr-un număr negativ
-evitarea tastării repetate a virgulei după un număr
-afișarea unui număr fix de cifre după virgulă
-și multe altele care vor permite funcționarea programului într-o manieră prietenoasă.

Figura 4.2 – Prognozarea erorilor

Într-un final, am obținut urmatorul soft:

Figura 4.3 – Interfața softului

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

Tabelul A.2 – Prioritatea operatorilor Java

Prioritate Simbol Asociativitate
1 ++ – + - ~ ! (tip) operatori unari de la dreapta la
stînga(DS)
2 */% înmulțire împărțire rest de la stînga la
dreapta(SD)
3 +-+ adunare scădere concatenare SD
4 << >> >>> deplasări(>>> completare cu 0) SD
5 < > <= relaționali SD
>=instanceof
6 == != Egalitate SD
7 & ȘI logic / pe biți SD
8 ^ SAU EXCLUSIV logic / pe SD
biți
9 | SAU logic / pe biți SD
 10 && ȘI logic SD
11 || SAU logic SD
12 ?: Operatorul condițional DS
13 = op= operatorii de atribuire DS

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;

public class Main extends Application {

@Override
public void start(Stage primaryStage) {
try {
Parent root =
FXMLLoader.load(getClass().getResource("/application/MainInteface.fxml"));
Scene scene = new Scene(root,1024,768,true);

scene.getStylesheets().add(getClass().getResource("/application/application.css").to
ExternalForm());
primaryStage.setScene(scene);
primaryStage.show();
} catch(Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {

launch(args);
}
}

MainController.java
package application;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.*;

public class MainController {

@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?>

<AnchorPane prefHeight="460.0" prefWidth="303.0"

xmlns="http://javafx.com/javafx/8.0.111" xmlns:fx="http://javafx.com/fxml/1"
fx:controller="application.MainController">
<children>
<Label fx:id="display" alignment="CENTER_RIGHT" layoutY="-32.0"
prefHeight="50.0" prefWidth="303.0" style="-fx-background-color: gray;"
textOverrun="CLIP" AnchorPane.bottomAnchor="366.0" AnchorPane.leftAnchor="0.0"
AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="24.0">
<font>
<Font size="38.0" />
</font></Label>
<GridPane layoutY="291.0" prefHeight="370.0" prefWidth="300.0"
AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0"
AnchorPane.rightAnchor="0.0">
<columnConstraints>
<ColumnConstraints hgrow="SOMETIMES" minWidth="10.0"
prefWidth="100.0" />
<ColumnConstraints hgrow="SOMETIMES" minWidth="10.0"
prefWidth="100.0" />
<ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
 <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
</columnConstraints>
<rowConstraints>
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
</rowConstraints>
<children>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="65.0" prefWidth="90.0" text="√">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processOperators"
prefHeight="65.0" prefWidth="118.0" text="C" GridPane.rowIndex="1">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="111.0" text="7" GridPane.rowIndex="2">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="128.0" text="4" GridPane.rowIndex="3">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="118.0" text="1" GridPane.rowIndex="4">
<font>
<Font size="30.0" />
</font></Button>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="80.0" prefWidth="89.0" text="x^"
GridPane.columnIndex="1">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processOperators"
prefHeight="65.0" prefWidth="121.0" text="±" GridPane.columnIndex="1"
GridPane.rowIndex="1">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="119.0" text="8" GridPane.columnIndex="1"
GridPane.rowIndex="2">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="156.0" text="5" GridPane.columnIndex="1"
GridPane.rowIndex="3">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="126.0" text="2" GridPane.columnIndex="1"
GridPane.rowIndex="4">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="184.0" text="0" GridPane.columnSpan="2"
GridPane.rowIndex="5">
<font>
<Font size="30.0" />
 </font>
</Button>
<Button id="operator" mnemonicParsing="false" onAction="#processDel"
prefHeight="65.0" prefWidth="183.0" text="Delete" GridPane.columnIndex="2"
GridPane.columnSpan="2">
<font>
<Font size="30.0" />
</font></Button>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="65.0" prefWidth="111.0" text="÷"
GridPane.columnIndex="3" GridPane.rowIndex="1">
<font>
<Font size="30.0" />
</font>
</Button>
<Button id="nums" mnemonicParsing="false" onAction="#processOperators"
prefHeight="65.0" prefWidth="115.0" text="\%" GridPane.columnIndex="2"
GridPane.rowIndex="1">
<font>
<Font size="30.0" />
</font>
</Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="135.0" text="9" GridPane.columnIndex="2"
GridPane.rowIndex="2">
<font>
<Font size="30.0" />
</font></Button>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="65.0" prefWidth="150.0" text="x"
GridPane.columnIndex="3" GridPane.rowIndex="2">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="86.0" prefWidth="100.0" text="6" GridPane.columnIndex="2"
GridPane.rowIndex="3">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processNum"
prefHeight="65.0" prefWidth="143.0" text="3" GridPane.columnIndex="2"
GridPane.rowIndex="4">
<font>
<Font size="30.0" />
</font></Button>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="65.0" prefWidth="116.0" text="-"
GridPane.columnIndex="3" GridPane.rowIndex="3">
<font>
<Font size="30.0" />
</font>
</Button>
<Button id="operator" mnemonicParsing="false"
onAction="#processOperators" prefHeight="71.0" prefWidth="76.0" text="+"
GridPane.columnIndex="3" GridPane.rowIndex="4">
<font>
<Font size="30.0" />
</font>
</Button>
<Button id="operator" cache="true" mnemonicParsing="false"
onAction="#processEqual" prefHeight="94.0" prefWidth="101.0" text="="
GridPane.columnIndex="3" GridPane.rowIndex="5">
<font>
<Font size="30.0" />
</font></Button>
<Button id="nums" mnemonicParsing="false" onAction="#processDecimal"
prefHeight="65.0" prefWidth="122.0" text="." GridPane.columnIndex="2"
GridPane.rowIndex="5">
<font>
<Font size="30.0" />
 </font>
</Button>
</children>
</GridPane>
</children>
<padding>
<Insets top="-28.0" />
</padding>
</AnchorPane>