"Procesul programarii are mai multe faze: se incepe cu definirea

CONCEPTELOR, dupa care se trece la stabilirea RELATIILOR

dintre ele. Abia dupa aceea se poate trece la scrierea codului"

Programe si modele

Aproape toate programele modeleaza o problema din lumea reala. Un model este o reprezentare simplificata sau o abstractiune a unui sistem. Modelul evidentiaza doar caracteristicile importante intr-un anumit context ale sistemului reprezentat. De exemplu, o masina de jucarie prezinta anumite detalii exterioare cum ar fi carcasa si rotile, dar nu include componente ca: motorul, rezervorul etc. Intr-un program, elementele cu ajutorul carora realizam modelarea sunt:

structurile de date secventele de instructiuni sau operatiile

In functie de limbajul de programare utilizat, constructiile care redau structurile de date si operatiile sunt mai mult sau mai putin expresive, adica mai mult sau mai putin apropiate de obiectele ce formeaza domeniul problemei de rezolvat. La nivelul cel mai de jos, din acest punct de vedere, se situeaza limbajele-masina si apoi limbajele de asamblare care dispun de structuri de date si operatii primitive cu care nu se pot modela probleme complexe. Limbajele de nivel inalt asa-numite structurate (de genul Pascal si C) aduc o crestere substantiala a nivelului de abstractizare mai ales in exprimarea operatiilor. Acestea sunt redate cu ajutorul structurilor de control (secventa, selectie si iteratie), iar "caramizile" din care este construit un program sunt subprogramele (functiile si procedurile). Structurile de date oferite de aceste limbaje raman insa destul de sarace pentru a acoperi complexitatea problemelor de rezolvat. Limbajele structurate au inspirat metodele procedurale folosite la dezvoltarea produselor software; ele se caracterizeaza prin:

Un program conceput conform unei metode procedurale pune accentul pe algoritmii care transforma datele initiale ale unei probleme in rezultate

Algoritmii sunt structurati in subprograme carora li se furnizeaza date sub forma de parametri sau care acceseaza datele respective prin intermediul unui fond global comun.

Programarea structurata este bazata pe ecuatia enuntata de Niklaus Wirth:

Structuri de date + Algoritmi = Program Limbajele de programare orientate pe obiecte (LPOO) aduc o noua viziune asupra dezvoltarii programelor, urmarind sa acopere "slabiciunile" limbajelor structurate privind structurile de date. Mai precis, programatorului i se da posibilitatea de a-si construi propriile tipuri de date, dotate cu operatiile necesare, care sa "mimeze" cat mai fidel entitatile din domeniul problemei de rezolvat. Un program dezvoltat cu ajutorul tehnologiei obiectuale are drept unitate de constructie nu subprogramul, ci obiectul.

1

In analogie cu ecuatia programarii structurate, se poate considera ca valabila urmatoarea relatie:

Date + Metode = Obiect Un obiect inglobeaza date si operatii si reprezinta o abstractiune a unei entitati din lumea reala. Astfel, abstractizarea (intelegand prin asta tranzitia de la entitatile domeniului problemei de rezolvat la programul care o modeleaza) este mai directa, mai naturala: Obiectele componente interactioneaza, iar rezultatul acestei interactiuni o reprezinta transformarea datelor de intrare in date de iesire, adica rezolvarea problemei. Intr-un program dezvoltat in maniera obiectuala NU mai avem date globale (sau in orice caz, foarte putine). Datele sunt repartizate si inglobate in obiecte. Putem spune ca metoda obiectuala de dezvoltare conduce la o mai buna respectare a unor principii ale ingineriei software cum ar fi:

localizarea si modularizarea: codul sursa corespunzator unui obiect poate fi scris si actualizat independent de alte obiecte;

ascunderea informatiei: un obiect are, dupa cum vom vedea si in lucrarile urmatoare, o interfata publica pe care celelalte obiecte o pot utiliza in vederea comunicarii. Dar, pe langa interfata publica, un obiect poate include date si operatii private, "ascunse" fata de alte obiecte, si care pot fi modificate oricand, fara a afecta restul obiectelor.

reutilizarea codului: multe clase de obiecte pot fi definite pe baza altor clase deja existente, preluandu-se automat (prin mostenire) continutul acestora din urma

Trecand la un limbaj de programare orientat pe obiecte nu inseamna ca "aruncam" principiile programarii structurate. Operatiile inglobate in obiecte nu sunt altceva decat un fel de subprograme (chiar daca au alt nume) care vor fi dezvoltate utilizand structurile de control cunoscute de la limbajele structurate.

Diferenta esentiala intre limbajele procedurale si cele obiectuale este aceea ca limbajele procedurale au un caracter imperativ, fiind axate pe "verbe" (subprograme), in timp ce limbajele obiectuale sunt concentrate in jurul "substantivelor" (datele).

2

Concepte fundamentale in programarea orientata pe obiecte

Principalele concepte ce stau la baza programarii orientate pe obiecte sunt:

Abstractizarea Incapsularea Modularitatea Ierarhizarea

Abstractizarea

Abstractizarea este una din caile fundamentale prin care noi, oamenii, ajungem sa intelegem si sa cuprindem complexitatea. O abstractiune buna este cea care scoate in evidenta toate detaliile semnificative pentru perspectiva din care este analizat un obiect, suprimand sau estompand toate celelalte caracteristici ale obiectului. In contextul programarii orientate pe obiecte, Booch ne ofera urmatoarea definitie a abstractiunii: Programarea orientata pe obiecte este o metoda de implementare in care programele sunt organizate ca ansamble de obiecte ce coopereaza intre ele, fiecare obiect reprezentand instanta unei clase; fiecare clasa apartine unei ierarhii in cadrul careia clasele sunt legate prin relatii de mostenire Aceasta definitie cuprinde trei parti importante, si anume:

obiectele si nu algoritmii sunt blocurile logice fundamentale; fiecare obiect este o instanta a unei clase. Clasa este o descriere a unei multimi de obiecte

caracterizate prin structura si comportament similare clasele sunt legate intre ele prin relatii de mostenire

Incapsularea

Incapsularea este conceptul complementar abstractizarii. Daca rezultatul operatiei de abstractizare pentru un anumit obiect este identificarea protocolului sau, atunci incapsularea are de a face cu selectarea unei implementari si tratarea acesteia ca pe un secret al respectivei abstractiuni. Prin urmare, Incapsularea este procesul in care are loc ascunderea implementarii unui obiect fata de majoritatea clientilor sai. Determinarea protocolului pentru un obiect trebuie sa preceada decizia privind implementarea sa. Sintetizand putem defini incapsularea astfel: Incapsularea este procesul de compartimentare a elementelor care formeaza structura si comportamentul unei abstractiuni; incapsularea serveste la separarea interfetei "contractuale" de implementarea acesteia. Din definitia de mai sus rezulta ca un obiect este format din doua parti distincte:

interfata (protocolul) implementarea interfetei

3

Abstractizarea este procesul prin care este definita interfata obiectului, in timp ce incapsularea defineste reprezentarea (structura) obiectului impreuna cu implementarea interfetei. Ascunderea structurii obiectului si a implementarii metodelor sale este ceea ce se intelege prin notiunea de ascundere a informatiei. Beneficiile incapsularii. Separarea interfetei unui obiect de reprezentarea lui permite modificarea reprezentarii fara a afecta in vreun fel pe nici unul din clienti, intrucat acestia depind de interfata si nu de reprezentarea obiectului-server. Incapsularea permite modificarea programelor intr-o maniera eficienta, cu un efort limitat si bine localizat.

Modularizarea

