Show page
Recent changes

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

poo:laboratoare:09 [2025/11/30 16:52]
george.tudor1906 		poo:laboratoare:09 [2025/11/30 17:22] (current)
george.tudor1906
Line 1: Line 1:
-====== ​Breviar ​9 ======+====== ​Laborator ​9 ====== 
 +{{:​poo:​laboratoare:​arhiva_laborator_-_swing_1.zip|Arhiva laborator}}
  
-=== Interfețe grafice (GUI) ===+=== Problema 1 ===
  
-=== 1. Introducere ===+Să se realizeze un program care afișează patru câmpuri text și un buton. În primele trei câmpuri text, utilizatorul introduce numele discului suport (A:, C:, D:), calea (secvența de directoare) și numele unui fișier. La apăsarea pe buton se va afișa, în cel de-al patrulea câmp text, calea completă la fișier.
  
-== 1.1 Contextul interfețelor grafice ==+În implementare,​ se vor scrie următoarele două variante:
  
-În cazul programelor pe care le-am făcut până acum, toate mesajele și răspunsurile apăreau ca linii de text sugestive, ecranul fiind folosit în mod text. +  * Se înregistrează trei obiecte ascultător (**ActionListener**) câte unul pentru fiecare ​**JTextField**, care transferă textul din fiecare câmp text în cel destinat rezultatului. 
- +  * Se înregistrează un singur obiect ascultător la **JButton**, care va compune datele din primele 3 câmpuri ​și le va afișa în cel destinat rezultatului.
-Un astfel de stil de comunicare nu este atractiv pentru utilizatori,​ motiv pentru care se preferă dialogul prin **interfețe grafice** sau **GUI** (//​Graphical User Interface//​), ecranul fiind folosit în mod grafic. +
- +
-<note important>​ +
-În trecerea de la o versiune la alta, bibliotecile de clase care oferă servicii grafice au suferit, probabil, cele mai mari schimbări. Acest lucru se datorează, pe de o parte, dificultății legate de implementarea noțiunii de portabilitate,​ iar pe de altă parte nevoii de a integra mecanismele GUI cu tehnologii apărute și dezvoltate ulterior. +
-</​note>​ +
- +
-== 1.2 Modalități de creare a interfețelor grafice == +
- +
-În momentul actual, există două modalități de a crea o aplicație cu interfață grafică: +
- +
-  * **AWT (Abstract Windowing Toolkit)** - este API-ul inițial pus la dispoziție începând cu primele versiuni de Java; +
-  ​* **Swing** - este parte dintr-un proiect mai amplu numit **JFC (Java Foundation Classes)** creat în urma colaborării dintre Sun, Netscape ​și IBM, care se bazează pe modelul AWT, extinzând funcționalitatea acestuia ​și adăugând sau înlocuind unele componente pentru dezvoltarea aplicațiilor GUI.+
  
 <note tip> <note tip>
-Este preferabil ca aplicațiile Java să fie create folosind tehnologia ​**Swing**, deoarece aceasta pune la dispoziție o paletă mult mai largă de facilități,​ însă nu se va renunța complet ​la AWT, deoarece aici există clase esențiale, reutilizate în Swing.+Trecerea de la un câmp text la altul se va putea face și cu tasta Tab. Însă evenimentul de tip **ActionEvent** pentru un **JTextField** se generează ​la apăsarea lui Enter!
 </​note>​ </​note>​
  
-=== 2. Pachetul Swing === +=== Problema ​2 ===
- +
-== 2.1 Caracteristici == +
- +
-Componentele **Swing**, spre deosebire de predecesoarele din versiunile Java anterioare, sunt implementate în întregime în Java. Aceasta are ca rezultat o mai bună compatibilitate cu platforme diferite decât în cazul folosirii componentelor AWT. +
- +
-Unul din principalele deziderate ale tehnologiei Swing a fost să pună la dispoziție un set de componente GUI extensibile care să permită dezvoltarea rapidă de aplicații Java cu interfață grafică competitivă,​ din punct de vedere comercial. +
- +
-Cel mai important pachet, care conține componentele de bază este **javax.swing**. +
- +
-== 2.2 Elementele unei interfețe utilizator == +
- +
-Orice interfață utilizator Java este compusă din următoarele elemente: +
- +
-  * **Componente** - orice poate fi plasat pe o interfață utilizator, cum ar fi butoane, liste de derulare, meniuri pop-up, casete de validare sau câmpuri de text; +
-  * **Containere** - acestea reprezintă componente care pot conține alte componente (de exemplu panouri, casete de dialog sau ferestre independente);​ +
-  * **Administratori de dispunere** - reprezintă obiecte care definesc modul în care sunt aranjate (dispuse) componentele într-un container. Administratorul de dispunere nu este vizibil într-o interfață,​ însă sunt vizibile rezultatele "​muncii"​ sale. +
- +
-<note tip> +
-Dispunerea componentelor interfeței este de mai multe feluri: +
-  * dispunere secvențială;​ +
-  * dispunere tabelară;​ +
-  * dispunere marginală;​ +
-  * dispunere tabelară neproporțională. +
-</​note>​ +
- +
-=== 3. Crearea ferestrelor === +
- +
-== 3.1 Clasa JFrame ​==+
  
-Clasa **JFrame** este cea pe care o vom folosi pentru a crea ferestre. Ca orice altă clasă care reprezintă componente Swing ea se află în pachetul //​javax.swing//​.+Să se realizeze un program ​care citește dintr-un fișier ​o întrebare urmată de 4 răspunsuri posibile, unul singur fiind corect (primul indicat în fișier), și afișează un câmp text nemodificabil, ​care va conține enunțul întrebării, patru butoane de tip **JRadioButton**,​ grupate într-un grup de butoane (**ButtonGroup**),​ conținând răspunsurile posibile, și un buton pentru validarea răspunsului selectat.
  
-Pentru că este un container, vom folosi, ​de cele mai multe ori, această clasă prin moștenire nu prin instanțiere. Altfel spus, vom crea clase care să reprezinte ferestre și pentru ca acestea să devină ferestre de tip JFrame ele vor moșteni această clasă.+Butonul de validare ​este de tip **JButton** și este accesibil doar după ce a fost ales un răspuns. În cazul în care răspunsul selectat este corect, se va aplica textului răspunsului culoarea verde, iar, în caz contrar, ​i se va aplica răspunsului corect culoarea roșie.
  
 <code java> <code java>
-public class Fereastra extends JFrame { +@Override 
-    ​private JButton button; +public ​void actionPerformed(ActionEvent e) { 
- +    ​if ​(e.getSource() instanceof JRadioButton) { 
-    ​public ​Fereastra(String text) { +        ​button.setEnabled(true);
-        super(text); +
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);​ +
-        setMinimumSize(new Dimension(300, 200)); +
-        ​getContentPane().setBackground(Color.blue);​ +
-        setLayout(new SpringLayout());​ +
-        button = new JButton("​Apasa"​);​ +
-        add(button);​ +
-        show(); +
-        pack(); +
-    } +
- +
-    public static void main(String args[]) { +
-        Fereastra f = new Fereastra("​Laborator POO");+
     }     }
 } }
