Differences
This shows you the differences between two versions of the page.
|
poo:laboratoare:01 [2025/10/05 18:52] george.tudor1906 [Problema 1] |
poo:laboratoare:01 [2025/10/05 22:04] (current) carmen.odubasteanu [Problema 8] |
||
|---|---|---|---|
| Line 10: | Line 10: | ||
| Creați un proiect Java nou, apoi creați un fișier sursă simplu numit **Prob1.java**. | Creați un proiect Java nou, apoi creați un fișier sursă simplu numit **Prob1.java**. | ||
| - | **1.** În acest fișier scrieți o clasă numită **Test** care conține metoda **//main//** și afișează în consolă mesajul "//Test Java//". Rulați programul și verificați apariția mesajului în fereastra Run | + | **1.** În acest fișier scrieți o clasă numită **Test** care conține metoda ''main'' și afișează în consolă mesajul "//Test Java//". Rulați programul și verificați apariția mesajului în fereastra Run. |
| <code java> | <code java> | ||
| Line 20: | Line 20: | ||
| </code> | </code> | ||
| - | **2.** Adăugați modificatorul **//public//** în fața declarației clasei Test și încercați din nou să rulați. Observați eroarea raportată de IDE și apoi rezolvați-o făcând ca numele fișierului și numele clasei publice să coincidă. Puteți alege fie să redenumiți fișierul în Test.java, fie să redenumiți clasa în Prob1. Recompilați și rulați din nou pentru a confirma că problema este rezolvată și că mesajul este afișat corect. | + | **2.** Adăugați modificatorul ''public'' în fața declarației clasei Test și încercați din nou să rulați. Observați eroarea raportată de IDE și apoi rezolvați-o făcând ca numele fișierului și numele clasei publice să coincidă. Puteți alege fie să redenumiți fișierul în Test.java, fie să redenumiți clasa în Prob1. Recompilați și rulați din nou pentru a confirma că problema este rezolvată și că mesajul este afișat corect. |
| Line 31: | Line 31: | ||
| ====Problema 2==== | ====Problema 2==== | ||
| - | Să se scrie o clasă **//Problema2//** care conţine două metode (funcţii): | + | Scrieți un program în fișierul **Prob2.java** care definește o clasă **Prob2** și o //**__metodă nestatică__**// numită ''printInt'', ce primește un număr întreg și îl afișează la consolă. În metoda ''main'', creați **un obiect** al clasei Prob2 (adică **o instanță** a clasei) și apelați metoda nestatică ''printInt'' de mai multe ori, folosind valori constante (de pildă 42, 7 + 5, 3 * 10). |
| - | * metoda **//print//** __nestatica__ care primește un argument de tip ''String'' pe care-l afișează; | + | |
| - | * metoda **//main//** care apelează funcția **//print()//** pentru afișarea unui șir constant. | + | |
| <note warning> | <note warning> | ||
| <color #FF0000>**IMPORTANT!**</color> | <color #FF0000>**IMPORTANT!**</color> | ||
| - | Metoda print se va apela în **//main//** astfel: | + | Metoda printInt se va apela în **//main//** astfel: |
| <code java> | <code java> | ||
| - | Problema2 obiect = new Problema2(); // creare obiect de tip Problema2 | + | Prob2 obiect = new Prob2(); // creare obiect de tip Prob2 |
| - | obiect.print("Test"); //apelare metoda print | + | obiect.printInt(42); //apelare metoda printInt |
| + | obiect.printInt(7 + 5); | ||
| + | obiect.printInt(3 * 10); | ||
| </code> | </code> | ||
| </note> | </note> | ||
| Line 51: | Line 51: | ||
| ====Problema 3==== | ====Problema 3==== | ||
| - | - Să se modifice clasa scrisă la exerciţiul anterior prin definirea a două clase, fiecare conţinând câte o metodă: | + | Creați un fișier numit **Prob3.java** în care scrieți două clase: |
| - | * o clasă pentru metoda **//main//**; | + | * ''public class Prob3'', care conține metoda ''main'' |
| - | * o clasă pentru metoda **//print//**. | + | * ''class Printer'', în care definiți o __//**metodă nestatică**//__ ''printInt(int x)'' care afișează valoarea primită ca parametru. |
| - | * Să se verifice dacă ambele clase din fișier pot fi publice. Apelul metodei **//print//** se va realiza în acelaşi mod ca la problema 2! | + | |
| - | - Să se modifice programul anterior prin crearea a două fişiere sursă, fiecare conţinând cate una din clasele de mai sus. Incercati să executați ambele clase. | + | În ''main'' apelați metoda ''printInt'' folosind o instanță a clasei Printer, ca în exemplul de la problema precedentă. |
| + | |||
| + | Acum adăugați modificatorul ''public'' și la clasa Printer, încercați să compilați și observați eroarea. Pentru a corecta, păstrați o singură clasă publică pe fișier: lăsați Prob3 publică în Prob3.java și mutați Printer într-un fișier separat numit **Printer.java**, unde o puteți declara public. Compilați din nou și rulați Prob3. | ||
| + | |||
| + | Opțional, adăugați și în Printer o metodă ''main'' minimală care apelează ''printInt'', apoi rulați-o separat pentru a confirma că ambele clase se pot executa independent când au propriul fișier. | ||
| <note important> | <note important> | ||
| Line 65: | Line 70: | ||
| ====Problema 4==== | ====Problema 4==== | ||
| - | Să se scrie un program pentru afișarea tuturor argumentelor primite în linia de comandă. | + | Scrieți un program în fișierul **Prob4.java** care afișează toate argumentele primite în linia de comandă. |
| + | |||
| + | În metoda ''main'', parcurgeți vectorul ''args'' și afișați, pentru fiecare element, indicele și valoarea lui, pe câte o linie separată. Dacă programul este rulat fără argumente, afișați un mesaj clar, de tipul "Nu s-au primit argumente.". | ||
| + | |||
| + | Pentru testare, rulați programul de mai multe ori: fără argumente, cu un singur argument și apoi cu mai multe (ex.: Ana are mere). Observați cum se modifică lungimea vectorului args și ordinea elementelor afișate. | ||
| <note tip> | <note tip> | ||
| Line 71: | Line 80: | ||
| Argumentele se pot transmite astfel: | Argumentele se pot transmite astfel: | ||
| - | * daca programul se ruleaza dintr-un IDE, se vor urma instructiunile de la începutul laboratorului; | + | * dacă programul se rulează dintr-un IDE, se vor urma instrucțiunile de la începutul laboratorului; |
| - | * daca programul se ruleaza din linia de comandă: ''java numeprogram arg1 arg2 arg3'' | + | * dacăprogramul se rulează din linia de comandă: ''java numeprogram arg1 arg2 arg3'' |
| </note> | </note> | ||
| ====Problema 5==== | ====Problema 5==== | ||
| - | Să se realizeze o clasă care cuprinde o metodă recursivă (nestatica) care calculează puterea întreagă a unui numar întreg și o metodă pentru afișarea rezultatului funcției, alături de rezultatul funcției statice ''Math.pow(baza, exp)'' pentru a se putea valida. Clasa va conține un **//main//** în care se vor testa cele două metode definite anterior. | + | Scrieți în fișierul **Prob5.java** o clasă **Prob5** care conține o __//**metodă nestatică**//__ ''powInt(int baza, int exp)'' ce calculează recursiv puterea întreagă pentru exponenți pozitivi. În ''main'' alegeți câteva perechi constante de valori pentru bază și exponent (de exemplu 3^4, 2^10, 5^0), apelați metoda voastră și afișați rezultatul în consolă. |
| - | <note important> | + | Pentru validare, afișați alături rezultatul returnat de ''Math.pow(baza, exp)''. Comparati rezultatele si afisati rezultatul comparatiei, afisand mesajul "egale" sau "diferite". Păstrați bazele și exponenții suficient de mici încât rezultatul să nu depășească limitele tipului întreg pe care îl folosiți; dacă apare un rezultat "ciudat", cel mai probabil s-a produs **overflow**. |
| - | <color red>**IMPORTANT!**</color> | + | |
| - | O **//metodă statică//** a unei clase se apelează prin: | ||
| - | ''NumeClasă.numeMetodăStatică(...)'' | ||
| - | ''Math.pow(...);'' | ||
| - | </note> | ||
| + | ====Problema 6==== | ||
| + | În fișierul **Prob6.java** scrieți o clasă **Prob6** care conține o __//**metodă nestatică**//__ ''isPrime(int n)'' ce întoarce true dacă n este număr prim și false în caz contrar. | ||
| + | În metoda ''main'' parcurgeți toate numerele întregi de la 1 la 20 și afișați pentru fiecare un mesaj clar, de forma "n prim" sau "n nu e prim". | ||
| - | ====Problema 6==== | + | **Considerați numărul 1 ca fiind număr prim.** |
| - | Să se implementeze o clasă cu două metode: | + | |
| - | * o metodă (nestatica) de tip ''boolean'' care verifică dacă un număr întreg dat este prim; | + | |
| - | * metoda ''main'' care verifică metoda anterioară pentru toate numerele naturale mai mici ca $20$. | + | |
| ====Problema 7==== | ====Problema 7==== | ||
| - | Să se scrie un program pentru verificarea ipotezei lui Goldbach pentru primele n numere pare, prin afișarea tuturor sumelor de două numere prime prin care poate fi exprimat un număr par. Variabila n poate fi inițializată cu o valoare constantă. | + | **Ipoteza lui Goldbach** spune că orice număr par se poate scrie ca sumă a două numere prime. |
| - | **Ipoteza lui Goldbach:** orice nr par poate fi descompus ca sumă de cel puțin o pereche de două numere prime. Se consideră $1$ ca fiind număr prim. | + | Exemple: 4 = 2 + 2, 6 = 3 + 3, 8 = 3 + 5, 10 = 3 + 7 sau 5 + 5. |
| - | Pentru afișarea unei expresii de forma ''a = b + c'' se va scrie: | + | Scrieți în fișierul **Prob7.java** un program care verifică ipoteza lui Goldbach pentru primele n numere pare. Refolosiți funcția ''isPrime(int)'' din **problema anterioară**. |
| + | |||
| + | Pentru fiecare număr par p, afișați exact forma p = a + b (o singură dată fiecare pereche, fără simetrice repetate). | ||
| + | |||
| + | Considerați numărul 1 prim și mențineți n (valoare constantă în cod) suficient de mic pentru a verifica rapid. | ||
| + | |||
| + | <note tip> | ||
| + | <color green>**Observație**</color> | ||
| + | |||
| + | Pentru afișarea unei expresii de forma ''p = a + b'' se va scrie: | ||
| <code java> | <code java> | ||
| - | System.out.println(a + " = " + b + " + " + c); | + | System.out.println(p + " = " + a + " + " + b); |
| </code> | </code> | ||
| - | unde ''a'', ''b'', ''c'' sunt variabile numerice de orice tip (''short'', ''int'', ''long'', ''float'', ''double''). | + | unde ''p'', ''a'', ''b'' sunt variabile numerice de orice tip (''short'', ''int'', ''long'', ''float'', ''double''). |
| + | </note> | ||
| + | |||
| ====Problema 8==== | ====Problema 8==== | ||
| - | Să se scrie un program pentru ordonarea unui vector de numere și căutarea binară în acest vector, folosind metodele statice **//sort()//** și **//binarySearch()//** din clasa **//Arrays//**. Vectorul va conține numere generate aleator folosind metoda statică **//random()//** din clasa //**Math**//, cu rezultat de tip //**double**//. | + | În acest exercițiu veți lucra cu vectori și cu două metode utile din clasa **Arrays**: ''Arrays.sort'' pentru ordonare și ''Arrays.binarySearch'' pentru căutare rapidă într-un tablou deja sortat. Ideea este simplă: mai întâi puneți elementele într-un tablou, le ordonați crescător, apoi căutați o cheie și interpretați poziția returnată de funcția de căutare. |
| + | |||
| + | Creați fișierul **Prob8.java** și, în metoda ''main'', **creați** un tablou de ''int'' de dimensiune fixă (de exemplu n = 12). **Populați-l** cu valori pseudo-aleatoare într-un interval mic. **Afișați** conținutul inițial al tabloului, apoi **apelați** ''java.util.Arrays.sort(tab)'' pentru a-l ordona și **afișați** din nou rezultatul, ca să se vadă efectul sortării. | ||
| + | |||
| + | După sortare, **alegeți** o cheie pentru test. Cel mai comod este să alegeți o valoare despre care știți sigur că există în tablou, de exemplu elementul din mijloc după sortare; în felul acesta ''Arrays.binarySearch(tab, cheie)'' vă va întoarce un indice valid (>= 0), iar apoi veți **afișa** un mesaj clar care indică poziția găsită. **Testați** apoi și un caz în care cheia nu există (de exemplu o valoare mai mare decât toate elementele din tablou) și **observați** ce returnează funcția. | ||
| + | |||
| + | |||
| + | <note tip> | ||
| + | <color green>**Observație**</color> | ||
| + | |||
| + | Metoda ''Math.random()'' întoarce un ''double'' în intervalul **[0.0, 1.0)**, adică poate fi 0.0, dar este întotdeauna mai mic decât 1.0. Pentru a obține un întreg într-un interval dorit, **înmulțiți rezultatul cu lățimea intervalului** și apoi **faceți conversia la int**. | ||
| + | |||
| + | De exemplu, valori întregi între 0 și 99 generați astfel: | ||
| + | <code java> | ||
| + | int x = (int) (Math.random() * 100); // 0..99 | ||
| + | </code> | ||
| + | |||
| + | Observați ordinea: mai întâi se înmulțește, abia apoi se face conversia la int. Dacă ați scrie ''(int) Math.random() * 100'', conversia s-ar face înainte (rezultând mereu 0) și ați obține doar 0. | ||
| + | |||
| + | Dacă vreți un interval general [min, max] inclusiv, folosiți formula: | ||
| + | <code java> | ||
| + | int min = 10, max = 20; | ||
| + | int y = min + (int) (Math.random() * (max - min + 1)); // 10..20 | ||
| + | </code> | ||
| + | |||
| + | </note> | ||
| + | |||
| + | |||
| + | |||
| + | |||