"Scopul descompunerii in module este reducerea costurilor prin posibilitatea de a proiecta si revizui modulele in mod independent" (Parnas & Britton). Clasele si obiectele obtinute in urma abstractizarii si incapsularii trebuie grupate si apoi stocate intr-o forma fizica, denumita modul. Modulele pot fi privite ca un fel de containere fizice in care declaram clasele rezultate in urma proiectarii la nivel logic. Asadar: Modulele formeaza arhitectura fizica a programului. Modularizarea consta in divizarea programului intr-un numar de subunitati care pot fi compilate separat, dar care sunt cuplate (conectate) intre ele. Gradul de cuplaj intre module trebuie sa fie mic, pentru ca modificarile aduse unui modul sa afecteze cat mai putine alte module. Pe de alta parte, clasele care compun un modul trebuie sa aiba legaturi stranse intre ele, care sa justifice gruparea lor la un loc. In acest sens, spunem ca un modul trebuie sa fie coeziv. Limbajele care suporta conceptul de modul fac in acelasi timp distinctia intre:

interfata modulului, formata din elementele (tipuri, variabile, functii etc) "vizibile" in celelalte module

implementarea sa, adica elemente vizibile doar in interiorul modulului respectiv.

Putem spune astfel ca incapsularea si modularizarea reprezinta procese similare dar care se desfasoara la nivele diferite: incapsularea se aplica la nivelul "microcosmosului" (obiectele), iar modularizarea la nivelul "macrocosmosului" (programele). In Java putem vorbi de 2 nivele de modularizare:

nivelul pachetelor: pachetele sunt colectii de clase inrudite d.p.d.v. logic. Interfata unui pachet este constituita de clasele publice (care pot fi importate de alte pachete), iar implementarea este data de restul claselor, "nepublice".

nivelul fisierelor sursa: clasele care formeaza un pachet pot fi continute intr-unul sau mai multe fisiere sursa si fiecare asemenea fisier poate fi compilat separat.

Reguli Generale de Modularizare

1. Structura fiecarui modul trebuie sa fie suficient de simpla pentru a putea fi complet inteleasa.

2. Implementarea unui modul trebuie sa depinda doar de interfetele altor module. Cu alte cuvinte trebuie sa fie posibila modificarea implementarii unui modul fara a avea cunostinte despre implementarea altor module si fara a afecta comportarea celorlalte module.

4

3. Acele detalii ale sistemului, care se presupune ca se vor modifica independent vor fi plasate in module diferite

4. Singurele legaturi intre module vor fi acelea a caror modificare este improbabila 5. Orice structura de date este incapsulata intr-un modul; ea poate fi accesata direct din

interiorul modulului dar nu poate fi accesata din afara modulului decat prin intermediul obiectelor si claselor continute in acel modul

Din aceasta perspectiva putem intelege definitia lui Booch asupra modularitatii: Modularitatea este proprietatea unui sistem care a fost descompus intr-un set de module coezive si slab cuplate.

Ierarhizarea

Abstractizarea este un lucru bun, dar in majoritatea aplicatiilor - exceptie facand doar aplicatiile banale - vom descoperi mai multe abstractiuni decat putem cuprinde la un moment dat. Incapsularea ne ajuta sa tratam aceasta complexitate prin ascunderea interiorului abstractiunilor noastre. Modularitatea ne ajuta si ea, oferindu-ne o modalitate de a grupa abstractiuni legate logic intre ele. Toate acestea desi utile, nu sunt suficiente. Adesea un grup de abstractiuni formeaza o ierarhie, iar prin identificarea acestor ierarhii, putem simplifica substantial intelegerea problemei. Ierarhizarea reprezinta o ordonare a abstractiunilor. Cele mai importante ierarhii in paradigma obiectuala sunt:

Ierarhia de clase (relatie de tip "is a") Ierarhia de obiecte (relatie de tip "part of")

Mostenirea (ierarhia de clase). Mostenirea defineste o relatie intre clase in care o clasa impartaseste structura si comportarea definita in una sau mai multe clase (dupa caz vorbim de mostenire simpla sau multipla). Asa cum aminteam mai sus, relatia de mostenire este cea care face diferenta intre programarea orientata pe obiecte si cea bazata pe obiecte. Semantic, mostenirea indica o relatie de tip "is a" ("este un/o"). De exemplu un urs "este un" mamifer si deci intre clasa ursilor si cea a mamiferelor exista o relatie de mostenire. Si in cazul programarii acesta este cel mai bun test pentru a detecta o relatie de mostenire intre doua clase A si B: A mosteneste pe B daca si numai daca putem spune ca "A este un fel de B". Daca A "nu este un" B atunci A nu ar trebui sa mosteneasca pe B. Prin urmare, mostenirea implica o ierarhie de tip generalizare/specializare, in care clasa derivata specializeaza structura si comportamentul mai general al clasei din care a fost derivata. Agregarea (ierarhia de obiecte) Agregarea este relatia intre doua obiecte in care unul dintre obiecte apartine celuilalt obiect. Agregarea reda apartenta unui obiect la un alt obiect. Semantic, agregarea indica o relatie de tip "part of" ("parte din"). De exemplu intre o roata si un automobil exista o astfel de relatie, intrucat putem spune ca "o roata este o parte din automobil"

5

Principiile POO abstractizare

pastrarea aspectelor importante (generale) si ignorarea detaliilor nesemnificative (specifice)

incapsulare ascunderea implementarii fata de client

modularizare impartirea unui sistem complex in parti (module) manevrabile

ierarhizare clasificarea pe nivele de abstractizare

polimorfism aceeasi forma sintactica poate avea diferite intelesuri in functie de contextul de

utilizare

Platforme de lucru Java Limbajul de programare Java a fost folosit la dezvoltarea unor tehnologii dedicate rezolvarii unor probleme din cele mai diverse domenii. Aceste tehnologii au fost grupate in asa numitele platforme de lucru, ce reprezinta seturi de librarii scrise in limbajul Java, precum si diverse programe utilitare, folosite pentru dezvoltarea de aplicatii sau componente destinate unei anume categorii de utilizatori. • J2SE (Standard Edition) Este platforma standard de lucru ce ofera suport pentru crearea de aplicatii independente si appleturi. De asemenea, aici este inclusa si tehnologia JavaWeb Start ce furnizeaza o modalitate extrem de facila pentru lansarea si instalarea locala a programelor scrise in Java direct de pe Web, oferind cea mai comoda solutie pentru distributia si actualizarea aplicatiilor Java. • J2ME (Micro Edition) Folosind Java, programarea dispozitivelor mobile este extrem de simpla, platforma de lucru J2ME oferind suportul necesar scrierii de programe dedicate acestui scop. • J2EE (Enterprise Edition) Aceasta platforma ofera API-ul necesar dezvoltarii de aplicatii complexe, formate din componente ce trebuie sa ruleze in sisteme eterogene, cu informatiile memorate in baze de date distribuite, etc. Tot aici gasim si suportul necesar pentru crearea de aplicatii si servicii Web, bazate pe componente cum ar fi servleturi, pagini JSP, etc. Toate distributiile Java sunt oferite gratuit si pot fi descarcate de pe Internet de la adresa ”http://java.sun.com”. In continuare, vom folosi termenul J2SDK pentru a ne referi la distributia standard J2SE 1.5 SDK (Tiger).

6

