Differences
This shows you the differences between two versions of the page.
|
poo:laboratoare:01 [2017/12/22 12:53] mihai.nan |
poo:laboratoare:01 [2025/10/05 22:04] (current) carmen.odubasteanu [Problema 8] |
||
|---|---|---|---|
| Line 8: | Line 8: | ||
| ====Problema 1==== | ====Problema 1==== | ||
| - | Să se introducă programul de mai jos (clasa **//Test//**) într-un fișier cu numele ''Prob1.java'', folosind mediul integrat NetBeans / Eclipse. | + | Creați un proiect Java nou, apoi creați un fișier sursă simplu numit **Prob1.java**. |
| - | 1. Să se compileze și să se ruleze următorul program: | + | |
| + | **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> | ||
| class Test { | class Test { | ||
| Line 17: | Line 19: | ||
| } | } | ||
| </code> | </code> | ||
| - | Adăugați atributul **//public//** înaintea cuvântului cheie **//class//**, recompilați și executați programul. Rezolvați problema apărută! | + | |
| + | **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 28: | 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()//** 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 48: | 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. |
| - | - as | + | |
| + | Î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. | ||
| - | 1. | ||
| - | \begin{itemize} | ||
| - | \item | ||
| - | o clasă pentru metoda \textbf{main()}; | ||
| - | \item | ||
| - | o clasă pentru metoda \textbf{print()}. | ||
| - | \end{itemize} | ||
| - | \par | ||
| - | \noindent | ||
| - | Să se verifice dacă ambele clase din fi\c{s}ier pot fi publice. | ||
| - | \par | ||
| - | \noindent | ||
| - | Apelul metodei \textbf{print} se va realiza în acelaşi mod ca la problema 2! | ||
| - | \newline | ||
| - | \warning{IMPORTANT !} | ||
| - | \begin{Warning} | ||
| - | Într-un fi\c{s}ier \textbf{\textit{nu}} pot fi definite două \textbf{\textit{clase publice}}. | ||
| - | \end{Warning} | ||
| - | \par | ||
| - | \setlength{\parindent}{7ex} | ||
| - | 2. Să se modifice programul anterior prin crearea a două fişiere sursă, fiecare conţinând o clasă cu câte o singură metodă. Incercati să executa\c{t}i ambele clase. | ||
| - | \noindent | ||
| - | \newline | ||
| - | \newline | ||
| - | \warning{IMPORTANT !} | ||
| - | \begin{Warning} | ||
| - | O \textbf{\textit{clasă executabilă}} este o clasă care con\c{t}ine obligatoriu \textbf{\textit{metoda main}}. | ||
| - | \end{Warning} | ||
| - | \noindent | + | <note important> |
| - | \chapter{\textbf{Problema 4}} | + | <color red>**IMPORTANT!**</color> |
| - | \par | + | |
| - | \setlength{\parindent}{7ex} | + | Într-un fișier **NU** pot fi definite două **clase publice**. |
| - | Să se scrie un program pentru afi\c{s}area tuturor argumentelor primite în linia de comandă. | + | </note> |
| - | \begin{myblock}{Observatie} | + | |
| + | |||
| + | ====Problema 4==== | ||
| + | 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> | ||
| + | <color green>**Observație**</color> | ||
| Argumentele se pot transmite astfel: | Argumentele se pot transmite astfel: | ||
| - | \begin{itemize} | + | * dacă programul se rulează dintr-un IDE, se vor urma instrucțiunile de la începutul laboratorului; |
| - | \item | + | * dacăprogramul se rulează din linia de comandă: ''java numeprogram arg1 arg2 arg3'' |
| - | daca programul se ruleaza din NetBeans / Eclipse se vor urma instructiunile de la începutul laboratorului; | + | </note> |
| - | \item | + | |
| - | daca programul se ruleaza din linia de comandă: | + | |
| - | \setlength{\parindent}{14ex} | + | |
| - | \par | + | |
| - | \textbf{\textit{java numeprogram arg1 arg2 arg3}} | + | |
| - | \end{itemize} | + | |
| - | \end{myblock} | + | |
| - | \noindent | ||
| - | \chapter{\textbf{Problema 5}} | ||
| - | \par | ||
| - | Să se realizeze o clasă care cuprinde o metodă recursivă care calculează puterea întreagă a unui numar întreg \c{s}i o metodă pentru afi\c{s}area rezultatului func\c{t}iei, alături de rezultatul func\c{t}iei statice \textbf{\textit{Math.pow(baza, exp)}} pentru a se putea valida. Clasa va con\c{t}ine un \textbf{main} în care se vor testa cele două metode definite anterior. | ||
| - | \warning{IMPORTANT !} | + | ====Problema 5==== |
| - | \begin{Warning} | + | 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ă. |
| - | \noindent | + | |
| - | O \textbf{\textit{metodă statică}} a unei clase se apelează prin: | + | |
| - | \setlength{\parindent}{17ex} | + | |
| - | \par\color{Blue}\textbf{NumeClasă.numeMetodăStatică(...)} | + | |
| - | \newline | + | |
| - | Ex: \texttt{Math.pow(...);} | + | |
| - | \end{Warning} | + | |
| + | 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**. | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ====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". | ||
| + | |||
| + | **Considerați numărul 1 ca fiind număr prim.** | ||
| + | |||
| + | |||
| + | ====Problema 7==== | ||
| + | **Ipoteza lui Goldbach** spune că orice număr par se poate scrie ca sumă a două numere prime. | ||
| + | |||
| + | Exemple: 4 = 2 + 2, 6 = 3 + 3, 8 = 3 + 5, 10 = 3 + 7 sau 5 + 5. | ||
| + | |||
| + | 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> | ||
| + | System.out.println(p + " = " + a + " + " + b); | ||
| + | </code> | ||
| + | unde ''p'', ''a'', ''b'' sunt variabile numerice de orice tip (''short'', ''int'', ''long'', ''float'', ''double''). | ||
| + | </note> | ||
| + | |||
| + | |||
| + | |||
| + | ====Problema 8==== | ||
| + | Î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> | ||
| - | \vspace{0.2cm} | ||
| - | \noindent | ||
| - | \chapter{\textbf{Problema 6}} | ||
| - | \par | ||
| - | Să se implementeze o clasă cu două metode: | ||
| - | \begin{itemize} | ||
| - | \item | ||
| - | o metodă de tip \textbf{\textit{boolean}} care verifică dacă un număr întreg dat este prim; | ||
| - | \item | ||
| - | metoda \textbf{\textit{main()}} care verifică metoda anterioară pentru toate numerele naturale mai mici ca 20. | ||
| - | \end{itemize} | ||
| - | \noindent | ||
| - | \chapter{\textbf{Problema 7}} | ||
| - | \par | ||
| - | Să se scrie un program pentru verificarea ipotezei lui Goldbach pentru primele \textbf{n} numere pare, prin afi\c{s}area tuturor sumelor de două numere prime prin care poate fi exprimat un număr par. Variabila \textbf{n} poate fi ini\c{t}ializată cu o valoare constantă. | ||
| - | \par | ||
| - | \textbf{Ipoteza lui Goldbach:} orice nr par poate fi descompus ca sumă de cel pu\c{t}in o pereche de două numere prime. Se consideră $1$ ca fiind număr prim. | ||
| - | \begin{myexampleblock}{Cod sursă Java} | ||
| - | \par | ||
| - | Pentru afi\c{s}area unei expresii de forma \textbf{\textit{a = b + c}} se va scrie: | ||
| - | \begin{lstlisting} | ||
| - | System.out.println(a + " = " + b + " + " + c); | ||
| - | \end{lstlisting} | ||
| - | unde \textbf{\textit{a}}, \textbf{\textit{b}}, \textbf{\textit{c}} sunt variabile numerice de orice tip (\textbf{\textit{short}}, \textbf{\textit{int}}, \textbf{\textit{long}}, \textbf{\textit{float}}, \textbf{\textit{doube}}). | ||
| - | \end{myexampleblock} | ||
| - | \noindent | ||
| - | \chapter{\textbf{Problema 8}} | ||
| - | \par | ||
| - | Să se scrie un program pentru ordonarea unui vector de numere \c{s}i căutarea binară în acest vector, folosind metodele statice \textbf{\textit{sort()}} si \textbf{\textit{binarySearch()}} din clasa \textbf{\textit{Arrays}}. Vectorul va con\c{t}ine numere generate aleator folosind metoda statică \textbf{\textit{random()}} din clasa \textbf{\textit{Math}}, cu rezultat de tip \textbf{\textit{double}}. | ||