Line 83: Line 31:
  
 <note important>​ <note important>​
-Metoda //​add(Component c)// este folosită pentru a adăuga pe fereastră o componentă exact ca în cazul Applet-urilor. Metoda //add()// este moștenită din clasa **Container**.+Fișier de intrare: ​**intrebare.txt**
 </​note>​ </​note>​
  
-=== 4. Crearea butoanelor ​===+=== Problema 3 ===
  
-== 4.1 Clasa JButton ==+Modificați programul implementat la exercițiul anterior, pentru afișarea unor casete cu bifare, **JCheckBox**. Astfel, de această dată vom avea un program care permite uzitarea unor întrebări cu răspunsuri corecte multiple.
  
-Un buton poate fi creat folosind clasa **JButton**. De obicei, butonul este construit folosind unul dintre constructorii:​+Toate cele patru casete de tip **JCheckBox** vor avea un singur ascultător de tip **ItemListener**, cu o metodă //​itemStateChanged()//​ și cu un argument de tip **ItemEvent**.
  
-  ​* //​public ​JButton();// → un buton fără text +Butonul de validare este de tip **JButton** și este accesibil doar după ce a fost ales un răspuns. La apăsarea butonului de validare se va aplica textelor ​răspunsurilor corecte culoarea verde, iar celor incorecte li se va aplica culoarea roșie.
-  * //public JButton(String text)// → un buton cu text dat ca parametru +
-  * //public JButton(String text, Icon ico)// → buton cu text și imagine+
  
