Differences
This shows you the differences between two versions of the page.
|
poo:laboratoare:14 [2021/01/24 13:04] carmen.odubasteanu |
poo:laboratoare:14 [2026/01/12 08:32] (current) george.tudor1906 |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ===== Laboratorul 14. ===== | ||
| - | === Problema 1 === | + | ===== Laboratorul 13 – Fluxuri I/O. Funcționale ===== |
| - | Pornind de la diagrama data, implementati clasele si interfetele din diagrama si cele care mai sunt necesare pentru a putea apoi sa construiti un obiect de tip **//IceCream//** ce contine doua toppinguri: **//Chocolate//** si **//Vanilla//**. Afisati pretul si descrierea acestei inghetate (design pattern-ul Decorator) | + | |
| - | In constructorul fiecarui topping, respectiv in constructorul **//BasicIceCream//** se va afisa un mesaj prin care se specifica ce se adauga. | ||
| - | Preturi: basicIceCream 0.5, ciocolata 1.5, vanilie 2. | + | {{:poo:laboratoare:arhiva_13.zip|Arhiva laborator}} |
| - | Descriere metode: | ||
| - | * **getDescription()**: returneaza elementele componente ale inghetatei pana acum(adica lista tuturor componentelor adaugate anterior plus topping-ul curent); | ||
| - | * **getPrice()**: returneaza costul curent al inghetatei(suma tuturor elementelor adaugate anterior + costul toppingului curent). | ||
| - | {{:poo:laboratoare:uml.png?600|}} | + | === Problema 1 === |
| + | Să se scrie un program pentru afișarea pe ecran a liniilor aflate pe poziții impare | ||
| + | dintr-un fișier text. Fiecare linie va fi precedată de numărul ei și un spațiu. | ||
| - | <note important>Pentru a putea adauga functionalitate (in cazul de fata un topping) unui obiect, vom avea nevoie de o referinta catre obiectul respectiv in decorator. | + | În implementare, se va folosi un obiect de tip **LineNumberReader**. |
| - | Un con (obiect de tipul BasicIceCream) fara topping este considerat tot o inghetata!</note> | + | |
| - | <note warning> | + | Cerințe: |
| - | Pentru a putea adauga topping-uri avem nevoie de un con! | + | * Tratați toate excepțiile care ar putea să apară exact acolo unde apar! |
| - | </note> | + | * Atenție la închiderea fișierelor – să se facă chiar dacă apare excepție la citire! |
| - | //**Exemplu output:**// | + | |
| - | <code> | + | Pentru validarea acestei cerințe, puteți folosi fișierul text //test01.in// pus la |
| - | Adding cone | + | dispoziție în arhiva laboratorului. |
| - | Adding choco | + | |
| - | Adding vanilla | + | |
| - | Ingrediente: cone, chocolate, vanilla | + | |
| - | Cost: 4.0 | + | |
| - | </code> | + | |
| === Problema 2 === | === Problema 2 === | ||
| - | Realizați o arhitectură unificată, similară cu Collections, pentru manipularea listelor care să conțină: | ||
| - | * interfața //**Function**//, parametrizată corespunzător, care conține o metodă //**execute**//, având ca parametru un obiect de tip //**A**// și un rezultat de tip //**B**//, unde //**A**// și //**B**// sunt două tipuri formale; | ||
| - | * interfața //**Addition**// folosită pentru a calcula suma a două numere de tip //**T**//, unde //**T**// este un subtip al lui //**Number**// (aceasta va conține o metodă //**zero**// care va întoarce elementul neutru al operației de adunare și o metodă //**add**//, care primește două obiecte de tip //**T**// și returnează suma lor); | ||
| - | * doi algoritmi polimorfici: //**reverse**// care inversează elementele unei liste și //**sum**// care calculează suma elementelor din listă; acești algoritmi trebuie să poată fi folosiți pe implementări diferite de liste, deoarece le abordează la nivel de interfață; | ||
| - | * o serie de metode care au un comportament similar cu funcționalele din paradigma funcțională. În cadrul acestei paradigme, funcțiile sunt valori de ordinul 1 ce pot fi manipulate ca orice altă valoare, iar funcționalele sunt funcții care manipulează alte funcții, primindu-le ca argumente sau returnându-le ca rezultat, în functie de cum e nevoie, fiind foarte utile în aplicarea anumitor modele de calcul des folosite. | ||
| - | Veți porni implementarea de la clasa **//ListUtil//**, pusă la dispoziție în arhiva laboratorului. | + | Să se scrie un program care citește un text de la tastatură și îl salvează într-un |
| + | fișier pe disc. Citirea se va face până la introducerea cuvântului **exit**. | ||
| - | Explicatii pentru functionale: | + | În implementare se va utiliza metoda **readLine()** pentru un obiect de tip |
| + | **DataInputStream** sau **BufferedReader**. | ||
| - | -**foldl**(function, init, list)- returnează rezultatul aplicării functiei function pe rând asupra unui element din listă si a unui acumulator init. Ordinea folosirii elementelor din listă este de la stânga la dreapta; | + | Tratați toate excepțiile care ar putea să apară! |
| - | Exemplu: | + | |
| - | foldl(f(x, y) = x + y, 5, [0, 1, 2, 3]) => 11 | + | |
| - | -**foldr**(function, init, list)- are un comportament similar cu foldl, însă ordinea folosirii elementelor din listă este de la dreapta la stânga; | + | === Problema 3 === |
| - | Exemplu: | + | |
| - | foldr(f(x, y) = y, 4, [0, 1, 2, 3]) => 0 | + | |
| - | -**map**(function, list)- returnează lista rezultatelor aplicării unei functii f asupra fiecărui element dintr-o listă; | + | Să se implementeze un program care citește din fișierul //test02.in// un text și |
| - | Exemplu: | + | determină numărul de cuvinte din text. |
| - | map(f(x) = 2*x,[0, 1, 2, 3]) => [0, 2, 4, 6] | + | |
| - | -**filter**(predicat, list)- returnează lista elementelor dintr-o listă care satisfac un predicat p (un predicat îl vom percepe ca o functie care are un rezultat de tip Boolean); | + | Pentru citire se vor utiliza un obiect de tip **FileReader** și unul de tip **StreamTokenizer**. |
| - | Exemplu: | + | |
| - | filter(f(x) = x % 2 == 0, P[0, 1, 2, 3]) => [0, 2] | + | |
| - | -**reduce**(function, list)- aplică functia pentru primele două elemente din lista, apoi pentru rezultatul obtinut anterior si urmatorul element si tot asa; | + | <code java> |
| - | Exemplu: | + | FileReader in = new FileReader(new File("test02.in")); |
| - | reduce(f(x, y) = x + y, [47, 11, 42, 13]) => 113 | + | StreamTokenizer str = new StreamTokenizer(in); |
| + | </code> | ||
| - | -**all**(predicat, list)- primeste un predicat (metoda ce are ca rezultat un boolean) si verifică dacă toate elementele din listă satisfac predicatul; | + | === Problema 4 – Funcționale === |
| - | Exemplu: | + | |
| - | all(f(x) = x > 0, [0, 1, 2, 3]) => True ; | + | |
| - | all(f(x) = x % 2 == 0, [0, 1, 2, 3]) => False | + | |
| - | -**any**(predicat, list)- primeste un predicat si verifică dacă exista cel putin un element în lista care satisface predicatul. | + | Realizați o arhitectură unificată, similară cu Collections, pentru manipularea listelor |
| - | Exemplu: | + | care să conțină: |
| - | any(f(x) = x < 0,[1, 2, 3, 4]) => False ; | + | |
| - | any(f(x) = x % 2 == 0,[1, 2, 3]) => True | + | |
| - | Pentru testare, completati exemplele din clasa Test. | + | * Interfața **Function**, parametrizată corespunzător, care conține o metodă **execute**, având ca parametru un obiect de tip **A** și un rezultat de tip **B**, unde **A** și **B** sunt două tipuri formale; |
| + | |||
| + | * Interfața **Addition** folosită pentru a calcula suma a două numere de tip **T**, unde **T** este un subtip al lui **Number** (aceasta va conține o metodă **zero** care va întoarce elementul neutru al operației de adunare și o metodă **add**, care primește două obiecte de tip **T** și returnează suma lor); | ||
| + | |||
| + | * Doi algoritmi polimorfici: **reverse** care inversează elementele unei liste și **sum** care calculează suma elementelor din listă; acești algoritmi trebuie să poată fi folosiți pe implementări diferite de liste, deoarece le abordează la nivel de interfață; | ||
| + | |||
| + | * O serie de metode care au un comportament similar cu funcționalele din paradigma funcțională. | ||
| + | |||
| + | Veți porni implementarea de la clasa **ListUtil**, pusă la dispoziție în arhiva laboratorului. | ||
| <hidden> | <hidden> | ||
| Line 78: | Line 63: | ||
| </hidden> | </hidden> | ||
| - | === Problema 3 === | ||
| - | Sa se scrie un program pentru afisarea pe ecran a liniilor aflate pe pozitii impare dintr-un fisier text. Fiecare linie va fi precedata de numarul ei si un spatiu. In implementare, se va folosi un obiect de tip //**LineNumberReader**//. Tratati toate exceptiile care ar putea sa apara exact acolo unde apar! Atentie la inchiderea fisierelor – sa se faca chiar daca apare exceptie la citire! | ||
| - | |||
| - | Pentru validarea acestei cerinte, puteti folosi fisierul text //test01.in// pus la dispozitie in arhiva laboratorului. | ||
| - | |||
| - | === Problema 4 === | ||
| - | Sa se scrie un program care citeste un text de la tastura si il salveaza intr-un fisier pe disc. Citirea se va face pana la introducerea cuvantului //**exit**//. In implementare se va uzita metoda //**readLine()**// pentru un obiect de tip //**DataInputStream**// sau //**BufferedReader**//. Tratati toate exceptiile care ar putea sa apara! | ||
| - | |||
| - | === Problema 5 === | ||
| - | Sa se implementeze un program care citeste din fisierul //test02.in// un text si determina numarul de cuvinte din text. Pentru citire se vor utiliza un obiect de tip //**FileReader**// si unul de tip //**StreamTokenizer**//. | ||
| - | <code java> | ||
| - | FileReader in = new FileReader(new File("test02.in")); | ||
| - | StreamTokenizer str = new StreamTokenizer(in); | ||
| - | </code> | ||
| - | |||
| - | {{:poo:laboratoare:arhiva_13.zip|Arhiva laborator}} | ||
