|
|
|||
|
|
10/10/2010 |
|
|
|
|
|
|
In aceasta lucrare de laborator vor fi acoperite
urmatoarele probleme:
- Dezvoltarea unui program Java.
- Conventii
ale limbajului Java
- Analiza, conceperea si
modificarea programelor Java
- Analiza unui program. Adaugarea interactivitatii. Utilizarea tablourilor
- Studiu de caz: calculul unui polinom. Delegarea functionala.
- Anexa. Instalarea kitului
Java. Generarea automata a documentatiei. Accesul la consola standard de
intrare. Delegarea functionala.
Java este un limbaj de programare orientat pe
obiecte, proiectat in special pentru a fi portabil pe platforme si sisteme de
operare diferite. Este important sa amintim pentru inceput cateva din
caracteristicile si avantajele limbajului de programare Java:
- este
un limbaj simplu – au fost eliminate
o serie de aspecte ce producea uneori dificultati in programare si constituiau
surse de erori in limbaje precum Pascal, C sau C++:
-
sirurile de caractere nu mai sunt considerate tablouri ci devin obiecte ale
clasei String;
-
se elimina lucrul cu pointerii – ca urmare memoria calculatorului nu mai poate
fi alterata;
-
s-a renuntat la operatiile de supraincarcare a operatorilor;
-
s-a eliminat mostenirea multipla in lucrul cu clasele;
- memoria alocata si neutilizata
este “curatata” automat (programatorul nu mai are grija sa elibereze memoria
neutilizata);
-
datele de tip boolean nu se mai pot confunda cu datele intregi;
-
asigura securitate sporita:
- codul este verificat dinamic (atat
la compilare cat si in timpul executiei) de secvente care pot afecta
integritatea sistemului;
- exista reguli stricte pentru
aplicatiile (appleturi) care ruleaza pe calculatoare distante – nu se pot scrie
sau citi fisiere locale de pe discul calculatorului, acestea fiind “oarbe” in
raport cu configuratia memoriei calculatorului;
- este
neutru fata de sistemul de operare si de arhitectura (portabil);
-
permite programarea concurenta – lucrul cu mai multe fire de executie;
- limbajul Java este compilat si interpretat
– codurile sursa sunt compilate (translatate) de la limbajul de programare Java
la coduri executabile de procesorul software Java (JVM = Java Virtual Machine),
numite coduri de octeti (bytecodes), care sunt apoi interpretate si
transformate in coduri executabile sistemului de operare.
Conceperea (proiectarea) programului inseamna cel putin scrierea pe hartie a codului sau a unui
pseudocod (schita a programului scrisa in limbaj natural), dar poate include si
aplicarea unor instrumente (diagrame, limbaje de modelare cum ar fi UML) si
metodologii mai complicate.
O cale de a incepe conceperea programelor simple
este de a crea un asa numit pseudocod, adica o descriere intr-un limbaj apropiat de cel
natural a ceea ce trebuie sa
faca programul. De exemplu:
|
clasa care ilustreaza elementele esentiale ale unui
program Java, contine: metoda principala (punctul de intrare in program), care: afiseaza pe ecran textul “Buna ziua” |
Urmatorul pas poate fi transformarea pseudocodului
in comentarii.
1 2 3 4 5 6 7 8 9 10 11 |
/** Clasa care
ilustreaza elementele esentiale ale unui program Java. * Trebuie sa fie publica pentru ca are metoda
principala. */ /** Metoda
principala (punct de intrare in program). * Este prima metoda executata de JVM (Java
Virtual Machine). * Primeste ca parametri argumentele din lina
de comanda. * Nu returneaza nici o valoare. Trebuie sa
fie ‘public static’ */ // Corpul
metodei afiseaza textul "Buna ziua" pe ecran |
In continuare, se pot utiliza pasi succesivi in care se adauga codul Java, pornind de la nivelul cel mai inalt (urmand o strategie top-down – de la nivel inalt la nivel jos – prin detaliere):
- declaratia
clasei:
|
public class Salut { |
- declaratia metodelor (in cazul nostru metoda main()) si a
atributelor (nu este cazul):
|
public
static void main(String[] args) { // Corpul metodei afiseaza
textul "Buna ziua" pe ecran } |
- declaratia corpurilor metodelor (in cazul nostru pentru metoda main()):
|
System.out.println("Buna ziua"); // Afisarea unui text pe ecran |
In final codul complet va fi urmatorul:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
/** Clasa care ilustreaza elementele esentiale ale unui
program Java. * Trebuie sa fie
publica pentru ca are metoda principala. */ public class Salut { /** Metoda
principala (punct de intrare in program). * Este prima metoda executata de JVM (Java
Virtual Machine). * Primeste ca parametri argumentele din lina
de comanda. * Nu returneaza nici o valoare. Trebuie sa fie ‘public static’ */ public
static void main(String[] args) { System.out.println("Buna
ziua"); // Afisarea unui text pe
ecran } } |
Daca inlaturam comentariile, codul ramas este
urmatorul:
1 2 3 4 5 |
public class Salut { public static void main(String[] args) { System.out.println("Buna ziua"); } } |
In laborator: 1. Se deschide editorul Notepad si se editeaza cele
5 linii de cod ale clasei Salut; 2. Se
salveaza codul sursa al clasei Salut intr-un fisier cu numele Salut.java intr-un director cu
formatul LPAIanulcurent\GrupaSiSubgrupa (de exemplu: LPAI2010\441Fa). |
Atentie! La salvarea fisierelor cu extensia .java in Notepad trebuie
avut grija sa se selecteze "All files" in loc de "*.txt
", altfel fisierul va avea extensia .java.txt. |
Se va compila programul Salut.java accesand linia de comanda (Command Prompt
– Cmd) din Windows. Se va modifica directorul curent astfel incat sa corespunda
cu directorul in care se afla fisierul Salut.java . Compilarea programului se va face cu comanda:
directorcurent> javac Salut.java |
In urma acestei comenzi, compilatorul Java va
genera codul de octeti (bytecodes)
corespunzator intr-un fisier cu numele Salut.class, in directorul in care se afla si fisierul Salut.java.
Pentru executia programului, acesta trebuie lansat
in interpretorul Java, folosind comanda:
directorcurent> java Salut |
Rezultatul va consta in aparitia mesajului Buna ziua! pe ecranul monitorului.
Se va explica in continuare codul programului Salut.java linie cu
linie. Aplicatia Salut.java contine trei mari componente: comentariile codului
sursa, definitia clasei Salut si metoda principala main().
Intr-un program comentariile sunt ignorate de
catre compilator, dar ele sunt introduse totusi, cu rolul de a ajuta
programatorul. Limbajul de programare Java suporta trei tipuri de comentarii pe
care le trateaza diferit:
/* text */ - Compilatorul ignora tot incepand cu /* pana la intalnirea */ (exista
si in C, C++)
//
text - Compilatorul ignora tot incepand cu // pana la sfarsitul liniei (exista si in C++)
/**
documentation */
-
Reprezinta un comentariu de documentatie. Compilatorul ignora si aceste tipuri
de comentarii, dar ele sunt totusi utilizate de catre unealta javadoc pentru generarea automata a
documentatiei aplicatiei.
In laborator: 1. Se copiaza varianta
cu comentarii a programului Salut.java in fisierul Salut.java; 2. Se genereaza
documentatia acestui program utilizand comanda: |
directorcurent> javadoc Salut.java |
Info! Pentru informatii suplimentare privind
generarea automata a documentatiilor se va analiza Anexa. |
Definirea claselor se face cu ajutorul cuvantului cheie
class, urmat de numele clasei, iar
codul clasei este cuprins intre acolade { }; O clasa
poate fi privita ca o extensie a conceptului de tip de date si contine o
colectie de date si metode (functii membru) care descriu un obiect cu care programul lucreaza.
Obiectul reprezinta o instantiere (o instanta) a
clasei. In acelasi program se pot folosi mai multe obiecte apartinand aceleeasi
clase, sau unor clase diferite. Fiecare obiect se caracterizeaza prin stare
si comportament. Starea obiectului depinde de datele pe care
acesta le contine, in timp ce comportamentul este dat de metodele clasei
respective.
Cuvantul cheie public evidentiaza faptul
ca acea clasa poate fi folosita de orice obiect; Daca s-ar fi omis acest
identificator, atunci implicit clasa ar fi fost definita private, si ar fi
putut fi vizibila doar de anumite clase specificate.
In limbajul de programare Java, orice aplicatie
trebuie sa contina o metoda main(), care are urmatoarea
sintaxa: public static void main(String[] args){ ... }. Cuvintele cheie public si static pot fi scrise in orice ordine, dar conventia este sa se
utilizeze public static, ca si in exemplul nostru. Cuvantul cheie public
evidentiaza nivelul de acces. O functie declarata public poate fi vizibila
(accesata) in metodele oricarei alte clase. O metoda statica a unei clase poate fi privita ca un
fel de funcţie globala şi se poate folosi fără să fie necesară crearea unei
instanţe a clasei (obiect). Cuvantul cheie void
evidentiaza faptul ca functia nu returneaza nici o valoare.
Metoda main( ) accepta ca parametru un
singur argument: un tablou de elemente de tip String (siruri de caractere)
folosit pentru a pasa informatii aplicatiei prin linia de comanda. Argumentele
date prin linia de comanda permit utilizatorului sa influenteze operatiile
aplicatiei fara a fi necesara recompilarea. Programul Salut.java nu foloseste
in nici un fel eventualele argumente pasate in linia de comanda.
Linia de cod: System.out.println("Buna
ziua"); utilizeaza clasa System din pachetul de clase standard java.lang pentru a afisa pe ecran mesajul “Buna ziua”, invocand
metoda println() a obiectului out (declarat
static).
Daca in urma compilarii sau executiei apar erori,
acestea trebuie corectate (urmarind si indicatiile din mesajele de eroare),
revenind la etapa conceperii si editarii.
In laborator: Produceti urmatoarele modificari in
codul sursa (varianta
de 5 linii, fara comentarii), urmariti efectele lor (in special
eventualele rapoarte de eroare la executie sau compilare), si faceti
interpretari ale acestora (aceste
rapoarte de eroare si interpretari vor forma prima parte a temei de casa!). Dupa fiecare modificare codul va fi recompilat (iar in caz de succes
executat din nou). Inaintea unei noi modificari va fi mai
intai restabilit programul
initial. Raspunsurile la urmatoarele intrebari
vor usura interpretarea rezultatelor : - Ce se afiseaza pe ecran? - Ce fel de
problema apare (eroare de compilare, exceptie in timpul executiei, niciuna)? - Care este
cauza probabila? - Cat de
sugestiv este mesajul care apare? - Ce concluzii se pot trage? |
I. Se elimina prima acolada (din linia 1) |
Exemplu de rezolvare: La compilare, pe ecran se afiseaza:
Salut.java:1:
'{' expected public class
Salut ^ 1 error |
Problema: eroare de
compilare. Cauza: compilatorul
sesizeaza inexistenta acoladei deschise dupa numele clasei, acolada care
marcheaza inceputul corpului clasei. Mesajul e destul de sugestiv incat sa ne permita corectarea rapida a erorii. Concluzii: …
II. Se va elimina acolada din linia 2 |
Exemplu de rezolvare: La compilare, pe ecran se afiseaza:
Salut.java:2:
';' expected public static void main(String[] args) ^ Salut.java:5:
'class' or 'interface' expected } ^ Salut.java:6:
'class' or 'interface' expected ^ 3 errors |
Problema: eroare de
compilare. Cauza: compilatorul
sesizeaza inexistenta acoladei deschise dupa numele metodei main, acolada care
marcheaza inceputul corpului metodei. Prima parte a mesajului este utila pentru
a corecta eroarea, dar restul mesajului poate produce confuzie in primul moment. Dupa corectarea erorii din
linia doi, “erorile” 2 si 3 “dispar”. Concluzii:
Apare un fenomen de “propagare a
erorilor”, lipsa acoladei respective putand avea mai multe interpretari.
III. Se va elimina simbolul punct
si virgula (;) din linia 3 |
IV. Se vor elimina parantezele
drepte, [], din linia 2 |
V. Se va elimina cuvantul cheie void (din linia 2) |
VI. Se va elimina cuvantul cheie static (din linia 2) |
Exemplu de rezolvare: Dupa compilare, in momentul executiei, pe ecran se afiseaza:
Exception in
thread "main" java.lang.NoSuchMethodError: main |
Problema: situatie
exceptionala (java.lang.NoSuchMethodError) in timpul executiei. Cauza: Masina Virtuala Java (JVM), cea
care sta in spatele interpretorului Java sesizeaza inexistenta unei metode
Java cu semnatura completa: public static void main(String[] args). Mesajul produce confuzie in primul moment, deoarece da impresia ca metoda
nu exista, si nu sugereaza cauza situatiei exceptionale. Concluzii: Este strict necesara declararea metodei main() ca fiind de tip static.
Este recomandabila retinerea simptomelor acestei situatii exceptionale!
VII. Se vor inlocui ghilimelele
cu apostroafe in linia 3 |
VIII. Se va inlocui numele clasei System cu system in linia 3 |
IX. Se va inlocui numele clasei Salut cu salut in linia 1 |
X. Se va inlocui args din linia 2 cu cuvantul argumente |
Pentru o mai buna intelegere a codului in Java se folosesc o serie de
conventii privind modul in care sunt denumite clasele, variabilele, metodele,
etc., astfel:
- Numele unei clase incepe
intotdeauna cu litera mare si nu
este urmat de paranteze. Ex: String
- Numele unui constructor
incepe intotdeauna cu litera mare si este
urmat de paranteze. Constructorii sunt functii care au acelasi nume cu clasa, folosite
pentru crearea/ initializarea obiectelor. Ex: String(..)
- Numele cuvintelor rezervate
sau cheie (prezentate in tabelul de
mai jos) incep intotdeauna cu litera mica. Ex: int
- Numele unei variabile incepe
intotdeauna cu litera mica si nu
este urmat de paranteze. Ex: razaCercului
- Numele unei metode (functie
Java) incepe intotdeauna cu litera mica si este
urmat de paranteze. Ex: ariaCercului(..)
In toate cazurile de mai sus, daca numele este
format din mai multe cuvinte, in loc de
separator cuvintele din interiorul numelui incep cu litera mare. Ex: razaCercului, ariaCercului(..)
- Numele unei constante se scrie
cu litere mari, iar in cazul numelor formate din mai multe cuvinte se foloseste
pe post de separator simbolul
underscore (“_”).
Ex: PI_PATRAT
Cuvintele cheie sau rezervate in limbajul Java:
abstract assert (din 1.4) boolean break byte case catch char class |
const (neutilizat) continue default do double else enum (din 5.0) extends false |
final finally float for goto (neutilizat) if implements import instanceof |
int interface long native new null package private protected |
public return short static strictfp(din1.2) super switch synchronized this |
throw throws transient true try void volatile while |
Urmatorul program, SalutUtilizator0.java, il saluta pe utilizator folosind ca nume al utilizatorului un argument
pasat programului de la lansare.
1 2 3 4 5 6 7 8 9 10 11 |
public class SalutUtilizator0
{ // Obtinerea numelui utilizatorului // Salutul |
In laborator: 1. Analizati codul
clasei SalutUtilizator0. 2. Care
sunt elementele de noutate fata de codul clasei Salut? |
In laborator: 1. Creati fisierul sursa
SalutUtilizator0.java cu
continutul de mai sus in directorul curent. 2. Executati
urmatoarele comenzi in consola, in directorul curent: > javac SalutUtilizator0.java > java SalutUtilizator0 <numele studentului care executa programul> folosind un nume simplu, care sa nu includa
spatii (exemplu: Xulescu). 3. Executati comenzile
de la pct. 2 cu un nume care sa includa spatii (exemplu: Xulescu Ygrec). Ce observati? 4.
Executati comenzile de la pct. 2 cu un nume care sa includa spatii dar care
sa fie incadrat de ghilimele (exemplu: "Xulescu Ygrec"). Ce se
schimba? |
Variabilele locale sunt acele variabile declarate in interiorul blocurilor de cod (cuprinse intre acolade). Sunt create in momentul declararii lor si sunt accesibile din locul declararii si pana la sfarsitul blocului de cod in care au fost declarate (pentru variabilele referinta in momentul declararii este creata doar referinta, obiectul referit fiind creat dinamic cu new).
Concatenarea sirurilor de caractere modSalut si nume este realizata cu ajutorul operatorului "+".
Fereastra de dialog este cel mai simplu si elegant mod de obtinere a unei intrari de la utilizator atunci cand este nevoie. Metodei showInputDialog() i se ofera ca parametru mesajul catre utilizator, iar metoda returneaza intrarea de la utilizator ca sir de caractere (obiect String).
Pentru a
obtine de la utilizator o valoare de tip sir de caractere (String) se foloseste
sintaxa:
1 2 |
// Obtinerea numelui utilizatorului folosind fereasta
de dialog String nume = JOptionPane.showInputDialog("Introduceti-va
numele:"); |
Pentru a
afisa un mesaj catre utilizator se foloseste sintaxa:
1 2 |
// Afisarea unui mesaj catre utilizator folosind fereasta de
dialog JOptionPane.showMessageDialog(null,
"Bun venit in lumea Java, Xulescu!"); |
Ambele situatii impun importul clasei JOptionPane din pachetul de clase de biblioteca grafice javax.swing, sau a intregului pachet de clase de biblioteca javax.swing.
Pentru a se
importa clasa JOptionPane din
pachetul de clase javax.swing se foloseste sintaxa:
1 2 |
// Importul unei clase se declara inaintea declaratiei
clasei import javax.swing.JOptionPane; |
Pentru a se
importa pachetul de clase
javax.swing se foloseste sintaxa:
1 2 |
// Importul unui pachet de clase se declara inaintea
declaratiei clasei import javax.swing.*; |
Urmatorul program, SalutUtilizator1.java, il saluta pe utilizator cu numele pe care il obtine interactiv direct de la acesta. Programul are un mod de salut diferit de cel al programului anterior.
In laborator: 1. Creati fisierul
sursa SalutUtilizator1.java cu continutul de mai jos in directorul curent. 2.
Compilati si executati programul in consola, in directorul curent. |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import javax.swing.*; //
Importul unui pachet (biblioteca) de clase grafice public class SalutUtilizator1 { //
Obtinerea numelui utilizatorului //
Salutul } |
Ca alternativa la utilizarea ferestrelor de dialog se poate utiliza perechea de console standard, tastatura si ecranul in mod text (vezi anexa).
Un tablou Java este o structura care contine mai multe valori de acelasi tip, numite elemente. Lungimea unui tablou este fixa, stabilita in momentul crearii tabloului (cu operatorul new).
Spre exemplu, pentru a crea un tablou cu valorile 1, 2, 3, 4, 3, 2, 1 se foloseste sintaxa simplificata:
// Crearea unui tablou de 7
valori intregi, varianta simplificata int[] tab = { 1, 2, 3, 4, 3, 2, 1 }; |
Acelasi efect se obtine folosind sintaxa complexa pentru crearea unui tablou:
// Crearea unui tablou de 7
valori intregi, varianta complexa int[] tab = new int[7]; // declararea variabilei si alocarea
memoriei tab[0]= 1; // popularea tabloului tab[1]= 2; // popularea tabloului tab[2]= 3; // popularea tabloului tab[3]= 4; // popularea tabloului tab[4]= 3; // popularea tabloului tab[5]= 2; // popularea tabloului tab[6]= 1; // popularea tabloului |
Urmatorul program, SumaArgumenteIntregi.java, calculeaza suma
valorilor pasate ca argumente la lansarea programului.
In laborator: 1. Analizati codul
clasei SumaArgumenteIntregi. 2. Ce
instructiuni recunoasteti si ce rol au ele? Ce elemente din program va sunt
necunoscute? |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class SumaArgumenteIntregi { |
Pentru a obtine numarul de elemente ale unui tablou se foloseste:
// Obtinerea dimensiunii
tabloului de argumente pasate de utilizator int
numarArgumentePasateDeUtilizator = args.length; |
Pentru a converti o valoare de la String la int se foloseste sintaxa:
// Conversia unei valori de
la tip int la tip String int
numarStudenti = Integer.parseInt("25"); |
In laborator: 1. Se creaza fisierul
sursa SumaArgumenteIntregi.java cu continutul de mai sus in directorul curent. 2. Se compileaza si se
executa programul in consola, in directorul curent, fara pasare de argumente. 3. Se executa apoi
programul oferindu-i 3 argumente
intregi. 4. Se
executa apoi programul oferindu-i un
singur argument ‘a’. Ce observati? |
Se doreste scrierea unui program Java numit Polinom0, care:
- sa creeze
un polinom cu grad prestabilit (4)
si coeficienti de valori prestabilite
(1, 2, 3, 2, 1),
- sa afiseze polinomul,
- sa calculeze
valoarea polinomului pentru o
anumita valoare prestabilita a necunoscutei (2), si
- sa afiseze
aceasta valoare.
In laborator: 1. Se creaza fisierul
sursa Polinom0.java cu continutul de mai jos (inclusiv comentariile)
in directorul curent. 2. Se adauga sub
fiecare grup de comentarii codul necesar (acest
cod va fi scris si testat la laborator si va fi prezentat apoi ca tema de
casa); 3. Formatul afisarii
coeficientilor polinomului este: P(X) = 1 + 2*X^1 + 3*X^2 + 2*X^3 + 1*X^4 4. Se
compileaza si se executa programul in consola, in directorul curent. |
Sfat! Pentru simplitate si pentru a evita
aparitia unui numar mare de erori de odata, este indicat sa se scrie si sa se verifice codul pe portiuni. Se va
crea intr-o prima etapa polinomul (prin gradul si coeficientii sai) si se va
afisa (liniile 1 - 13). In cea
de-a doua etapa se obtine necunoscuta, se calculeaza valoarea polinomului si
se afiseaza rezultatul (liniile
14-28). |
Indicatii! - pentru a calcula X^i (in variabila xLaI) se poate folosi functia matematica pow() din biblioteca matematica Math aflata in pachetul de clase java.lang (pachet care contine si String si System si nu necesita importul); - metoda pow()
primeste doua argumente
(primul este valoarea de ridicat la putere, iar al doilea este puterea) si
returneaza o valoare de tip double; In acest
caz este necesara conversia explicita
(cast) a valorii returnate la tipul int ca in mai jos:
int xLaI;
for (int i=0; i<=N; i++)
{ // - calculul valorii X^i,
unde i=1,N
xLaI
= (int) Math.pow(X, i); } |
Pseudocodul programului Polinom0 este urmatorul:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
public class Polinom0
{ public
static void main(String[]
args) { // Declararea si initializarea variabilei intregi, // care contine gradul polinomului, N=4 // Crearea tabloului coeficientilor (de
dimensiune N+1), numit C, // folosind valorile prestabilite :
1, 2, 3, 2, 1 // Afisarea polinomului P(X) // - mai intai termenul liber Co // - apoi termenii Ci*X^i, unde i=1,N // Declararea si initializarea
variabilei intregi numita necunoscuta, // care contine valoarea necunoscutei,
X=2 // Afisarea valorii necunoscutei (X) // Declararea si initializarea
variabilei intregi numita P, // care contine valoarea polinomului,
P(X) // Calculul polinomului P(X) = suma(Ci *
X^i), unde i=0,N // - calculul valorii X^i, unde
i=1,N // - actualizarea valorii
polinomului // Afisarea valorii polinomului P(X) } } |
Se observa ca in aceasta forma, la fiecare executie programul va genera
aceleasi iesiri.
Pornind de la programul Polinom0 sa se scrie un program numit Polinom1, care:
- sa creeze un polinom cu grad si
coeficienti avand valorile obtinute de
la utilizator,
- sa afiseze polinomul,
- sa calculeze valoarea polinomului pentru o
valoare a necunoscutei specificata de utilizator, si
- sa afiseze aceasta valoare.
Programul Polinom1 reprezinta o generalizare a programului anterior (versiune mai flexibila),
deoarece gradul polinomului, valorile coeficientilor si a necunoscutei sunt
obtinute de la utilizator. In aceasta forma, la fiecare executie programul poate genera alte iesiri, in functie de
valorile de intrare.
In laborator: 1. Se creaza fisierul
sursa Polinom1.java cu continutul de mai jos (inclusiv comentariile)
in directorul curent. 2. Se adauga sub
fiecare grup de comentarii codul necesar (acest cod va fi scris si testat la laborator si va fi prezentat apoi
ca tema de casa). 3. Se
compileaza si se executa programul in consola, in directorul curent. Se
corecteaza eventualele erori. |
Indicatii! - combinand doua sintaxe deja cunoscute se poate scrie: int N = Integer.parseInt(JOptionPane.showInputDialog(
"Introduceti gradul polinomului")); - pentru a popula (atribui valori initiale) un tablou de intregi se poate folosi o instructiune for. |
In pseudocodul care urmeaza comentariile scrise
intensificat (bold) reprezinta elementele de noutate fata de programul
anterior.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import javax.swing.JOptionPane; public
class Polinom1 { public
static void main(String[]
args) { // Declararea
variabilei intregi N gradul polinomului // Obtinerea
gradului polinomului de la utilizator, conversie String-int // Declararea
si crearea tabloului coeficientilor, C // Obtinerea de
la utilizator a coeficientilor Ci, unde i=0,N // Afisarea
polinomului P(X) // - mai intai
termenul liber Co // - apoi
termenii Ci*X^i, unde i=1,N // Declararea
variabilei intregi X // Obtinerea valorii
necunoscutei de la utilizator, conversie String-int // Afisarea
valorii necunoscutei (X) // Declararea
si initializarea variabilei intregi numita polinom, // care contine
valoarea polinomului, P(X) // Calculul
polinomului P(X) = suma(Ci * X^i), unde i=0,N // -
calculul valorii X^i, unde i=1,N // -
actualizarea valorii polinomului // Afisarea
valorii polinomului P(X) } } |
Metodele sunt cazul cel mai simplu si mai des intalnit
de delegare a functionalitatii.
Separarea codului in functii (metode) serveste gestiunii mai simple a codului,
modularizarii codului la nivel de secventa de instructiuni, reutilizarii
codului la nivel de functie. In general
functia principala main() deleaga
anumite sarcini catre alte functii, acestea la randul lor catre altele,
s.a.m.d.
Pornind de la programul Polinom1 sa se scrie codul unei clase Java numita Polinom2, a carei structura interna contine:
- o metoda (declarata public static) numita obtineGrad(), care
- obtine de la utilizator valoarea gradului
polinomului, si
- o returneaza ca intreg de tip int,
- o metoda (declarata public static) numita stabilesteCoeficienti(), care
- primeste un parametru intreg de tip int, numit N,
reprezentand gradului polinomului,
- creeaza un nou tablou al coeficientilor (cu N+1 elemente),
- obtine de la utilizator valori pentru
coeficientii polinomului si
- populeaza cu ei tabloul nou creat, apoi
- returneaza taboul de tip int[] creat,
- o metoda (declarata public static) numita obtineNecunoscuta(), care
- obtine de la utilizator valoarea necunoscutei,
si
- o returneaza ca intreg de tip int,
- o metoda (declarata public static) numita afisarePolinom(), care
- primeste un parametru intreg de tip int, numit N,
reprezentand gradului polinomului,
si un
parametru de tip int[], numit C,
reprezentand coeficientii polinomului, si
- afiseaza polinomul corespunzator valorilor
primite,
- o metoda (declarata public static) numita valoarePolinom(), care
- primeste un parametru intreg de tip int, numit N,
reprezentand gradului polinomului,
un parametru de tip int[], numit C,
reprezentand coeficientii polinomului,
si un parametru intreg de tip int, numit X, reprezentand necunoscuta,
- calculeaza valoarea polinomului corespunzatoare
valorilor primite si
- o returneaza ca intreg de tip int,
- o metoda principala, de test,
care:
- deleaga catre metoda obtineGrad()
obtinerea valorii gradului polinomului,
- deleaga catre metoda stabilesteCoeficienti() stabilirea
valorilor coeficientilor,
- deleaga catre metoda afisarePolinom()
afisarea polinomului,
- deleaga catre metoda obtineNecunoscuta()
obtinerea valorii necunoscutei,
- afiseaza valoarea necunoscutei,
- deleaga catre metoda valoarePolinom()
calculul valorii polinomului,
- afiseaza valoarea polinomului.
In laborator: 1. Se creaza fisierul
sursa Polinom2.java cu continutul de mai jos (inclusiv comentariile)
in directorul curent. 2. Se adauga sub
fiecare grup de comentarii codul necesar (acest
cod va fi scris si testat la laborator si va fi prezentat apoi ca tema de
casa). 3. Se
compileaza si se executa programul in consola, in directorul curent. Se
corecteaza eventualele erori. |
In pseudocodul care urmeaza comentariile scrise
intensificat (bold) reprezinta elementele de noutate fata de programul
anterior.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
import javax.swing.JOptionPane; public
class Polinom2 { //
Metoda care obtine de la utilizator gradul polinomului public static int obtineGrad() { // Obtinerea de la utilizator a
gradului polinomului int N = Integer.parseInt(JOptionPane.showInputDialog( "Introduceti gradul polinomului")); // Returnarea valorii gradului polinomului return N; } // Metoda care obtine de la utilizator
coeficientii polinomului public static int[] stabilesteCoeficienti(int
N) { //
Declararea si crearea tabloului coeficientilor, numit C //
Obtinerea de la utilizator a coeficientilor Ci, unde i=0,N // Returnarea tabloului coeficientilor } // Metoda care afiseaza polinomul P(X) public static
void afisarePolinom(int N,
int[] C) { // Afisarea polinomului P(X) // - mai
intai termenul liber Co // - apoi
termenii Ci*X^i, unde i=1,N } // Metoda care obtine de la utilizator
valoarea necunoscutei public static
int obtineNecunoscuta() { //
Obtinerea de la utilizator a valorii necunoscutei // Returnarea valorii necunoscutei } // Metoda care calculeaza valoarea
polinomului pt o valoare a necunoscutei public static
int valoarePolinom(int N, int[] C, int X) { // Declararea si
initializarea variabilei intregi numita P // Calculul
polinomului P(X) = suma(Ci * X^i), unde i=0,N // -
calculul valorii X^i, unde i=1,N // - actualizarea
valorii polinomului // Returnarea valorii polinomului } // Metoda principala. Utilizata pentru
testarea celorlalte metode. public static
void main(String[] args) { // Apelul metodei care obtine de la utilizator gradul polinomului int N = obtineGrad(); // Apelul
metodei care obtine de la utilizator
coeficientii polinomului // Apelul
metodei care afiseaza polinomul // Apelul
metodei care obtine o valoare a
necunoscutei // Afisarea valorii necunoscutei // Apelul
metodei care calculeaza polinomul
pentru necunoscuta data // Afisarea valorii polinomului System.exit(0); //
Inchiderea interfetei grafice } } |
Temele indicate de-a lungul laboratorului in
platforma (in sectiunile 1.3.5, 1.5.1, 1.5.2 si 1.5.3)
- vor fi predate la lucrarea urmatoare
- cate un exemplar pentru fiecare grup
de 2 studenti
- scrise
de mana pe hartie
- avand numele celor doi studenti scrise pe prima pagina sus
Pentru obtinerea platformei de dezvoltare JDK 6
Update XY (21 in prezent) trebuie accesata pagina site-ului
Oracle http://www.oracle.com/technetwork/java/javase/downloads/index.html
- cautata Java Platform, Standard
Edition care contine Java Development Kit (JDK)
- click pe Download
JDK
- click pe Download
Java SE Development Kit 6u21
- selectata platforma
(Windows, etc.)
- click pe Continue
(DOAR optional completati user name si mail, pentru Log In or Register)
- click pe v jdk-6u21-windows-i586.exe
(Java SE Development Kit 6u21
75.91 MB)
Link
local pentru descarcare JDK 6.
Instalarea kitului de dezvoltare Java sub Windows este in general simpla (vezi si http://www.oracle.com/technetwork/java/javase/documentation/install-windows-152927.html pentru Windows). Dupa lansarea in
executie a kitului se pot accepta toate optiunile implicite pe care le ofera
kitul. Directorul de baza al instalarii va fi implicit C:\Program
Files\Java\jdk1.6.0_21.
Procedura incepe cu selectarea Start
-> Control Panel -> System -> Advanced -> Environment
Variables -> System
Variables (nu User Variables).
1. Pentru a se putea
executa programele care compun kitul de dezvoltare Java, trebuie adaugata la
variabila de mediu PATH calea catre
directorul \bin al kitului
Java (in care se gasesc executabilele care formeaza kitul Java), folosind
comanda -> Edit:
- se va adauga calea C:\Program Files\Java\jdk1.6.0_21\bin.
2. Pentru a fi
vizibile clasele de biblioteca standard Java, precum si clasele din directorul curent
folosit pentru dezvoltarea programelor, trebuie creata o noua variabila de
mediu CLASSPATH, folosind comanda -> New:
- acestei variabile i se da valoarea C:\Program
Files\Java\jdk1.6.0_21\lib;.; (unde \lib e directorul
bibliotecii, iar punctul este calea catre directorul curent, necesara executiei
programelor create de noi).
1. Se lanseaza consola cu Start -> Run se scrie:
cmd apoi <Enter>
2. In consola se alege un director dorit pentru
testarea instalarii kitului
(cu cd \ <Enter> se ajunge in radacina C:\> ,
cu cd.. <Enter> se
ajunge in directorul al carui subdirector este directorul curent,
cu cd <subdirector> <Enter> se ajunge intr-un subdirector,
cu D: <Enter> se
schimba harddiskul in D:)
3. In directorul ales se creaza cu un editor un
fisier numit Test.java, cu urmatorul
continut:
public class Test {
public static void main(String[]
args) {
System.out.println("Kitul Java a fost
instalat cu succes!");
}
}
4. In consola se scrie (pentru compilare) :
javac Test.java <Enter>
(daca nu sunt probleme,
apare un nou prompt fara vreun mesaj)
5. In consola se scrie (pentru executie in masina
virtuala Java – JVM):
java Test <Enter>
6. Astfel in consola va aparea mesajul:
Kitul Java a fost instalat cu succes!
Asa cum a fost precizat in capitolul 1.3.4., cu ajutorul comenzii:
directorcurent> javadoc Salut.java |
se poate genera
automat documentatia pentru aplicatia Salut.java pe baza comentariilor introduse in
interiorul codului.
In urma aplicarii comenzii anterioare se vor afisa urmatoarele mesaje:
directorcurent>javadoc Salut.java Loading source file Salut.java... Constructing Javadoc
information... Standard Doclet version
1.5.0_07 Building tree for all the packages and classes... Generating Salut.html... Generating package-frame.html... Generating package-summary.html... Generating package-tree.html... Generating constant-values.html... Building index for all the packages and classes... ... |
si vor fi automat
create pagini web ca cea din figura:
In acest format pot fi gasite si documentatiile claselor de biblioteca
Java.
Documentatia Java pentru ultima versiune (Java
SE 6) poate fi accesata online
la adresa http://download.oracle.com/javase/6/docs/
Specificatia API (documentatia
claselor bibliotecii standard) poate
fi accesata online la adresa http://download.oracle.com/javase/6/docs/api/index.html pentru versiunea Java SE 6.
Documentatia Java poate fi descarcata sub forma
unei arhive .zip din sectiunea Java SE 6 Documentation de la adresa http://www.oracle.com/technetwork/java/javase/downloads/index.html.
Din sectiunea Java SE 6 JDK Source Code poate fi descarcat si vizualizat si
codul sursa al tuturor claselor Java. Link local
pentru descarcare documentatie JDK 6.
Pe langa documentatia de baza, se poate accesa
online tutorialul general Java oferit
de Oracle, aflat la adresa http://download.oracle.com/javase/tutorial/, iar lista detaliata de subiecte la adresa http://download.oracle.com/javase/tutorial/reallybigindex.html
De asemenea, poate fi accesat si tutorialul Java
SE 6 la adresa http://download.oracle.com/javaee/6/tutorial/doc/
.
Alte referinte Web interesante:
Bruce Eckel, Thinking in Java, 3 rded,
http://www.faqs.org/docs/think_java/TIJ3_c.htm,
PDF: http://www.planetpdf.com/codecuts/pdfs/eckel/TIJ3.zip, http://www.mindviewinc.com/downloads/TIJ-3rd-edition4.0.zip
(HTML)
Kevin Taylor, Java Progr. Tutorial, http://java.about.com/od/beginningjava/a/beginjavatutor.htm
Ca alternativa la utilizarea ferestrelor de dialog se poate utiliza perechea de console standard, tastatura (de intrare) si ecranul in mod text (de iesire).
Programul SalutUtilizator2.java foloseste varianta cu clasa Scanner din pachetul java.util. Varianta este disponibila de la versiunea Java 5 (JDK 1.5.0).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.util.*; //Importul
pachetului (bibliotecii) de clase utilitare System.out.print("Introduceti-va
numele: "); |
Programul SalutUtilizator3.java foloseste varianta cu clasele BufferedReader si InputStreamReader din pachetul java.io. Varianta este cea utilizata inca de la prima versiune Java, dar este mai complicata decat cea bazata pe clasa Scanner.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.io.*; // Importul pachetului de clase de intrare-iesire (IO) public class SalutUtilizator3 {
|
In acest caz, citirea consolei standard de intrare se face prin intermediul unui flux de intrare pentru caractere (in Java, caracterele sunt codate UNICODE pe 2 octeti), BufferedReader, conectat la fluxul standard de intrare (System.in, care ofera datele de la tastatura sub forma de octeti simpli) prin intermediul unui flux de intrare care face conversia octet-caracter (InputStreamReader).