-Textul de pe buton poate fi modificat folosind metoda //​setText(String text)// sau poate fi preluat folosind metoda //​getText()//​.+<note tip> 
 +Presupunem că sunt corecte primul și al treilea răspuns.
  
-<note warning>​ +Metodă utilă: ​//getSource()//
-Metodele ​//setLabel()// și //​getLabel()//​ sunt considerate obsolete și nu se mai folosesc în prezent.+
 </​note>​ </​note>​
  
-== 4.2 Exemplu de implementare ​==+=== Problema ​4 ===
  
-<code java> +Să se implementeze o aplicație grafică cu 3 obiecte cursor, de tip **JSlider**,​ și un câmp text. Fiecare cursor corespunde ponderii unei culori (Red, Green, Blue), iar culoarea apare în câmpul text.
-class Button extends JFrame implements ActionListener { +
-    private JButton button;+
  
-    public Button(String text) { +Pentru fiecare obiect **JSlider**, trebuie să definiți următoarele:​ 
-        super(text);​ +  * orientarea; 
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);​ +  * valoarea minimă; 
-        setMinimumSize(new Dimension(300, 200)); +  * valoarea maximă; 
-        ​getContentPane().setBackground(Color.blue); +  * valoarea inițială afișată (ca numere întregi).
-        ​setLayout(new SpringLayout()); +
-        ​button = new JButton("​Apasa"​); +
-        ​button.addActionListener(this);​ +
-        add(button);​ +
-        show(); +
-        pack(); +
-    } +
- +
-    public static void main(String args[]) { +
-        Button b = new Button("​LaboratorPOO"​);​ +
-    } +
- +
-    @Override +
-    public void actionPerformed(ActionEvent e) { +
-        /* +
-        JButton button = (JButton)e.getSource();​ +
-        if (button.getText().equals("​Apasa"​)) +
-            // valabil dacă aveam mai multe butoane ascultate de acest ascultător +
-        */ +
-        System.out.println("​Butonul a fost apasat!"​); +
-    } +
-} +
-</​code>​+
  
 <note important>​ <note important>​
-Din moment ce butonul reprezintă o componentă, poate fi adăugat pe un container folosind ​metoda //add(Component c)// a containerului.+La deplasarea cursorului, se generează un eveniment de tip **ChangeEvent** și se apelează ​metoda //stateChanged//, dintr-un obiect **ChangeListener**.
  
-Butonul ​**JButton** este sensibil la evenimente de tip **ActionEvent**, așadar, modalitatea de atașare a ascultătorilor și de creare evenimente este similară butoanelor Button din pachetul ​//java.awt//.+Valoarea ce corespunde poziției cursorului se poate obține cu metoda //​getValue()//​ din clasa **JSlider**, ce are ca rezultat un //int//.
 </​note>​ </​note>​
  
-=== 5. Crearea componentelor text ===+<code java> 
 +slider ​= new JSlider(JSlider.HORIZONTAL, 0, 255, 0); 
 +</​code>​
  
-== 5.1 Tipuri de componente text ==+=== Problema ​5 ===
  
-Vom folosi trei tipuri de componente text: **JTextField**,​ **JTextArea** ​și **JPasswordField**.+Program pentru afișarea unui buton cu inscripția "​Colors" ​și modificarea culorii acestuia ca urmare a efectuării unui click pe buton.
  
-  ​* **JTextField** - este un câmp de text cu un singur rând pe care pot încăpea mai multe caractere. În general, această componentă este folosită pentru a introduce ​un text de dimensiuni mici; +Metoda //​setForeground()//​ cu parametru de tip **Color** schimbă culoarea textului, iar metoda //​setBackground()//​ schimbă culoarea butonului. La fiecare click se va itera pe un vector ​de culori, inițializat cu constante (//​Color.RED//​, //​Color.BLUE//​ etc).
-  * **JTextArea** - este un câmp de text care permite introducerea unui text pe mai multe rânduri, deci, această componentă este folosită pentru texte de dimensiuni mai mari; +
-  * **JPasswordField** - este similară componentei JTextField, doar că aceasta ascunde caracterele introduse de utilizator ca în cazul unui câmp pentru introducerea parolei obișnuit.+
  
 <note tip> <note tip>