Dintre avantajele limbajului Java amintim următoarele: simplitatea – deşi sintaxa este bazată pe C++, limbajul Java este considerat mai simplu, deoarece au fost eliminate multe cuvinte cheie, nu mai există un preprocesor, iar limbajul are o bibliotecă mult mai bogată de unelte de dezvoltare; nu mai există funcţii independente, variabile globale, instrucţiunea goto şi lucrul liber cu pointeri, pointerii fiind inlocuiţi de referinţe şi deci nu mai este necesară o aritmetică a pointerilor; orientarea spre obiecte – Java a fost conceput pentru a respecta principiile programării orientate pe obiecte, folosind clase pentru organizarea logică a codului, clasa fiind unitatea de bază în elaborarea programelor. În afara claselor nu există variabile sau funcţii. La execuţie, programul creează obiecte de tipul claselor; aceste obiecte pot fi gândite ca nişte ajutoare care execută funcţiile clasei (numite metode); compilarea prealabilă urmată de execuţie pe maşina gazdă – un program sursă Java trebuie compilat rezultând un fişier “byte-code” (o secvenţă de instrucţiuni de asamblare pentru o maşină imaginară, numită maşina virtuală Java –Java Virtual Machine-JVM), care nu depinde de maşina gazdă pe care va fi executat programul. Programul byte-code poate fi apoi transferat pe orice maşină. Fiecare maşină gazdă capabilă să execute programe Java dispune de un emulator, care converteşte reprezentarea byte-code în instrucţiuni maşină proprii, care apoi sunt executate; conversia are loc la lansarea în execuţie şi anume instrucţiune cu instrucţiune. În acest mod este asigurată portabilitatea şi independenţa de platformă. Dezavantajul acestui mod de lucru constă în timpul mare de execuţie. O variantă pentru emulator o constituie compilatoarele JIT (Just in Time), care transformă programul byte-code nu instrucţiune cu instrucţiune, ci în întregime (la lansarea în execuţie) într-o formă executabilă pe maşina gazdă, ceea ce conduce la o creştere semnificativă a vitezei de execuţie; suport pentru multithreading, adică posibilitatea lansării mai multor fire de execuţie – permiţând astfel execuţia concurentă a mai multor acţiuni; colectarea de reziduuri – Java permite crearea explicită de obiecte (de tipul unei clase), iar distrugerea acestor obiecte este preluată de colectorul de reziduuri – Garbage Collector – care marchează obiectele care nu mai sunt folosite şi eliberează spaţiul ocupat de ele; eliberarea se face periodic sau atunci când spaţiul disponibil curent nu mai poate satisface o nouă cerere de alocare a memoriei; securitate ridicată – accesul la memorie este posibil numai prin verificarea în prealabil a drepturilor de acces. Lipsa pointerilor face ca accesarea unor zone de memorie pentru care accesul nu este autorizat să nu fie posibilă. Limbajul obligă programatorul să prevadă acţiunile ce trebuie intreprinse la diferitele erori (numite excepţii) posibile. De exemplu, chiar o simplă operaţie de citire trebuie însoţită de codul ce trebuie executat la detectarea unei excepţii; extensibilitatea – Java permite includerea de metode native, adică de funcţii scrise în alt limbaj (de obicei C++). Metodele native sunt legate dinamic la programul Java în momentul execuţiei, rolul lor fiind în principal de a mări viteza de execuţie pentru anumite secvenţe din program; claritatea – este obţinută şi prin eliminarea unor facilităţi neesenţiale din C++, conducând la programe mai uşor de înţeles; limbajul Java este proiectat pentru lucrul în reţea, putându-se construi programe care fac conexiuni între calculatoare server şi client şi care pot fi executate în medii Internet. De fapt, programele Java se împart în trei categorii:

programe obişnuite, de sine stătătoare (stand-alone), numite aplicaţii;

7

applet-uri, aplicaţii care se execută pe parte de client. Ele folosesc acelaşi limbaj, dar diferă modalitatea de lansare în execuţie, se execută în browsere WWW. Conexiunea browser-ului cu applet-urile se face prin intermediul etichetelor html. Când utilizatorul vizualizează o pagină Web ce include un applet, maşina la care este conectat transmite applet-ul maşinii gazdă, care este cea pe care se execută applet-ul (se presupune că maşina pe care lucrează utilizatorul are un emulator Java). Applet-urile pot îngloba elemente de grafică, animaţie, sunet, jocuri; servlet-uri, aplicaţii care se execută pe parte de server. Un tip special de aplicaţie executată pe server, care serveşte şi susţine cererile primite de la clienţii din reţea îl constituie servlet-ul. Java Servlet-urile reprezintă o alegere potrivită pentru a construi aplicaţii Web interactive, înlocuind, astfel, folosirea scripturilor CGI.

Pentru dezvoltarea programelor Java, firma Sun pune la dispoziţia programatorului Java Developers Kit (JDK). JDK conţine biblioteci de clase Java, necesare scrierii unui program şi un set de utilitare, necesare compilării, testării, execuţiei şi documentării unei aplicaţii Java. O clasă, un fişier bytecode cu extensia .class reprezintă unitatea fundamentală a unui program executabil Java. O bibliotecă de clase cuprinde pachete. Pachetele sunt colectii de clase inrudite d.p.d.v. logic. O astfel de bibliotecă se numeşte package. JDK-ul include câteva package-uri fundamentale. Package-urile Java incluse în JDK, formează principalul API – Application Programming Interface, numit şi Java Core. Principalele package-uri sunt: java.applet - conţine clasele necesare dezvoltării unui applet; java.awt - conţine clase utilizate în dezvoltarea interfeţelor grafice; java.lang - conţine clasele fundamentale fără de care un program Java nu poate exista. Utilizarea unei clase din oricare alt pachet decât java.lang într-un program Java se specifică în clar prin directiva: import numepachet.*; sau

import numepachet.numeclasă;

java.math - utilizat pentru lucrul cu numere mari; java.net - conţine clasele necesare programării în reţea; java.sql - utilizat pentru lucrul cu baze de date; java.txt - utilizat pentru lucrul cu texte; java.util - conţine clase pentru lucrul cu liste, vectori, dicţionare, informaţii legate de dată şi timp; java.util.zip - utilizat pentru aplicaţii ce presupun folosirea unor algoritmi de compresie şi decompresie; java.io - include clasele necesare lucrului cu stream-uri (comunicare cu device-uri Input/Output, comunicare cu consola, accesul la fişiere); java.beans - este legat de implementarea tehnologiei Java Beans, o tehnologie orientată pe crearea unor componente reutilizabile; Pe lângă package-urile din Java Core, JDK conţine o serie de utilitare necesare dezvoltării, testării, analizei şi documentării programelor Java. Dintre acestea fac parte:

8

javac – (Java LanguageCompiler) este compilatorul Java care transformă sursele text scrise în limbaj de programare Java, având extensia .java în cod executabil pe maşina virtuală Java (JVM), rezultând o serie de fişiere cu extensia .class, în funcţie de numărul de clase definite în fişierul sursă. Numele fişierului sursă cu extensia .java se transmite ca şi parametru la lansarea programului javac.

Exemplu: javac ProgUnu.java

java - (Java Interpretor) este interpretorul Java care execută programele Java, pornindu-se de fapt JVM. Programul emulează JVM convertind instrucţiunile JVM în instrucţiuni ale maşinii reale. Acest utilitar se foloseşte doar pentru programele Java stand-alone şi are drept parametru numele fişierului rezultat în urma compilării (fără extensia class).

Exemplu: java ProgUnu

jre - (Java Runtime Interpreter) este similar cu interpretorul java fiind o variantă simplificată a acestuia, cu opţiuni puţine. Programul jre este varianta utilizator, iar programul java este varianta programator. Acest utilitar se foloseşte doar pentru programele Java stand-alone şi are drept parametru numele fişierului rezultat în urma compilării (fără extensia class).

Exemplu: jre ProgUnu

jdb - (Java Language Debugger) este utilitarul folosit pentru depanarea programelor Java. javah - este utilitarul folosit pentru a permite programelor Java să comunice cu programele scrise în alte limbaje (de exemplu limbajul C). Cu javah se crează fişiere header C şi fişiere stub C necesare pentru a realiza această conexiune. javap - este programul care dezasamblează fişierele de tip .class Java şi tipăreşte rezultatul pe monitor. Numele fişierului cu extensia .class se transmite ca şi parametru la lansarea programului javap.

Exemplu: javap ProgUnu

javadoc - este programul ce generează un fişier în format html pe baza comentariilor din programul sursă Java, fişier ce reprezintă documentaţia programului. Acest utilitar se foloseşte doar pentru fişierele sursă Java, numele fişierului sursă cu extensia .java se transmite ca şi parametru la lansarea programului javadoc.

