This shows you the differences between two versions of the page.
poo:laboratoare:03 [2017/12/22 15:13] mihai.nan |
poo:laboratoare:03 [2020/10/20 11:33] (current) carmen.odubasteanu [Problema 1] |
||
---|---|---|---|
Line 2: | Line 2: | ||
====Problema 1==== | ====Problema 1==== | ||
- | Definiti o clasa **//Fractie//** care modeleaza lucrul cu fractiile. Membrii acestei clase sunt: | + | Definiți o clasă **//Fractie//** care modelează lucrul cu fracțiile. Membrii acestei clase sunt: |
- | * doua atribuite de tip **//double//** pentru numaratorul fractiei, respectiv numitorul ei; | + | * două atribuite de tip **//int//** pentru numărătorul fracției, respectiv numitorul ei; |
- | * constructorul cu doi parametri de tip //**double**//, pentru setarea celor doua parti ale fractiei (numarator si numitor); | + | * constructorul cu doi parametri de tip //**int**//, pentru setarea celor două parți ale fracției (numărător și numitor); |
- | * un constructor fără parametri care apeleaza constructorul anterior; | + | * un constructor fără parametri care apelează constructorul anterior; |
- | * o metoda, cu un **singur** parametru, de calcul a sumei a doua fractii; | + | * o metodă, cu un **singur** parametru, de calcul a sumei a două fracții; |
- | * o metoda **//toString//** uzitata pentru afisarea pe ecran a valorii fractiei; | + | * o metodă **//toString//** uzitată pentru afișarea pe ecran a valorii fracției; |
- | * o metoda **//equals//**, cu un parametru de tip **//Object//**, care va returna **//true//** daca fractiile sunt egale, respectiv **//false//** in sens contrar; | + | * o metodă **//equals//**, cu un parametru de tip **//Object//**, care va returna **//true//** dacă fracțiile sunt egale, respectiv **//false//** în sens contrar; |
- | * o metoda **//main//** pentru testarea functionalitatii clasei. | + | * o metodă **//main//** pentru testarea funcționalității clasei. |
- | <note important>Consultati exemplul prezentat la curs pentru numere complexe!</note> | + | <note important>Consultați exemplul prezentat la curs pentru numere complexe!</note> |
Line 17: | Line 17: | ||
====Problema 2==== | ====Problema 2==== | ||
- | Un produs este caracterizat prin nume (**//String//**), pret (//**double**//) si cantitate (**//int//**). Un magazin are un nume (//**String**//) si contine 3 produse. Creati clasele **//Produs//** si //**Magazin**// corespunzatoare specificatiilor de mai sus. In fiecare clasa, implementati constructorul potrivit, astfel incat caracteristicile instantelor sa fie setate la crearea acestora. | + | Un produs este caracterizat prin nume (**//String//**), preț (//**double**//) și cantitate (**//int//**). |
- | \par | + | Un magazin are un nume (//**String**//) și conține 3 produse. |
- | Clasa //**Produs**// contine o metoda //**toString**//, care va returna un //**String**// sub forma **"Produs nume_produs pret_produs cantitate"** si o metoda **//getTotalProdus//** care va returna un **//double//**, produsul dintre cantitate si pret. Clasa //**Magazin**// contine o metoda //**toString**// care afiseaza toate componentele magazinului (va apela metoda //**toString**// pentru fiecare produs) si o metoda //**getTotalMagazin**// care va calcula suma totalurilor produselor si o va returna. Creati, intr-o metoda //**main**//, un obiect de tip //**Magazin**//, uzitand obiecte anonime in cadrul instantierii. | + | Creați clasele **//Produs//** și //**Magazin**// corespunzătoare specificațiilor de mai sus. În fiecare clasă, implementați constructorul potrivit, astfel încât caracteristicile instanțelor să fie setate la crearea acestora. |
+ | Clasa //**Produs**// conține o metodă //**toString**//, care va returna un //**String**// sub forma **"Produs <nume_produs> <preț_produs> <cantitate>"** și o metodă **//getTotalProdus//** care va returna un **//double//**, produsul dintre cantitate și preț. Clasa //**Magazin**// conține o metodă //**toString**// care va returna String-ul corespondent tuturor componentelor magazinului și o metodă //**getTotalMagazin**// care va calcula suma totalurilor produselor și o va returna. | ||
+ | Creați, într-o metodă //**main**//, un obiect de tip //**Magazin**//, uzitând obiecte anonime în cadrul instanțierii. | ||
<note tip> | <note tip> | ||
Line 28: | Line 30: | ||
====Problema 3==== | ====Problema 3==== | ||
- | Sa se defineasca o clasa **//MyQueue//** care sa descrie o structura de date de tip coada. | + | Să se definească o clasă **//MyQueue//** care să descrie o structură de date de tip coadă. |
Datele clasei (private): | Datele clasei (private): | ||
- | * un obiect de tip **//MyArray//** (clasa inclusa in arhiva laboratorului); | + | * un obiect de tip **//MyArray//** (clasa inclusă în arhiva laboratorului); |
- | * o constanta (//**Infinit**//) avand valoarea 9500; | + | * o constantă (//**Infinit**//) având valoarea $9500$; |
- | * indicele primului element din coada; | + | * indicele primului element din coadă; |
- | * indicele ultimului element din coada; | + | * indicele ultimului element din coadă; |
- | * numarul de elemente din coada. | + | * numărul de elemente din coada. |
Constructorul clasei: | Constructorul clasei: | ||
- | * constructor fara parametri care se ocupa de initializarile membrilor. | + | * constructor fără parametri care se ocupă de inițializările membrilor. |
Metodele clasei: | Metodele clasei: | ||
- | * **//int getSize()//** = are ca rezultat numarul de elemente din coada; | + | * **//int getSize()//** = are ca rezultat numărul de elemente din coadă; |
- | * **//void enqueue(int value)//** = adauga o valoare in coada; | + | * **//void enqueue(int value)//** = adaugă o valoare în coadă; |
- | * **//int dequeue()//** = intoarce primul element din coada si il elimina, incrementand indicele corespunzator, fara a elimina efectiv elementul din obiectul de tip **//MyArray//** (//**Infinit**// - coada vida); | + | * **//int dequeue()//** = întoarce primul element din coadă și îl elimină, incrementând indicele corespunzător, fără a elimina efectiv elementul din obiectul de tip **//MyArray//** (//**Infinit**// - coada vidă); |
- | * **//boolean isEmpty()//** = verifica daca este vida coada; | + | * **//boolean isEmpty()//** = verifică dacă este vidă coada; |
- | * **//String toString()//** = afisarea elementelor din structura de date. | + | * **//String toString()//** = String cu elementele din structura de date. |
- | Pentru verificare, se va folosi clasa **//TestBonus//** din arhiva laboratorului. | + | Pentru verificare, se va folosi clasa de mai jos. |
+ | |||
+ | <code java> | ||
+ | class MyArray { | ||
+ | private int v[]; | ||
+ | private int size; | ||
+ | |||
+ | public MyArray() { | ||
+ | this(100); | ||
+ | } | ||
+ | |||
+ | public MyArray(int length) { | ||
+ | size = 0; | ||
+ | v = new int[length]; | ||
+ | } | ||
+ | |||
+ | public int get(int poz) { | ||
+ | if(poz < size) { | ||
+ | return v[poz]; | ||
+ | } else { | ||
+ | return -1; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | public void set(int pos, int value) { | ||
+ | v[pos] = value; | ||
+ | size++; | ||
+ | } | ||
+ | |||
+ | public int getSize() { | ||
+ | return size; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | |||
+ | class Test { | ||
+ | public static void main(String args[]) { | ||
+ | MyQueue queue = new MyQueue(); | ||
+ | queue.enqueue(7); | ||
+ | queue.enqueue(8); | ||
+ | queue.enqueue(10); | ||
+ | queue.enqueue(-1); | ||
+ | queue.enqueue(2); | ||
+ | System.out.println(queue); | ||
+ | System.out.println(queue.dequeue()); | ||
+ | System.out.println(queue.getSize()); | ||
+ | System.out.println(queue); | ||
+ | queue.enqueue(9); | ||
+ | queue.enqueue(queue.dequeue()); | ||
+ | queue.enqueue(11); | ||
+ | queue.enqueue(22); | ||
+ | System.out.println(queue); | ||
+ | while(!queue.isEmpty()) { | ||
+ | System.out.print(queue.dequeue() + " "); | ||
+ | } | ||
+ | System.out.println(""); | ||
+ | System.out.println(queue); | ||
+ | } | ||
+ | } | ||
+ | </code> | ||
====Problema 4==== | ====Problema 4==== | ||
- | Definiti o clasa **//Numar//** care are ca membru un numar intreg si contine metodele descrise mai jos. Implementati metodele astfel incat fiecare metoda sa efectueze o singura adunare. | + | Definiți o clasă **//Numar//** care are ca membru un număr întreg și conține metodele descrise mai jos. Implementați metodele astfel încât fiecare metodă să efectueze o singură adunare. |
- | Instantiati un obiect de tip **//Numar//** in metoda //**main**// si apelati metodele implementate. | + | Instanțiați un obiect de tip **//Numar//** în metoda //**main**// și apelați metodele implementate. |
- | Ce principiu POO este evidentiat in acest exercitiu? | + | Ce principiu POO este evidențiat în acest exercițiu? |
<note important><code java> | <note important><code java> | ||
//returneaza suma dintre nr (membrul clasei) si a | //returneaza suma dintre nr (membrul clasei) si a | ||
Line 65: | Line 126: | ||
====Problema 5==== | ====Problema 5==== | ||
- | Sa se implementeze ierarhia de clase descrisa prin urmatoarea diagrama: | + | Implementați clasa **//Punct//** care definește un punct din spațiul 2D. |
- | {{:poo:laboratoare:clase1.png|}} | + | **Datele clasei (private):** |
+ | * două nr. întregi reprezentând cele două coordonate ale punctului. | ||
- | Clasa **//Schedule//** contine o metoda care calculeaza durata calatoriei in minute. Stiind algoritmul de calcul al pretului unui bilet de calatorie, sa se implementeze o metoda, in clasa **//Train//**, care calculeaza pretul unui bilet. Valoarea unui bilet este egala cu **//X * durata_calatoriei//**, unde $X$ este egal cu $1$ pentru cursele interne si $2$ pentru cursele internationale. Clasa **//Route//** va contine un constructor cu 2 parametri si o metoda care primeste ca parametru un obiect de tip **//Route//** si verifica daca sunt de tip tur - retur cele doua rute, rezultatul fiind de tip **//boolean//**. Clasa **//ClockTime//** contine o metoda, cu un parametru de tip **//ClockTime//**, si compara doua momente de timp, rezultatul fiind un //**int**//. | + | **Conctructorul clasei:** |
+ | * un constructor fără parametri care instanțiază punctul ''O(0, 0)''. | ||
- | Adaugati o metoda //**main**// pentru testarea claselor implementate, utilizand exemplele oferite. Definiti un constructor potrivit pentru instantierea unui obiect de tip //**Train**//, in care sa apelati constructorii definiti in clasele //**Route**//, //**Schedule**// si //**ClockTime**//. | ||
- | <code> | + | **Metodele clasei:** |
- | [local] [origin (departure)] -> [destination (arrival)] | + | * ''int getX()'' = întoarce abscisa punctului; |
- | true Bucuresti Nord (9:35) -> Constanta (12:02) | + | * ''void setX(int x)'' = seteaza abscisa punctului; |
- | true Bucuresti Nord (5:45) -> Iasi (12:49) | + | * ''int getY()'' = întoarce ordonata punctului; |
- | false Bucuresti Nord (23:45) -> Sofia (17:00) | + | * ''void setY(int y)'' = setează ordonata punctului; |
- | </code> | + | * ''String toString()'' = returnează un String de forma ''(x, y)''; |
+ | * ''double distance(int, int)'' = calculează distanța dintre 2 puncte; | ||
+ | * ''double distance(Punct p1)'' = calculează distanța dintre 2 puncte. | ||
+ | |||
+ | Creați o clasă **//Test//**, în același pachet cu clasa **//Punct//**, care conține o metodă **//main//** care calculează distanța dintre punctele ''A(1, 2)'' si ''B(-1, 3)''. | ||
+ | |||
+ | |||
+ | Puteți accesa datele clasei //**Punct**// în metoda //**main**// din clasa //**Test**//? | ||
====Problema 6==== | ====Problema 6==== | ||
- | Implementati clasa **//Punct//** care defineste un punct din spatiul 2D. | + | Să se definească o clasă **//Graph//** care să descrie un graf ponderat orientat care are nodurile numerotate de la $1$. |
- | Datele clasei (private): | + | **Datele clasei (private):** |
- | * doua nr. intregi reprezentand cele doua coordonate ale punctului. | + | * o matrice cu componente de tip int (matricea costurilor) - matrice; |
+ | * o constantă (**//Infinit//**) având valoarea 9500; | ||
+ | * numărul de noduri - n . | ||
- | Conctructorul clasei: | + | **Constructorul clasei:** |
+ | * constructor cu un parametru întreg (numărul de noduri din graf) | ||
- | \begin{itemize} | + | **Metodele clasei:** |
- | \setlength{\itemindent}{.4in} | + | * ''int getSize()'' = are ca rezultat numărul de noduri din graf; |
- | \item | + | * ''void addArc(int v, int w, int cost)'' = adaugă un arc la graf (între $v$ și $w$, având costul $cost$); |
- | un constructor fara parametri care instantiaza punctul O(0, 0). | + | * ''boolean isArc(int v, int w)'' = verifică dacă există arc între $v$ și $w$ în graf; |
- | \end{itemize} | + | * ''toString()'' = afișarea grafului (se va alege o variantă intuitivă de afișare a grafului); |
- | \par | + | * ''int[][] floydWarshall()'' = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim în graf; |
- | \textbf{Metodele clasei} | + | * ''void main(String[])'' = metoda main pentru testarea functionalității clasei implementate. |
- | \begin{itemize} | + | |
- | \setlength{\itemindent}{.4in} | + | |
- | \item | + | |
- | \textbf{\textit{int getX()}} = intoarce abscisa punctului; | + | |
- | \item | + | |
- | \textbf{\textit{void setX(int x)}} = seteaza abscisa punctului; | + | |
- | \item | + | |
- | \textbf{\textit{int getY()}} = intoarce ordonata punctului; | + | |
- | \item | + | |
- | \textbf{\textit{void setY(int y)}} = seteaza ordonata punctului; | + | |
- | \item | + | |
- | \textbf{\textit{String toString()}} = returneaza un String de forma \textit{(x, y)}; | + | |
- | \item | + | |
- | \textbf{\textit{double distance(int, int)}} = calculeaza distanta dintre 2 puncte; | + | |
- | \item | + | |
- | \textbf{\textit{double distance(Punct p1)}} = calculeaza distanta dintre 2 puncte. | + | |
- | \end{itemize} | + | |
- | \par | + | |
- | Creati o clasa \textbf{\textit{Test}}, in acelasi pachet cu clasa \textbf{\textit{Punct}}, care contine o metoda \textbf{\textit{main}} care calculeaza distanta dintre punctele \textbf{A(1, 2)} si \textbf{B(-1, 3)}. | + | |
- | \par | + | |
- | Puteti accesa datele clasei \textbf{\textit{Punct}} in metoda \textbf{\textit{main}} din clasa \textbf{\textit{Test}}? | + | |
- | \chapter{\textbf{Problema 7}} | + | |
- | \par | + | |
- | Sa se defineasca o clasa \textbf{\textit{Graph}} care sa descrie un graf ponderat orientat care are nodurile numerotate de la 0. | + | |
- | \par | + | |
- | \textbf{Datele clasei (private)}: | + | |
- | \begin{itemize} | + | |
- | \setlength{\itemindent}{.4in} | + | |
- | \item | + | |
- | o matrice cu componente de tip int (matricea costurilor); | + | |
- | \item | + | |
- | o constanta (\textbf{\textit{Infinit}}) avand valoarea 9500; | + | |
- | \item | + | |
- | numarul de noduri. | + | |
- | \end{itemize} | + | |
- | \par | + | |
- | \textbf{Constructorul clasei}: | + | |
- | \begin{itemize} | + | |
- | \setlength{\itemindent}{.4in} | + | |
- | \item | + | |
- | constructor cu un parametru intreg (numarul de noduri din graf) | + | |
- | \end{itemize} | + | |
- | \par | + | |
- | \textbf{Metodele clasei}: | + | |
- | \begin{itemize} | + | |
- | \setlength{\itemindent}{.4in} | + | |
- | \item | + | |
- | \textbf{\textit{int getSize()}} = are ca rezultat numarul de noduri din graf; | + | |
- | \item | + | |
- | \textbf{\textit{void addArc(int v, int w, int cost)}} = adauga un arc la graf (intre v si w, avand costul cost); | + | |
- | \item | + | |
- | \textbf{\textit{boolean isArc(int v, int w)}} = verifica daca exista arc intre v si w in graf; | + | |
- | \item | + | |
- | \textbf{\textit{toString()}} = afisarea grafului (se va alege o varianta intuitiva de afisare a grafului); | + | |
- | \item | + | |
- | \textbf{\textit{int[][] floydWarshall()}} = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim in graf; | + | |
- | \item | + | |
- | \textbf{\textit{void main(String[])}} = metoda main pentru testarea functionalitatii clasei implementate. | + | |
- | \end{itemize} | + | |
- | \par | + | |
- | Pentru verificare, se va crea graful din figura de mai jos. Se va afisa graful, uzitand metoda \textbf{\textit{toString}} implementata, si se va determina distanta minima dintre doua noduri folosind algoritmul \textit{Floyd - Warshall}. | + | |
- | \newline | + | |
- | \begin{center} | + | |
- | \begin{tikzpicture} | + | |
- | [scale=.8,auto=left,every node/.style={circle,draw,minimum size=0.8cm,draw=black,line width=0.5mm,fill=arbore}] | + | |
- | \node (n6) at (1,10) {6}; | + | |
- | \node (n4) at (4,8) {4}; | + | |
- | \node (n5) at (8,9) {5}; | + | |
- | \node (n1) at (11,8) {1}; | + | |
- | \node (n2) at (9,6) {2}; | + | |
- | \node (n3) at (5,5) {3}; | + | |
- | \node (n0) at (5, 10) {0}; | + | |
- | \node (n7) at (7, 6.5) {7}; | + | |
- | \foreach \source/ \dest /\weight in {n4/n6/2,n4/n5/3,n5/n1/1,n1/n2/5,n2/n5/7,n2/n3/6,n3/n4/2,n0/n6/15,n0/n4/1,n5/n0/6, n7/n4/2, n7/n5/4} | + | |
- | \path [draw,thick,->,every node/.style={font=\scriptsize}] (\source) -- node {$\weight$} (\dest); | + | |
- | | + | |
- | \end{tikzpicture} | + | Pentru verificare, se va crea graful din figura de mai jos. Se va afișa graful, uzitând metoda **//toString//** implementată, și se va determina distanța minimă dintre două noduri folosind algoritmul **Floyd - Warshall**. |
- | \end{center} | + | Folosiți scheletul de mai jos: |
- | \begin{myexampleblock}{Cod sursa Java} | + | |
- | \begin{lstlisting} | + | {{ :poo:laboratoare:graf.png |}} |
- | public int[][] floydWarshall() { | + | <code java> |
- | int result[][]; | + | class Graph { |
- | result = new int[this.nrVarfuri][this.nrVarfuri]; | + | //.... |
- | int k, i, j; | + | |
- | for(i = 1; i <= this.nrVarfuri; i++) { | + | public int[][] floydWarshall() { |
- | for(j = 1; j <= this.nrVarfuri; j++) { | + | int result[][]; |
- | if(i == j) { | + | result = new int[n+1][n+1]; |
- | result[i][j] = 0; | + | int k, i, j; |
- | } else if(this.isArc(i, j)) { | + | for(i = 1; i <= n; i++) { |
- | result[i][j] = this.matrice[i][j]; | + | for(j = 1; j <= n; j++) { |
- | } else { | + | if(i == j) { |
- | result[i][j] = Infinit; | + | result[i][j] = 0; |
+ | } else if(isArc(i, j)) { | ||
+ | result[i][j] = matrice[i][j]; | ||
+ | } else { | ||
+ | result[i][j] = Infinit; | ||
+ | } | ||
} | } | ||
} | } | ||
- | } | + | for(k = 1; k <= n; k++) { |
- | for(k = 1; k <= this.nrVarfuri; k++) { | + | for(i = 1; i <= n; i++) { |
- | for(i = 1; i <= this.nrVarfuri; i++) { | + | for(j = 1; j <= n; j++) { |
- | for(j = 1; j <= this.nrVarfuri; j++) { | + | int dist; |
- | int dist; | + | dist = result[i][k] + result[k][j]; |
- | dist = result[i][k] + result[k][j]; | + | if(result[i][j] > dist) { |
- | if(result[i][j] > dist) { | + | result[i][j] = dist; |
- | result[i][j] = dist; | + | } |
} | } | ||
} | } | ||
} | } | ||
+ | return result; | ||
+ | } | ||
+ | |||
+ | public static void main(String args[]) { | ||
+ | Graph g = new Graph(4); | ||
+ | g.addArc(1, 3, 2); | ||
+ | g.addArc(1, 2, 3); | ||
+ | g.addArc(2, 4, 6); | ||
+ | g.addArc(2, 3, 2); | ||
+ | System.out.println(g); | ||
+ | System.out.println("Floyd-Warshall"); | ||
+ | int [][] my_matrix = g.floydWarshall(); | ||
+ | System.out.println("distanta minima dintre nodurile 1 si 4 este "+ my_matrix[1][4]); // rezultat - 9 | ||
} | } | ||
- | return result; | ||
} | } | ||
- | \end{lstlisting} | + | </code> |
- | \end{myexampleblock} | + | |
+ | ====Problema 7==== | ||
+ | |||
+ | Să se implementeze ierarhia de clase descrisă prin următoarea diagramă: | ||
+ | |||
+ | {{:poo:laboratoare:clase1.png|}} | ||
+ | |||
+ | Clasa **//Schedule//** conține o metodă care calculează durata călătoriei în minute. Știind algoritmul de calcul al prețului unui bilet de călătorie, să se implementeze o metodă, în clasa **//Train//**, care calculează prețul unui bilet. Valoarea unui bilet este egală cu **//X * durata_călătoriei//**, unde $X$ este egal cu $1$ pentru cursele interne și $2$ pentru cursele internaționale. Clasa **//Route//** va conține un constructor cu $2$ parametri și o metodă care primește ca parametru un obiect de tip **//Route//** și verifică dacă sunt de tip tur - retur cele două rute, rezultatul fiind de tip **//boolean//**. Clasa **//ClockTime//** conține o metodă, cu un parametru de tip **//ClockTime//**, și compară două momente de timp, rezultatul fiind un //**int**//. | ||
+ | |||
+ | Adaugați o metodă //**main**// pentru testarea claselor implementate, utilizând exemplele oferite. Definiți un constructor potrivit pentru instanțierea unui obiect de tip //**Train**//, în care să apelați constructorii definiți în clasele //**Route**//, //**Schedule**// și //**ClockTime**//. | ||
+ | |||
+ | <code> | ||
+ | [local] [origin (departure)] -> [destination (arrival)] | ||
+ | true Bucuresti Nord (9:35) -> Constanta (12:02) | ||
+ | true Bucuresti Nord (5:45) -> Iasi (12:49) | ||
+ | false Bucuresti Nord (23:45) -> Sofia (17:00) | ||
+ | </code> |