-Metoda folosită pentru preluarea textului dintr-o componentă text este: //getText()// care returnează o instanță de **String**.+Folosiți ​o fereastră **JFrame** cu dimensiuni mici (100, 100) și organizarea ​**FlowLayout**.
  
-Pentru ​a modifica textul dintr-un câmp de text, se folosește metoda //​setText(String text)//. +Implementați și posibilitatea de acționare ​a butonului prin combinația ​de taste **ALT+C**.
- +
-Componenta ​**JTextArea** are în comportament și metoda //​append(String text)// care permite adăugarea unui text la componentă.+
 </​note>​ </​note>​
- 
-== 5.2 Exemplu de implementare == 
  
 <code java> <code java>
-class Text extends JFrame implements ActionListener { +buton.setMnemonic(KeyEvent.VK_C);
-    private JButton button; +
-    private JTextField user; +
-    private JPasswordField pass; +
- +
-    public Text(String text) { +
-        super(text);​ +
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);​ +
-        setMinimumSize(new Dimension(300,​ 200)); +
-        getContentPane().setBackground(Color.blue);​ +
-        setLayout(new FlowLayout());​ +
-        button = new JButton("​Apasa"​);​ +
-        button.addActionListener(this);​ +
-        add(button);​ +
-        user = new JTextField(15);​ +
-        add(user);​ +
-        pass = new JPasswordField(15);​ +
-        add(pass);​ +
-        show(); +
-        pack(); +
-    } +
- +
-    public static void main(String args[]) { +
-        Text b = new Text("​LaboratorPOO"​);​ +
-    } +
- +
-    @Override +
-    public void actionPerformed(ActionEvent e) { +
-        /* +
-        JButton button = (JButton)e.getSource();​ +
-        if (button.getText().equals("​Apasa"​)) +
-            // valabil dacă aveam mai multe butoane ascultate de acest ascultător +
-        */ +
-        System.out.println(user.getText() + pass.getText()); +
-    } +
-}+
 </​code>​ </​code>​
  
-=== 6. Butoane de selecție ​===+=== Problema ​6 ===
  
-== 6.1 JCheckBox și JRadioButton ==+Realizați o fereastră cu titlu, folosind **JFrame**, care să conțină următoarele:​ 
 +  * o etichetă, având ca text "​Calea";​ 
 +  * un **JTextField**;​ 
 +  * un **JButton**;​ 
 +  * un **JScrollPane** care să conțină un **JTextArea**,​ setat inițial ca fiind invizibil.
  
-Clasele **JCheckBox** ​și **JRadioButton** definesc componente de tip butoane de selecție. +După ce se va introduce o cale, către un fișier text aflat local pe disc, se va afișa conținutul acestui fișier în fereastră, uzitând componenta ​de tip **JTextArea**.
- +
-Standard, butoanele **JCheckBox** sunt folosite pentru ​a crea liste de opțiuni de tip //​multiple-choice//​ (din care poți selecta mai multe variante), iar **JRadioButton** pentru crearea de liste de tip //​single-choice//​ (din care se poate selecta o singură opțiune).+
  
 <note important>​ <note important>​
-Astfel, pentru butoanele ​**JRadioButton** adăugăm o nouă clasă **ButtonGroup** cu ajutorul căreia precizăm care sunt butoanele din care se selectează o singură opțiune. +Componenta de tip **JScrollPane** va deveni vizibilă la accesarea butonului, dacă există fișierul specificat local pe disc, în caz contrar, ​se va șterge conținutul din **JTextField**.
- +
-**ButtonGroup** definește un grup de butoane. Din butoanele ce aparțin aceluiași grup, nu putem selecta decât o singură opțiune.+
 </​note>​ </​note>​
