This shows you the differences between two versions of the page.
poo:laboratoare:03 [2018/10/08 14:53] carmen.odubasteanu [Problema 3] |
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 produs este caracterizat prin nume (**//String//**), preț (//**double**//) și cantitate (**//int//**). |
- | Un magazin are un nume (//**String**//) si contine 3 produse. | + | Un magazin are un nume (//**String**//) și conține 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. | + | 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**// 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 va returna String-ul corespondent tuturor componentelor magazinului si o metoda //**getTotalMagazin**// care va calcula suma totalurilor produselor si o va returna. | + | 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. |
- | Creati, intr-o metoda //**main**//, un obiect de tip //**Magazin**//, uzitand obiecte anonime in cadrul instantierii. | + | Creați, într-o metodă //**main**//, un obiect de tip //**Magazin**//, uzitând obiecte anonime în cadrul instanțierii. |
<note tip> | <note tip> | ||
Line 30: | 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()//** = String cu elementele din structura de date. | * **//String toString()//** = String cu elementele din structura de date. | ||
Line 110: | Line 110: | ||
====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 126: | 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|}} | + | |
- | + | ||
- | 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**//. | + | |
- | + | ||
- | 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> | + | |
- | [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> | + | |
- | + | ||
- | ====Problema 6==== | + | |
- | Implementati clasa **//Punct//** care defineste un punct din spatiul 2D. | + | |
**Datele clasei (private):** | **Datele clasei (private):** | ||
- | * doua nr. intregi reprezentand cele doua coordonate ale punctului. | + | * două nr. întregi reprezentând cele două coordonate ale punctului. |
**Conctructorul clasei:** | **Conctructorul clasei:** | ||
- | * un constructor fara parametri care instantiaza punctul ''O(0, 0)''. | + | * un constructor fără parametri care instanțiază punctul ''O(0, 0)''. |
**Metodele clasei:** | **Metodele clasei:** | ||
- | * ''int getX()'' = intoarce abscisa punctului; | + | * ''int getX()'' = întoarce abscisa punctului; |
* ''void setX(int x)'' = seteaza abscisa punctului; | * ''void setX(int x)'' = seteaza abscisa punctului; | ||
- | * ''int getY()'' = intoarce ordonata punctului; | + | * ''int getY()'' = întoarce ordonata punctului; |
- | * ''void setY(int y)'' = seteaza ordonata punctului; | + | * ''void setY(int y)'' = setează ordonata punctului; |
- | * ''String toString()'' = returneaza un String de forma \textit{(x, y)}; | + | * ''String toString()'' = returnează un String de forma ''(x, y)''; |
- | * ''double distance(int, int)'' = calculeaza distanta dintre 2 puncte; | + | * ''double distance(int, int)'' = calculează distanța dintre 2 puncte; |
- | * ''double distance(Punct p1)'' = calculeaza distanta dintre 2 puncte. | + | * ''double distance(Punct p1)'' = calculează distanța dintre 2 puncte. |
- | Creati o clasa **//Test//**, in acelasi pachet cu clasa **//Punct//**, care contine o metoda **//main//** care calculeaza distanta dintre punctele ''A(1, 2)'' si ''B(-1, 3)''. | + | 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)''. |
- | Puteti accesa datele clasei //**Punct**// in metoda //**main**// din clasa //**Test**//? | + | Puteți accesa datele clasei //**Punct**// în metoda //**main**// din clasa //**Test**//? |
- | ====Problema 7==== | + | ====Problema 6==== |
- | + | Să se definească o clasă **//Graph//** care să descrie un graf ponderat orientat care are nodurile numerotate de la $1$. | |
- | Sa se defineasca o clasa **//Graph//** care sa descrie un graf ponderat orientat care are nodurile numerotate de la 1. | + | |
**Datele clasei (private):** | **Datele clasei (private):** | ||
* o matrice cu componente de tip int (matricea costurilor) - matrice; | * o matrice cu componente de tip int (matricea costurilor) - matrice; | ||
- | * o constanta (**//Infinit//**) avand valoarea 9500; | + | * o constantă (**//Infinit//**) având valoarea 9500; |
- | * numarul de noduri - n . | + | * numărul de noduri - n . |
**Constructorul clasei:** | **Constructorul clasei:** | ||
- | * constructor cu un parametru intreg (numarul de noduri din graf) | + | * constructor cu un parametru întreg (numărul de noduri din graf) |
**Metodele clasei:** | **Metodele clasei:** | ||
- | * ''int getSize()'' = are ca rezultat numarul de noduri din graf; | + | * ''int getSize()'' = are ca rezultat numărul de noduri din graf; |
- | * ''void addArc(int v, int w, int cost)'' = adauga un arc la graf (intre v si w, avand costul cost); | + | * ''void addArc(int v, int w, int cost)'' = adaugă un arc la graf (între $v$ și $w$, având costul $cost$); |
- | * ''boolean isArc(int v, int w)'' = verifica daca exista arc intre v si w in graf; | + | * ''boolean isArc(int v, int w)'' = verifică dacă există arc între $v$ și $w$ în graf; |
- | * ''toString()'' = afisarea grafului (se va alege o varianta intuitiva de afisare a grafului); | + | * ''toString()'' = afișarea grafului (se va alege o variantă intuitivă de afișare a grafului); |
- | * ''int[][] floydWarshall()'' = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim in graf; | + | * ''int[][] floydWarshall()'' = implementarea algoritmului \textit{Floyd - Warshall} pentru determinarea drumurilor de cost minim în graf; |
- | * ''void main(String[])'' = metoda main pentru testarea functionalitatii clasei implementate. | + | * ''void main(String[])'' = metoda main pentru testarea functionalității clasei implementate. |
- | + | ||
- | Pentru verificare, se va crea graful din figura de mai jos. Se va afisa graful, uzitand metoda **//toString//** implementata, si se va determina distanta minima dintre doua noduri folosind algoritmul **Floyd - Warshall**. | + | |
- | Folositi scheletul de mai jos: | + | |
+ | 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**. | ||
+ | Folosiți scheletul de mai jos: | ||
+ | {{ :poo:laboratoare:graf.png |}} | ||
<code java> | <code java> | ||
class Graph { | class Graph { | ||
- | .... | + | //.... |
public int[][] floydWarshall() { | public int[][] floydWarshall() { | ||
- | int result[][]; | + | int result[][]; |
- | result = new int[n+1][n+1]; | + | result = new int[n+1][n+1]; |
- | int k, i, j; | + | int k, i, j; |
- | for(i = 1; i <= n; i++) { | + | |
- | for(j = 1; j <= n; j++) { | + | |
- | if(i == j) { | + | |
- | 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(i = 1; i <= n; i++) { | for(i = 1; i <= n; i++) { | ||
for(j = 1; j <= n; j++) { | for(j = 1; j <= n; j++) { | ||
- | int dist; | + | if(i == j) { |
- | dist = result[i][k] + result[k][j]; | + | result[i][j] = 0; |
- | if(result[i][j] > dist) { | + | } else if(isArc(i, j)) { |
- | result[i][j] = dist; | + | result[i][j] = matrice[i][j]; |
+ | } else { | ||
+ | result[i][j] = Infinit; | ||
} | } | ||
} | } | ||
} | } | ||
+ | for(k = 1; k <= n; k++) { | ||
+ | for(i = 1; i <= n; i++) { | ||
+ | for(j = 1; j <= n; j++) { | ||
+ | int dist; | ||
+ | dist = result[i][k] + result[k][j]; | ||
+ | if(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; | ||
- | } | ||
- | 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 | ||
- | |||
- | } | ||
} | } | ||
+ | </code> | ||
+ | |||
+ | ====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> | </code> |