Exemplu: javadoc ProgUnu.java

appletviewer – este utilitarul folosit pentru testarea applet-urilor. Programul lansează în execuţie o maşină virtuală Java, fiind un browser minimal de WWW care suportă toate caracteristicile Java ale mediului jdk. Lansarea în execuţie a acestui utilitar, presupune transmiterea ca şi parametru a unui fişier html, care conţine eticheta de conectare cu clasa Java.

Exemplu: appletviewer AppletUnu.html

9

Dezvoltarea şi execuţia unei aplicaţii Java

Etapele de dezvoltare şi execuţie ale unei aplicaţii Java stand-alone sunt:

scrierea codului; compilarea; interpretarea şi lansarea în execuţie.

Editor text

Compilator Java (javac)

Interpretor Java (java)

Fişier executabil ProgUnu.class

Execuţie program în JVM

Fişier sursă ProgUnu.java

Editarea unei aplicaţii Java se realizează cu orice editor de texte, care salvează datele în format text. Fişierul sursă obligatoriu are extensia .java şi trebuie să conţină o declaraţie de clasă declarată public, care are nume identic cu numele fişierului Java. În orice aplicaţie Java, trebuie să existe metoda main, aceasta fiind prima metoda apelată de interpretor când se lansează în execuţie un program (un bytecode) Java. Metoda main este declarată public prin convenţie şi în mod obligatoriu static, pentru a putea fi executată fără a se construi o instanţă a clasei corespunzătoare. Exemplul 1: /* Prima aplicatie va afisa un mesaj */ class ProgUnu {

public static void main (String args[]) {

System.out.println(“Aceasta este prima aplicatie Java”); } } //Am incheiat programul Compilarea acestui program Java se realizează cu comanda: javac ProgUnu.java În urma compilării se obţine un fişier în cod binar cu numele ProgUnu.class. Execuţia programului se va realiza prin comanda: java ProgUnu Pe ecran va apare mesajul: Aceasta este prima aplicatie Java

10

Exemplul 2: /* Aplicatia preia parametrii din linia de comanda Se vor introduce mai multe nume ce vor fi afisate*/ class ProgDoi {

public static void main(String args[]) { if (args.length= =0){ System.out.println(“Lista parametrii vida!”); return; }

for (int i=0; i<args.length; i++)

System.out.println(“Salut”+args[i]+”!”);

} } // ... Am incheiat La execuţia programului prin linia de comandă:

java ProgDoi Ionescu Popescu Georgescu

se va afişa pe ecran: Salut Ionescu! Salut Popescu! Salut Georgescu!

Dezvoltarea şi execuţia unui applet Java

Un applet este un program Java care respectă o mulţime de convenţii ce îi permit să ruleze într-un browser WWW, compatibil Java. În vederea acestei execuţii în interiorul unui bowser, se crează un fişier html, care se conectează prin intermediul unui tag html de programul Java obţinut după compilare (de fişierul .class). Rezultă deci că la etapele de dezvoltare ale unei aplicaţii stand-alone, se adaugă scrierea fişierului html pentru a dezvolta şi executa un applet.

11

Editor text

Fişier html – conţine

eticheta de legatură cu

fişierul AppletUnu.class

Browser Web cu suport Java

(appletviewer, Netscape)

Fişier executabil JVM

Bytecodes Java

(AppletUnu.class)

Execuţie program în

JVM

Fişier sursă Java (AppletUnu.java)

Compilator Java (javac)

Exemplul următor arată modul de construire al unui applet. Exemplul 3: Pentru început vom edita un applet Java memorat în fişierul AppletUnu.java: import java.applet.*; import java.awt.*; /* Primul applet Java - programul va afisa un text in zona alocata applet-ului de browser */ public class AppletUnu extends Applet { public void paint(Graphics g) { g.setColor(Color.red); g.drawString(“Acesta este primul applet JAVA!”, 30, 30); g.setColor(Color.blue); g.drawLine(30,50,200,50); g.drawRect(80,80,100,100); } } //Sfarsit applet

12

După compilarea programului sursă AppletUnu.java şi deci crearea fişierului bytecode cu numele AppletUnu.class, se trece la editarea fişierului AppletUnu.html, fişier care se află în acelaşi director cu fişierul AppletUnu.class şi care conţine: <HTML> <TITLE> Pagina test </TITLE> <BODY> <P>Aici este applet-ul nostru <BR> <APPLET CODE=”AppletUnu.class” WIDTH=300 HEIGHT=200> </APPLET> </BODY> </HTML> Observaţie: Legătura cu programul Java se face prin intermediul tag-ului <applet>. Acesta trebuie să conţina obligatoriu următoarele atribute: code = “numeApplet.class” – atribut ce anunţă browser-ul că trebuie să pornească JVM

executând programul care se află în fişierul numeApplet.class din directorul în care se află fişierul html curent.

width, height – sunt atribute ce specifică dimensiunea applet-ului. Această dimensiune este dată în pixeli şi reprezintă dimensiunea zonei din interiorul paginii html pe care applet-ul o va ocupa.

Execuţia unui applet se va realiza prin comanda appletviewer AppletUnu.html

sau încărcând pagina html utilizând un browser WWW compatibil Java (Netscape, Internet Explorer). Rezultatul este:

13

Structura lexicală a unui program Java

Limbajul Java foloseşte ca şi alfabet setul de caractere Unicode pe 16 biti. Setul de caractere Unicode are 65536 caractere oferind suport pentru toate limbile scrise; el cuprinde şi setul de caractere ASCII (primele 128 caractere Unicode fiind caracterele ASCII). Un program sursă Java poate fi scris folosind setul de caractere ASCII şi caractere Unicode în notaţia \udddd, şirul dddd fiind în format hexa şi reprezentând un caracter în format Unicode. În faza de compilare, codul sursă al unui program Java este supus unei operaţii de translaţie lexicală parcurgându-se etapele:

1. şirul de caractere ASCII sau Unicode este translatat într-un flux de caractere Unicode; 2. fluxul obţinut la pasul precedent este tranformat într-un flux de caractere de intrare şi

terminatori de linie; 3. fluxul caracterelor de intrare şi a terminatorilor de linie de la pasul 2 este transformat în

unităţi lexicale Java, eliminându-se spaţiile şi comentariile. Limbajul Java conţine următoarele unităţi lexicale sau atomi lexicali (tokens): comentariile – sunt folosite pentru a documenta programul cuvintele cheie (keywords) – sunt cuvinte rezervate de limbajul Java în diferite scopuri identificatorii – sunt numele dat pe programator unor elemente de program, permiţând referirea unică a acelor elemente de program: clase, metode, variabile literalii – reprezintă valori constante ale unui tip de dată separatorii – sunt utilizaţi pentru a separa unităţile lexicale Java unele de altele. Aceştia sunt: ( ){ }[ ] ; , . operatorii – sunt necesari pentru a descrie operaţiile ce se aplică asupra unor variabile program Înainte de a detaila aceste unităţi lexicale, vom mai prezenta câteva noţiuni legate de gramatica unui program, ce vor fi utilizate: Variabila este entitatea de program caracterizată printr-o valoare, asupra ei se poate acţiona (prin operatori, metode) modificându-i valoarea. Variabilele au un nume unic într-un anumit domeniu (numit scope). Constanta este o entitate program care pastreaza aceeasi valoare, nefiind posibila modificarea ei. Expresia este o combinaţie de operatori şi metode aplicate asupra unor variabile de program, combinaţie ce poate fi evaluată la o singură valoare de un anume tip. Instrucţiunile reprezintă grupuri de unităţi lexicale Java grupate pentru a “spune” ce trebuie să facă programul. Instrucţiunile care nu depăşesc o linie de cod se termină cu ; Blocul de cod (Code Block) este o secvenţă de instrucţiuni şi declaraţii de variabile locale grupate într-o unitate distinctă, delimitat prin separatorii { şi }.