- 
-== 6.2 Utilizare == 
- 
-Ambele tipuri de componente se creează similar butoanelor **JButton**. În general, acestea nu sunt folosite cu evenimente și prin verificări ale stărilor acestora (se verifică dacă este sau nu selectat la un anumit eveniment). 
- 
-Verificarea stării unei astfel de componente se face folosind metoda //​isSelected()//​ care returnează //true// dacă butonul este bifat și //false// dacă nu este bifat. 
- 
-<note tip> 
-Pentru o înțelegere mai bună, se recomandă analizarea exemplelor propuse în arhiva laboratorului. 
-</​note>​ 
- 
-=== 7. JScrollPane === 
- 
-== 7.1 Descriere == 
- 
-**JScrollPane** este o componentă folosită pentru adăugarea de bare de defilare pentru o altă componentă care ar putea depăși dimensiunile containerului în care este adăugată. 
- 
-Instanța JScrollPane nu este folosită în acțiunile directe pe care le are componenta pe care o susține. La construirea instanței, i se dă o componentă pentru care este creată și pe care adaugă bare de defilare (//​scrollbars//​). 
- 
-Apoi, instanța **JScrollPane** este adăugată pe container în locul componentei din instanța JScrollPane. 
- 
-== 7.2 Exemplu de implementare == 
  
 <code java> <code java>
-class Text extends JFrame { +File f = new File(path); 
-    private JTextArea textArea; +if(f.exists() && !f.isDirectory()) { 
-    private JScrollPane scroll; +    ​// ...
- +
-    public Text(String text) { +
-        super(text);​ +
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);​ +
-        setMinimumSize(new Dimension(300,​ 200)); +
-        getContentPane().setBackground(Color.blue);​ +
-        setLayout(new FlowLayout());​ +
-        textArea ​= new JTextArea(200, 100); +
-        ​textArea.setLineWrap(true); +
-        textArea.setWrapStyleWord(true); +
-        textArea.setFont(new Font("​Tahoma",​ 2, 12)); +
-        scroll = new JScrollPane(textArea);​ +
-        add(scroll);​ +
-        show(); +
-        pack(); +
-    } +
- +
-    public static void main(String args[]) { +
-        Text b = new Text("​LaboratorPOO"​);​ +
-    ​}+
 } }
 </​code>​ </​code>​
- 
-=== 8. Etichete === 
- 
-== 8.1 JLabel == 
- 
-O etichetă reprezintă cea mai simplă componentă. Aceasta este folosită pentru afișarea unui text static în cele mai multe cazuri. 
- 
-Textul de pe o etichetă poate fi modificat sau preluat folosind metodele //​getText()//​ și //​setText(String text)//. 
- 
-<note tip> 
-Un **JLabel** poate fi uzitat și pentru afișarea unei imagini. În acest caz, nu i se aplică niciun text, ci doar un **ImageIcon**,​ această modalitate fiind considerată cea mai simplă de a afișa o imagine într-un container. 
-</​note>​ 
- 
-=== 9. Tratarea evenimentelor === 
- 
-== 9.1 Ce sunt evenimentele?​ == 
- 
-Un **eveniment** este produs de o acțiune a utilizatorului asupra unei componente grafice și reprezintă mecanismul prin care utilizatorul comunică efectiv cu programul. 
- 
-Exemple de evenimente sunt: 
-  * apăsarea unui buton; 
-  * modificarea textului într-un control de editare; 
-  * închiderea sau redimensionarea unei ferestre. 
- 
-<note important>​ 
-Componentele care generează anumite evenimente se mai numesc și **surse de evenimente**. 
-</​note>​ 
- 
-== 9.2 Listeners (Ascultători de evenimente) == 
- 
-Interceptarea evenimentelor generate de componentele unui program se realizează prin intermediul unor clase de tip **listener** (ascultător,​ consumator de evenimente). 
- 
-În Java, orice obiect poate "​consuma"​ evenimente, cu condiția ca acesta să implementeze interfața listener corespunzătoare tipului de eveniment pe care dorește să-l intercepteze. 
  

Laboratoare

Breviare

poo/laboratoare/09.1764514335.txt.gz · Last modified: 2025/11/30 16:52 by george.tudor1906
Show pageOld revisions
Media ManagerBack to top
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0