14

Comentarii

Java defineşte trei tipuri de comentarii: comentariul tradiţional, ca şi în limbajele C/C++, textul cuprins între caracterele /* şi */ ; comentariul de linie, ca şi în limbajele C/C++, textul de după caracterele // până la sfârşitul liniei; comentariul de documentare, textul dintre caracterele /** şi */, utilizat pentru documentarea programului folosind programul javadoc – care generează documentaţii în format html, informaţii legate de structura claselor dezvoltate de program.

Cuvinte cheie

Cuvintele cheie sunt secvenţe de caractere ASCII rezervate de limbaj avînd un sens special. O listă a principalelor cuvinte cheie este prezentată în continuare, urmând ca pe parcurs să fie introduse şi altele: abstract boolean break byte case catch class continue default do double else extends final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch syncrinized this throw try void while

Identificatorii

Un identificator este un şir de caractere şi reprezintă numele dat unei variabile, clase sau funcţii. Şirul începe cu o literă Java, este diferit de orice cuvânt cheie şi este diferit de null, false, true. Observaţie: Java deosebeşte literele mari de literele mici. Deşi nu există o regulă pentru atribuirea de nume identificatorilor, există anumite convenţii utilizate: identificatorii numelor de clasă încep cu majusculă şi fiecare cuvânt distinct din identificator

începând cu majusculă; Exemple: ProgUnu, AppletUnu, ClassStud. identificatorii de variabilă încep cu literă mică, iar fiecare cuvânt ce urmează începe cu

majusculă; Exemple: obiectStudent1, sir, x1, a. identificatorii unei funcţii respectă regula de la variabile; Exemple: deseneazaCerc(), calculeazaProdus().

15

identificatorii unei constante conţin doar majuscule, cuvintele fiind separate prin underscore: “_” ;

Exemple: VARSTA_MINIMA, VAL_MIN, VAL_MAX.

Literalii

Un literal este reprezentarea unei valori corespunzatoare unui tip de date elementare – byte, short, int, long, float, double, char, boolean, a tipului string sau a unui tip de date null. Un identificator de variabilă reprezintă un simbol sau o referinţă la o valoare, iar literarul reprezintă o valoare. În Java există următoarele tipuri de literali: întreg în virgulă flotantă boolean caracter şir de caractere null Literalul întreg corespunde tipurilor de date întregi. Există două tipuri: normal pentru byte, short, int şi lung pentru long. Literalii lungi se termină cu sufixul l sau L. Reprezentarea literarilor întregi se face pe 32 de biţi şi este reprezentarea cu semn în complement faţă de 2. Există trei modalităţi de scriere a literarilor întregi: zecimal – cifre de la 0 la 9, fără să înceapă cu 0; octal – conţine cifre de la 0 la 7, obligatoriu începând cu 0; hexa – conţine cifre de la 0 la 9 şi literele de la A la F, obligatoriu începe cu 0x. Exemple: 123 (zecimal) 12345L (long) 0xA69 (hexa) 0272 (octal) 0xAB23L (hexa long) 032l (octal long) byte x1=10; //literal byte short y=-150; //literal short int i=200; //literal int long f2=1234L; //literal long Un literal în virgulă flotantă reprezintă un număr real. El este compus din parte întreagă, punct zecimal, parte fracţională, un exponent şi un sufix de tip. Exponentul, dacă există, este indicat prin litera “e” sau “E” urmată de un semn. Un literal în virgulă flotantă este de tip float, dacă are sufixul “f” sau ”F” sau de tip double, dacă are sufixul “d” sau “D”. Un literal în virgulă flotantă fără sufix este de tip double. Exemple: 12.34f (float)

16

12.45d (double) 12E-3 (double cu exponent) 123e+4f (float cu exponent) Literalul boolean poate lua una din valorile true sau false. Exemple: boolean sw=true; gasit=false; Literalul caracter corespunde tipului de date char şi este un caracter Unicode încadrat între apostrofuri. Pentru caracterele Unicode care nu au reprezentare grafică se folosesc secvenţele escape. În Java secvenţele escape predefinite sunt: ‘\b’ caracterul backspace BS are reprezentarea Unicode \u0008 ‘\t’ caracterul tab HT are reprezentarea Unicode \u0009 ‘\n’ caracterul linefeed LF are reprezentarea Unicode \u000a ‘\f’ caracterul formfeed FF are reprezentarea Unicode \u000c ‘\r’ caracterul carriage return CR are reprezentarea Unicode \u000d ‘\”’ caracterul ghilimele are reprezentarea Unicode \u0022 ‘\’’ caracterul apostrof are reprezentarea Unicode \u0027 ‘\\’ caracterul backslash are reprezentarea Unicode \u005c Exemple: ‘a’ ‘\t‘ ‘,’ char c=’x’; Literalul şir de caractere (String) este o secvenţă de zero sau mai multe caractere încadrată între ghilimele, fiecare caracter putând fi reprezentat printr-o secvenţă escape. Un literal şir de caractere este de tip String. El poate fi scris pe mai multe rânduri punând semnul “+” între subşiruri. Exemple: String sir1=”primul sir de caractere \n”; String sir2=”acest sir se continua \t”+

“pe randul al doilea”;

Literalul null corespunde unei referinţe nule.

Separatori

Un separator este un caracter care indică sfârşitul unei unităţi lexicale şi începutul alteia. În Java separatorii sunt: ( ) { } [ ] ; , .

17

Operatori

Un operator este un simbol grafic utilizat în operaţiile elementare definite în Java. Lista operatorilor limbajului Java este: =, <, >, !, ~, ? :, = =, <=, >=, !=, &&, | |, ++, --, +, -, *, /, &, | , ^, %, <<, >>, >>>, +=, -=, *=, /=, &=, |=, ^=, %=, <<=, >>=, >>>=, null, instanceof Modul de utilizare şi efectul operatorilor îl vom prezenta o dată cu expresiile.

Tipuri de date

Un tip de dată constă în definirea mulţimii valorilor pe care le poate lua o variabilă şi în definirea operaţiilor suportate de aceasta. În Java există următoarele tipuri de date:

tipuri de date primitive, unde sunt incluse tipurile numerice şi tipul boolean (byte, short, int, long, char, float, double, boolean) tipuri de date referinţă, care includ tipurile clasă, interfaţă şi tablou. tipul null, un tip special, referinţa null fiind o valoare posibilă pentru o expresie de tip null. Tipul clasă este un tip de date generic format din mai multe date de diferite tipuri şi din metode care se pot asocia variabilelor de acest tip. Clasa este entitatea de bază a unui limbaj obiectural. Conceptul de clasă permite crearea propriilor structuri de date, în funcţie de cerinţele programului şi permite asocierea unor funcţii la aceste structuri de date. Datele dintr-o clasă sunt caracterizate printr-un identificator (un nume) şi un tip (ce poate fi oricare tip cunoscut, inclusiv o clasă) şi poartă denumirea de atribute (field). Funcţiile unei clase caracterizate prin identificatori (nume) şi parametrii funcţiei poartă numele de metode (method) ale unei clase. Dacă atributele sunt caracteristici de stare ale clasei, metodele conferă funcţionalitate unei clase. În interiorul claselor pot exista o serie de funcţii speciale având acelaşi nume cu numele clasei numite constructori. Scopul constructorilor este de iniţializare a atributelor. Pentru a putea utiliza o clasă, aceasta trebuie declarată sub forma:

class numeClasa {

//lista declaraţii atribute;

//lista declaraţii constructori;

//lista declaraţii metode;

}

18

Declaraţia unui atribut se face sub forma: {[modificator]…} tip_Atribut{numeAtribut[=expresieInit]…}; unde:

modificator specifică proprietăti de atribuire; tip_Atribut reprezintă tipul de dată şi poate fi şi un nume de clasă; numeAtribut reprezintă identificatorul atributului; expresieInit reprezintă o expresie de iniţializare a atributului.

Exemple: int v1; char c=’a’; public long v3=123L; Declaraţia unei metode se face sub forma: {[modificator]} tip_return numeMetoda([lista_Param]){

//corp metoda } unde:

modificator specifică proprietăţi ale funcţiei; tip_return reprezintă tipul de dată returnat de metodă (dacă metoda nu returnează nici o

valoare, atunci tipul este void); nume_Metoda este identificatorul metodei; lista_Param este o listă de parametrii ai funcţiei daţi prin tip şi identificator parametru

separaţi prin virgulă; corp metoda este o secvenţă de instrucţiuni care se execută la apelul metodei.

Exemple: public int sumaNr(int x, int y) {

return (x+y);

} public void exVid () { …. } Declaraţia unui constructor este următoarea: {[modificator]} numeClasa ([lista_Param]) {

//corp constructor

} Un constructor trebuie să aibă numele clasei şi să nu returneze nici o valoare. Un constructor nu este o metodă, el nu se poate apela decât în momentul instanţierii unui obiect, utilizând new. Exemplu: class Persoana {

19

public Persoana () {

//… }

public Persoana (String s) {

//… } } O variabilă de tip clasă se numeşte obiect sau instanţă a clasei. Un program lucrează cu obiecte, cu instanţe de clase. Clasa doar caracterizează aceste obiecte. Pentru a lucra cu un obiect este nevoie de parcurgerea următoarelor etape: declararea obiectului; instanţierea obiectului; iniţializarea. Un obiect se declară la fel ca orice variabilă de tip primitiv: {[modificator]…} nume_clasa identificatorObiect [=expresieInit]; Exemplu: public Point p1, p2=new Point(5,5); Rectangle rect1; Instanţierea şi iniţializarea unui obiect se fac simultan prin operatorul new, urmat de numele clasei şi parametrii constructorului în paranteze. Exemplu: p1=new Point(); p2=new Point(5,20); rect1=new Rectangle (p1,25,50); O dată un obiect creat (instanţiat) el poate fi utilizat accesându-se membrii lui publici (care sunt specificaţi prin modificatorul public), fie membrii metodei, fie membrii atribut. Accesul la un atribut public se face prin

identificatorObiect.identificatorAtribut iar accesul la o metodă publică prin: identificatorObiect.identificatorMethod(par1,par2,…) O variabilă reprezintă un nume ce referenţiază o valoare, o locaţie în care este stocat un anumit tip de dată. Data din acea locaţie se poate modifica pe parcursul execuţiei programului. Referinţa la ea se face prin intemediul unui identificator, al unui nume de variabilă sau a unei variabile. În cazul tipurilor de date primitive, identificatorul reprezintă chiar valoarea din locaţia de memorie în care a fost stocată. În cazul în care avem un tip de dată referinţă, identificatorul specifică adresa memoriei în care se află data respectivă. Înainte de a utiliza o anumită variabilă, aceasta trebuie declarată. O declarare a unei variabile trebuie să specifice tipul variabilei şi un identificator al variabilei (numele variabilei) şi să se termine cu un separator “;”. Pe lângă aceste două elemente obligatorii, declaraţia unei variabile poate conţine o listă de modificatori variabilă şi o initializare a ei la o anumită valoare.

20

Modificatorul reprezintă un cuvânt cheie care specifică anumite proprietăţi ale variabilei (public, final, static) Structura unei declaraţii este: {[modificator]…} tip_data {identificator[=val_initiala],…}; Exemple: int var1; int var2=0; byte var3, var4=128; public int id5; static final id6=23; long id7=0x23FFL; Variabile pot fi: variabile atribut - ele exprimă atributele unei clase variabile locale – sunt variabilele declarate într-un bloc de cod variabile parametru de metodă – apar în lista parametrilor din declaraţia unei metode Domeniu de vizibilitate al unei variabile (scope) este domeniul în care variabila poate fi accesată. Astfel, o variabilă de tip atribut are domeniul de vizibilitate întreaga clasă, o variabilă locală are domeniul de vizibilitate în blocul unde a fost declarată, iar o variabilă parametru de metodă are domeniul de vizibilitate în interiorul metodei. Maşina virtuală Java (JVM) iniţializează în mod implicit variabilele atribut de tip numeric cu 0, pe cele de tip boolean cu valoarea false şi pe cele de tip referinţă cu null. Variabilele locale nu sunt iniţializate implicit de maşina JVM, deci ele trebuie iniţializate explicit de programator. Exemplu: Class TestInit {

int atr; public void method () { int loc; System.out.println(atr); //se afiseaza 0

System.out.println(loc); //eroare de compilare //datorita neinitializarii variabilei loc } }

21

Operatori in Java

1. Operatorul de atribuire (=) permite atribuirea valorii operandului din dreapta operandului

din stânga. Forma generală a unei operaţii de atribuire este: variabila=expresie;

Exemple: int x,y; x=10; y=x*2; //atribuire inlantuita int a,b,c; a=b=c=5; //aceiasi cu c=5;b=c;a=b; 2. Operatorii aritmetici sunt de două tipuri: operatori binari: adunare (+), scădere (-), înmulţire (*), împărţire (/), restul împărţirii modulo (%) şi operatori unari: semnul minus (-), semnul plus (+), decrementare (--), incrementare (++) Observaţie. Operatorii de incrementare (++) şi decrementare (--) pot fi utilizaţi înainte de operand (prefix) sau după operand (sufix). În cazul utilizării prefixate prima dată se face operaţia (incrementare sau decrementare), după care se va returna valoarea obţinută, iar în cazul utilizării postfixate, se returnează la început valoarea operandului, după care se face operaţia. 3. Operatorii relaţionali sunt = =, !=, >, >=, <, <= (ultimii patru pot apărea pentru date

primitive şi numerice, în afară de tipul boolean). Primii doi, semnul egal şi diferit, se pot aplica oricărui tip de date, fie el primitiv, fie referinţă cu condiţia ca cei doi operanzi să fie compatibili (pentru ca operanzii de tip referinţă să fie egali, trebuie ca datele ce le conţin să fie aceleasi şi ei să referenţieze aceeaşi adresă). Rezultatul unei expresii ce implică un operator relaţional este de tip boolean, true sau false.

4. Operatorii logici sunt condiţionali AND (&&), OR (||) - nu necesită evaluarea celui de-al doilea operand dacă primul operand determină valoarea finală a expresiei; booleeni: NOT (!), AND pe biţi (&), OR pe biţi ( | ), XOR pe biţi (^) (sau exclusiv ia valoarea true dacă operanzii nu au aceeaşi valoare) - fac evaluarea tuturor operanzilor. Operatorii logici se pot aplica numai operanzilor de tip boolean, dar pot fi şi expresii al căror rezultat este de tip boolean.

22

5. Operatorii la nivel de bit sunt & (şi) - | (sau) - ^ (sau exclusiv) ~ (complementare) << (deplasare stânga cu semn) >> (deplasare dreapta cu semn) >>>(deplasare dreapta fără semn) Operanzii în acest caz nu pot fi decât de tip primitiv întregi (byte, short, char, int, long) 6. Operatorii de atribuire combinaţi

Operatorul de atribuire (=) poate fi combinat cu operatori de tip aritmetic şi operatori la nivel de bit, obţinându-se prescurtări de scriere a codului. De exemplu:

a=a+b; a+=b; a=a&b; a&=b; a=a<<b; a<<=b;

7. Operatorul condiţional (? :) este un operator ternar care pe baza valorii obţinute ca rezultat

al unei evaluări a unei expresii, alege una din alte două expresii.

boolean_exp ? value0:value1;

Dacă boolean_exp are valoarea true atunci value0 este valoarea returnată de operaţie; invers, dacă boolean_exp este false, atunci value1 este valoarea returnată.

Exemplu:

int x; boolean cond=true; x=cond?1:2; //x ia valoarea 1 cond=false; x=cond?1:2; //x ia valoarea 2

8. Operatorul de adunare şir caractere este utilizat în cazul clasei String din pachetul

java.lang. Operaţia: sir_caractere+var_tipT sau var_tipT+sir_caracter,

returnează un şir de caractere (String) oricare ar fi tipul tipT. În cazul în care var_tipT este un obiect, se utilizează metoda toString a clasei Object pentru a forma şirul final.

Exemplu:

String sir=”Afisez”, rez; int a=2; float b=1.25f; boolean c=true; rez=sir+a; //”Afisez 2” rez=sir+b; //”Afisez 1.25” rez=sir+c; //”Afisez true”

23

9. Operatorul cast este utilizat pentru a converti o valoare dintr-un tip de date numeric într-o altă valoare similară, însă de alt tip de date numeric. (tipNumericDorit) operand AltTipNumeric

Observaţie. Dacă se doreşte conversia unui tip de date într-un alt tip de date de precizie mai mare utilizarea operatorului cast nu este obligatorie, conversia făcându-se implicit. Invers, este obligatorie utilizarea operatorului cast. In\din Byte Short Char Int Long Float Double Byte - Byte Byte Byte Byte Byte Byte Short Implicit - Short Short Short Short Short Char Char Char - Char Char Char Char Int Implicit Implicit Implicit - Int Int Int Long Implicit Implicit Implicit Implicit - Long Long Float Implicit Implicit Implicit Implicit Implicit - Float Double Imiplicit Implicit Implicit Implicit Implicit Implicit -

Observaţie. Tipul boolean nu poate fi convertit în nici un alt tip şi nici alt tip în tipul boolean. 10. Operatorul instanceof este utilizat pentru a testa dacă un anumit obiect este de o anumită

clasă. object instanceof className

returnează true sau false. 11. Operatorul promotion Promotion este procedura prin care un operand de tip numeric al unui operator este convertit implicit la un alt tip numeric înainte de execuţia operaţiei. Sunt două tipuri de promotion:

1. unary promotion – implică conversia operanzilor de tip byte, short, char în tipul int în operaţii unare(+,-), operaţii de complementare (~), operaţii de shiftare (>>, <<, >>>);

2. bynary promotion – implică conversia unor operanzi în cazul aplicării unor operatori binari. Conversia se face astfel:

dacă un operand este double, celălalt va fi converit în double înainte de execuţie; dacă nu avem operand double, iar unul dintre operanzi este float, atunci celălalt va fi

float; dacă nu avem operanzi double, float, iar unul dintre operanzi este long, celălalt este

convertit în long; dacă nu avem operanzi double, float, long, atunci se face conversia la int.

Bynary promotion se utilizează în operaţiile aritmetice binare: +, -, *, /, %; operaţiile relaţionale aplicate asupra operanzilor numerici (= =, !=, >, >=, <, <=) operaţiile la nivel de bit (&, |, ^) Exemplu: byte x=2, y=3, z; // x=-y; // eroare de compilare. Corect: x=(byte)-y; // x=~y; // eroare de compilare. Corect:

24

x=(byte)~y; // z=x+y; // eroare de compilare. Corect: z=(byte)(x+y); // z=x&y; // eroare de compilare. Corect: z=(byte)(x&y);

Structuri de control program. Instrucţiuni

Execuţia unui program Java este controlată de structuri de control sau instrucţiuni. Instrucţiunile sunt cele ce ne ajută să descriem succesiunea operaţiilor ce urmează a fi executate de program. Fiecare instrucţiune are un mod normal de execuţie în care sunt parcurşi anumiţi paşi. Dacă toţi paşii sunt parcurşi fără vreun incident, spunem că instrucţiunea s-a terminat normal. Cauzele posibile ale terminării anormale ale unei instrucţiuni sunt: instrucţiunile break, continue şi return, care pot determina transferul controlului programului

prin terminarea anormală a instrucţiunii care le conţine; evaluarea anumitor expresii Java sau instrucţiunile throw pot arunca excepţii ale maşinii

virtuale Java şi pot conduce la transferul controlului programului prin terminarea anormală a instrucţiunii care o conţine.

Instrucţiunile Java sunt asemănătoare cu instrucţiunile din limbajul C/C++. Acestea sunt: if-else, switch, for, while, do, break, continue, return. În plus mai există instrucţiuni pentru tratarea excepţiilor: try-catch-finally şi throw. Observaţii: expresiile condiţionale din instrucţiunile if-else, for, while, do trebuie să fie strict de tipul

boolean (în Java nu se poate face conversia din int în boolean), aceste expresii în C puteau fi de tip int;

instrucţiunea goto din C lipseşte, fiind înlocuită cu instrucţiunile break şi continue care pot primi o etichetă de salt.

O secvenţă de instrucţiuni cuprinsă între acolade poartă numele de bloc (de instrucţiuni). Exemplu: { lista declaraţii; //int i; int j=4; lista instrucţiuni; //i=i+j; } Observaţie. { } oferă un domeniu de vizibilitate variabilelor (scope). Identificatorii definiţi în acest domeniu (variabile locale) sunt vizibili doar în acest domeniu şi în subdomeniile lui (în instrucţiuni ce intră în cadrul acestor intrucţiuni compuse). Din momentul în care se iasă din domeniu, identificatorii îşi pierd sensul şi nu mai pot fi folosiţi. Exemplu: {

int x=1; int y=2;

25

{ int z; int x=10; // eroare la compilare z=x+y;

} y=z; // eroare la compilare , z a ieşit din domeniu

} Instrucţiunea expresie determină atribuirea rezultatului evaluării unei expresii unei variabile; ea se termină cu ; . În categoria instrucţiunilor expresie intră operaţiile de atribuire, apelul metodelor şi instrucţiunea vidă.

Instrucţiuni condiţionale

Instrucţiunile if-else şi switch oferă posibilitatea execuţiei selective a unor secvenţe de cod în funcţie de valoarea unei expresii. if (expresie_conditionala)

secventa1; else secventa2; Această instrucţiune determină evaluarea expresiei condiţionale şi dacă expresie_conditionala este true, se execută secventa1, iar dacă este false, se execută secventa2; Observaţii: expresie_conditionala trebuie să fie evaluată la o valoare booleană folosirea lui else nu este obligatorie dacă se doreşte testarea mai multor condiţii, avem varianta:

if (expresie_conditionala1) secventa_if1;

else if(expresie_conditionala2) secventa_if2;

… else if(expresie_conditionalan) secventa_ifn;

else secventa_else;

Exemplu: /* programul determina maximul dintre trei numere a,b,c si modulul unui numar x */ import java.util.*; class numere

{public static void main(String args[]) {

System.out.println(“Se determina max “); int a,b,c,max; Random r=new Random(); a=r.nextInt();

26

System.out.println(a); b=r.nextInt(); System.out.println(b); c=r.nextInt(); System.out.println(c); max=a; if (max<b) max=b; if (max<c) max=c; System.out.println(“maximul este =”+max); int x; x=r.nextInt(); System.out.println(“x =”+x); if (x>0) System.out.println(“val abs este =”+x); else if (x= =0) System.out.println(“val este 0”); else System.out.println(“val abs este =”+(-x)); } }

Instrucţiunea switch permite executarea unei secvenţe de cod dintr-o succesiune de mai multe secvenţe în funcţie de valoarea unei expresii; ea înlocuieşte instrucţiunea if_else în cascadă dacă este vorba de o singură condiţie. switch (expresie_conditie) {

case val1: secventa1; <break;> case val2: secventa2; <break;>

… case valn: secventan; <break;>

<default:> secventa_default;

} Când se execută o instrucţiune switch, se evaluează la început valoarea expresiei expresie_conditie; apoi se compară valoarea evaluată cu prima valoare a lui case, val1. Dacă această valoare este egală cu val1, se trece la execuţia secvenţei secventa1 până la întâlnirea lui break. Dacă instrucţiunea break nu este prezentă, se trece la execuţia secvenţei secventa2, s.a.m.d. În cazul în care valoarea din condiţie nu este egală cu val1, se compară cu val2. Dacă sunt egale, se trece la execuţia secvenţei secventa2 până la apariţia instrucţiunii break. Procesul se repetă până la valn. Dacă nici una din cele n valori nu a fost egală cu expresia, se execută secvenţa secventa_default, ce urmează lui default. Dacă în unul din segmentele case instrucţiunea break lipseşte, o dată intrat în acel bloc se execută instrucţiunile din următoarele blocuri case (fără a mai testa valorile vali) până la întâlnirea instrucţiunii break. Cazul default permite intrarea în execuţia unei secvenţe indiferent de valoarea condiţiei. Acest caz poate lipsi. Pentru utilizarea acestei instrucţiuni este obligatoriu ca tipul expresie_conditie şi tipul valorilor val1, …, valn să fie: byte, char, short, int. Exemplu: /*

27

Programul exemplifica utilizarea instructiunii switch calculând suma, produsul, diferenţa şi câtul a două numere întregi */

import java.util.*; class Switch

{ public static void main(String args[]) { char oper=args[0].charAt(0); System.out.println(“Executa operatia”+oper); int a,b; Random r=new Random(); a=r.nextInt()%100; System.out.println(a); b=r.nextInt()%100; System.out.println(b); double rez=0;

switch(oper){ case ‘+’: rez=a+b;

break; case ‘*’: rez=a*b; break; case ‘-‘: rez=a-b; break; case ‘/’: if (b= =0) System.out.println(“Impartire ilegala”); else rez=a/b; break; default: System.out.println(“Eroare”); } System.out.println(“rezultatul este =”+rez); } }

Instrucţiuni repetitive

Instrucţiunile repetitive se împart în instrucţiuni repetitive cu test iniţial while, for şi instrucţiuni repetitive cu test final do. Instrucţiunea while este utilizată pentru execuţia repetată a unei instrucţiuni sau a unei secvenţe de instrucţiuni şi are sintaxa:

while (expresie_conditionala) secventa_repetata; unde expresie_conditionala trebuie să aibă tipul boolean. Execuţia instrucţiunii while începe cu evaluarea expresiei expresie_conditie. Dacă această expresie este true, se execută secvenţa din interiorul buclei while; dacă este false se termină execuţia buclei while.

28

Dacă expresie_conditie este evaluată false de la început, atunci instrucţiunea while nu se execută. O instrucţiune while se poate executa de un număr finit de ori (dacă expresie_conditie este evaluată false după un număr finit de paşi sau dacă există un break în secventa_repetata) sau de o infinitate de ori (dacă secventa_repetata nu determină evaluarea expresiei expresie_conditionala la false sau nu există un break în secventa_repetata). Exemplu: /* programul afiseaza numerele din intervalul [a,b] cu pasul h */ import java.util.*; class While {public static void main(String args[]) { System.out.println(“Se afiseaza numerele din intervalul”);

int a,b; double x,h=0.5; Random r=new Random(); a=r.nextInt()%20; b=r.nextInt()%20; while (a>b){

a=r.nextInt()%20; b=r.nextInt()%20;

} System.out.print(“a=”+a); System.out.println(“ b=”+b); x=(float)a; while (x<=b){

System.out.println(x); x=x+h; } } }

Instructiunea for este o instrucţiune repetitivă, care se foloseşte când se cunoaşte numărul de iteraţii ce vor fi executate şi are sintaxa: for(<secventa_initializare>;<expresie_conditie>; <secventa_incrementare>)

<secventa_repetata;>

În instrucţiunea for toate cele trei expresii sunt opţionale. Dacă există toate trei, execuţia acestei instrucţiuni începe cu secventa_initializare; apoi se testează expresie_conditie. Dacă valoarea este true, se execută secventa_repetata după care se execută secventa_incrementare. Procedura se repetă atâta timp cât expresie_conditie returnează valoarea true.

29

În instrucţiunea for pot exista mai mutle iniţializări, expresii de declarare a variabilelor locale şi multiple incrementări, separându-le prin virgulă. Variabilele din secventa_initializare sunt disponibile doar în interiorul blocului for. O secvenţă echivalentă cu instrucţiunea for este următoarea: <secventa_initializare> while (<expresie_conditie>){

<secventa_repetata>; <secventa_incrementare>;

} Exemplu: //progranmul calculeaza suma (-1)^i*1/i, i=1,n afisand la fiecare pas termenul calculat import java.util.*; class For { public static void main(String args[]) {

System.out.println(“Se determina suma “); int n=10; float t,suma=0; for(int i=1;i<=n;i++){

if (i%2==0) t=(float)1/i; else t=-(float)1/i; System.out.print(i); suma=suma+t; System.out.println(“ “+t);

} System.out.println(“suma=”+suma);

} } Instrucţiunea do este o instrucţiune repetitivă cu test final şi se execută cel puţin o dată. Sintaxa este:

do {

secventa_repetata;

} while (expresie_conditie)

Dacă expresie_conditie este true, se reia procesul de execuţie pentru secventa_repetata, iar dacă expresie_conditie este false, se termină execuţia instrucţiunii do. Tipul lui expresie_conditie trebuie să fie boolean, altfel se obţine eroare la compilare. Exemplu: //programul afiseaza numere mai mici decat 10, pana la generarea numarului 1 import java.util.*; class Do { public static void main(String args[])

30

31

{ int i=0; do

{ if(i= =1) break; Random r=new Random(); i=r.nextInt()%10; System.out.println(“i= “+i); }while (true);

} }

Instrucţiuni de salt

Instrucţiunile de salt permit întreruperea necondiţionată a unei secvenţe şi continuarea programului dintr-un alt punct. Instrucţiunile de salt sunt break, continue şi return. Instrucţiunea break este o instrucţiune de transfer de control necondiţionat şi are sintaxa:

break <eticheta>;

<eticheta> este un parametru opţional. O instrucţiune break fără etichetă va determina un salt în afara instrucţiunii de ciclare sau a instrucţiunii switch în care apare. Dacă apare şi eticheta, se va face un salt în afara instrucţiunii etichetate (obligatoriu instrucţiunea etichetată trebuie să cuprindă instrucţiunea break). Instrucţiunea continue este tot o instrucţiune de salt, de întrerupere, ea poate fi folosită doar în interiorul instrucţiunilor de ciclare (while, do, for) forţând trecerea la un nou ciclu. Are sintaxa:

continue <eticheta>;

Instrucţiunea continue fără etichetă va marca sfârşitul ciclului instrucţiunii în interiorul căruia se află, ducând la terminarea imediată a iteraţiei curente şi trecerea la una nouă. Utilizarea etichetei în instrucţiunea continue forţează sfârşitul unui ciclu al instrucţiunii de ciclare etichetate (care poate cuprinde o altă instrucţiune de ciclare care să conţina instrucţiunea continue) Folosirea instrucţiunii continue în afara instrucţiunilor repetitive generează eroare la compilare. Instructiunea return forţează ieşirea dintr-o metodă, având sintaxa:

return <expresie>;

În cazul în care o metodă se defineste ca returnâd o variabilă de tip T, atunci metoda în mod obligatoriu va conţine o instrucţiune return, în care expresia returnată trebuie să fie evaluată la un tip de date T. În cazul în care metoda se defineşte ca fiind void, instrucţiunea return poate lipsi. Totuşi, şi în acest caz, return se poate utiliza pentru o ieşire forţată din metodă.

Instrucţiuni pentru tratarea excepţiilor

Instrucţiunile pentru tratarea excepţiilor sunt try-catch-finally, respectiv throw şi vor fi tratate în capitolul ”Excepţii”.