Ingineria Sistemelor de Programe

Documentatie suplimentara, ISP, Seria B si SM

View on GitHub

Documentație: Interfețe Grafice în Java

Cuprins

  1. Introducere în Interfețele Grafice
  2. Alegerea Tehnologiei pentru Interfețe Grafice
  3. Tehnologii pentru Interfețe Grafice în Java
  4. De ce Swing?
  5. Concepte Fundamentale în Swing
  6. Mecanismul de Bază al Creării unei Interfețe Grafice în Java
  7. Componente Swing de Bază
  8. Sfaturi și Bune Practici
  9. Resurse Suplimentare

Introducere în Interfețele Grafice

Interfețele grafice (GUI - Graphical User Interface) reprezintă modalitatea prin care utilizatorii interacționează vizual cu o aplicație, folosind elemente precum ferestre, butoane, meniuri și alte componente grafice, în loc să folosească o interfață bazată pe linie de comandă. O interfață grafică bine proiectată este esențială pentru experiența utilizatorului, făcând aplicația mai accesibilă și mai ușor de utilizat.

Alegerea Tehnologiei pentru Interfețe Grafice

Alegerea tehnologiei pentru dezvoltarea interfețelor grafice depinde în primul rând de tipul aplicației pe care doriți să o creați. Principalele categorii sunt:

Aplicații Web

Pentru interfețe grafice accesibile prin browser web, tehnologiile tipice includ:

Aplicații Mobile Native

Pentru aplicații mobile specifice unei platforme:

Aplicații Mobile Cross-Platform

Pentru aplicații mobile care rulează pe multiple platforme:

Aplicații Desktop

Pentru aplicații care rulează pe sistemele de operare desktop:

În acest curs ne vom concentra pe dezvoltarea aplicațiilor desktop folosind Java, în special tehnologia Swing, pentru a înțelege principiile fundamentale ale dezvoltării interfețelor grafice.

Tehnologii pentru Interfețe Grafice în Java

Java oferă mai multe opțiuni pentru dezvoltarea interfețelor grafice pentru aplicații desktop:

AWT (Abstract Window Toolkit)

AWT este cea mai veche bibliotecă pentru interfețe grafice în Java, fiind parte din JDK încă de la versiunea 1.0. Caracteristici principale:

Swing

Swing a fost introdus în Java 1.2 ca o extensie a AWT și oferă o serie de îmbunătățiri:

JavaFX

JavaFX este cea mai nouă tehnologie pentru interfețe grafice în Java, lansată în 2008 și a fost integrată în JDK între Java 8 și Java 10. Începând cu Java 11, JavaFX a fost eliminat din JDK standard și a devenit un modul separat:

De ce Swing?

În acest curs ne vom concentra pe Swing din următoarele motive:

  1. Accesibilitate pentru începători: Swing are o curbă de învățare mai blândă, fiind ideal pentru cei care învață pentru prima dată despre interfețe grafice.

  2. Concepte fundamentale: Swing ilustrează foarte bine conceptele de bază ale dezvoltării interfețelor grafice, care sunt aplicabile și în alte tehnologii.

  3. Documentație vastă: Fiind o tehnologie matură, există numeroase resurse, tutoriale și exemple disponibile.

  4. Stabilitate: Swing este o tehnologie stabilă și bine testată, cu comportament predictibil.

  5. Transferabilitate a cunoștințelor: Principiile învățate cu Swing (layout management, gestionarea evenimentelor, componentele GUI) sunt aplicabile și în alte tehnologii precum JavaFX sau chiar în alte limbaje de programare.

  6. Prevalență în aplicații existente: Multe aplicații enterprise încă folosesc Swing, astfel încât învățarea acestuia rămâne relevantă pentru piața muncii.

  7. Disponibilitate directă în JDK: Spre deosebire de JavaFX care necesită instalare separată începând cu Java 11, Swing este integrat direct în Java SE, astfel încât nu există dependențe externe de gestionat.

Deși JavaFX oferă caracteristici mai moderne, Swing rămâne o alegere excelentă pentru a înțelege fundamentele dezvoltării interfețelor grafice în Java.

Concepte Fundamentale în Swing

Containere și Componente

În Swing, interfața grafică este construită pe baza unui model ierarhic de componente:

Containere sunt componente speciale care pot conține alte componente:

Componente sunt elementele UI cu care interacționează utilizatorul:

Layout Managers

Layout Managers sunt clase care controlează poziționarea și dimensionarea componentelor într-un container:

Gestionarea Evenimentelor

Swing folosește un model de programare bazat pe evenimente. Când utilizatorul interacționează cu interfața (click, tastare, etc.), se generează evenimente care pot fi procesate de codul aplicației:

  1. Sursa evenimentului: Componenta care generează evenimentul (ex. un buton)
  2. Obiectul eveniment: Conține informații despre eveniment
  3. Listener: Obiect care “ascultă” evenimente și definește acțiunile de efectuat

Tipuri comune de listeners:

Mecanismul de Bază al Creării unei Interfețe Grafice în Java

Crearea unei interfețe grafice în Java urmează o secvență logică de pași. Înțelegerea acestui proces vă va permite să dezvoltați interfețe grafice într-un mod structurat și eficient. Mai jos sunt prezentați pașii principali necesari pentru crearea unei interfețe grafice în Java Swing:

1. Importul Bibliotecilor Necesare

Primul pas este importul claselor necesare din pachetele Swing și AWT:

import javax.swing.*;          // Pachetul principal pentru Swing
import java.awt.*;             // Abstract Window Toolkit pentru layout și grafică
import java.awt.event.*;       // Pentru gestionarea evenimentelor

2. Crearea și Configurarea Ferestrei Principale (JFrame)

JFrame este containerul principal al aplicației, reprezentând fereastra vizibilă pentru utilizator:

// Metoda 1: Crearea unui JFrame separat
JFrame frame = new JFrame("Titlul Aplicației");
frame.setSize(600, 400);                             // Setarea dimensiunii (lățime, înălțime)
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Închiderea aplicației la închiderea ferestrei
frame.setLocationRelativeTo(null);                    // Centrarea ferestrei pe ecran
frame.setResizable(true);                            // Permiterea redimensionării (opțional)
frame.setIconImage(new ImageIcon("icon.png").getImage()); // Setarea iconiței ferestrei (opțional)

// SAU Metoda 2: Extinderea clasei JFrame
public class AplicatiaMea extends JFrame {
    public AplicatiaMea() {
        setTitle("Titlul Aplicației");
        setSize(600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        // ...restul configurărilor
    }
}

3. Alegerea și Configurarea Layout Manager-ului

Layout Manager-ul determină cum sunt aranjate componentele în container:

// Opțiunea 1: Setarea Layout Manager direct pe JFrame
frame.setLayout(new FlowLayout()); // Componentele vor fi aranjate în flux

// Opțiunea 2: Crearea unui JPanel cu Layout Manager și adăugarea în JFrame
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout()); // Sau alt layout manager
frame.add(panel);

// Opțiunea 3: Utilizarea mai multor paneluri cu layout managers diferite
JPanel mainPanel = new JPanel(new BorderLayout());
JPanel topPanel = new JPanel(new FlowLayout());
JPanel centerPanel = new JPanel(new GridLayout(3, 2, 10, 10)); // 3 rânduri, 2 coloane, gap 10px

mainPanel.add(topPanel, BorderLayout.NORTH);
mainPanel.add(centerPanel, BorderLayout.CENTER);
frame.add(mainPanel);

4. Crearea și Configurarea Componentelor

Adăugați componentele necesare pentru interfața utilizator:

// Crearea componentelor
JLabel titleLabel = new JLabel("Aplicație de Exemplu");
titleLabel.setFont(new Font("Arial", Font.BOLD, 20)); // Setarea fontului

JTextField inputField = new JTextField(20); // 20 de caractere vizibile
JButton submitButton = new JButton("Trimite");
JCheckBox optionCheckbox = new JCheckBox("Activează opțiunea");

// Personalizarea componentelor (opțional)
submitButton.setBackground(new Color(100, 180, 100)); // Setarea culorii de fundal
submitButton.setForeground(Color.WHITE);              // Setarea culorii textului
submitButton.setFocusPainted(false);                  // Elimină border-ul de focus

5. Adăugarea Componentelor în Containere

Adăugați componentele create în containerele configurate anterior:

// Adăugarea în layout-uri standard (exemplu pentru BorderLayout)
topPanel.add(titleLabel);
centerPanel.add(new JLabel("Introduceți datele:"));
centerPanel.add(inputField);
centerPanel.add(new JLabel("Opțiuni:"));
centerPanel.add(optionCheckbox);
centerPanel.add(new JLabel()); // Celulă goală pentru aranjament
centerPanel.add(submitButton);

// Adăugarea în layout-uri specifice (exemplu pentru BorderLayout)
panel.add(titleLabel, BorderLayout.NORTH);
panel.add(inputField, BorderLayout.CENTER);
panel.add(submitButton, BorderLayout.SOUTH);

6. Atașarea Event Handler-elor

Adăugați logica pentru a răspunde la interacțiunile utilizatorului:

// Metoda 1: Folosind clase anonime interne
submitButton.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        String input = inputField.getText();
        JOptionPane.showMessageDialog(frame, "Ați introdus: " + input);
    }
});

// Metoda 2: Folosind expresii lambda (Java 8+)
submitButton.addActionListener(e -> {
    String input = inputField.getText();
    JOptionPane.showMessageDialog(frame, "Ați introdus: " + input);
});

// Metoda 3: Implementarea interfeței în clasa principală
public class AplicatiaMea extends JFrame implements ActionListener {
    // ...
    
    public AplicatiaMea() {
        // ...
        submitButton.addActionListener(this);
    }
    
    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == submitButton) {
            // Acțiunea pentru buton
        }
    }
}

7. Afișarea Interfației Grafice

La final, faceți interfața vizibilă pentru utilizator:

// Este important să faceți toate operațiunile pe interfață în Event Dispatch Thread
SwingUtilities.invokeLater(() -> {
    // Pentru Metoda 1 (JFrame separat)
    frame.pack(); // Opțional - ajustează dimensiunea ferestrei la componente
    frame.setVisible(true); // Afișează fereastra
    
    // SAU pentru Metoda 2 (clasă extinsă din JFrame)
    AplicatiaMea app = new AplicatiaMea();
    app.pack(); // Opțional
    app.setVisible(true);
});

8. Gestionarea Aspectelor Avansate

Pentru interfețe mai complexe, puteți adăuga funcționalități suplimentare:

// Setarea unui Look and Feel specific
try {
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    // SAU pentru un L&F specific:
    // UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Exception e) {
    e.printStackTrace();
}

// Adăugarea de meniuri
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("Fișier");
JMenuItem exitItem = new JMenuItem("Ieșire");
exitItem.addActionListener(e -> System.exit(0));
fileMenu.add(exitItem);
menuBar.add(fileMenu);
frame.setJMenuBar(menuBar);

// Adăugarea de scurtături de tastatură
submitButton.setMnemonic(KeyEvent.VK_S); // Alt+S activează butonul

Sfaturi și Bune Practici

  1. Utilizați Event Dispatch Thread: Toate operațiile pe interfață trebuie efectuate astfel: 
    SwingUtilities.invokeLater(() -> {
    // Cod pentru interfața grafică
});

  2. Separați logica de afaceri de interfața grafică: Folosiți modele de design precum MVC pentru a separa codul.

  3. Folosiți layout managers în loc de poziționare absolută: Aceasta asigură că interfața se adaptează la diferite dimensiuni de ecran.

  4. Gestionați erorile în mod grafic: Folosiți dialoguri pentru afișarea erorilor în loc de consolă.

  5. Folosiți mnemonici și acceleratori pentru accesibilitate: Aceștia permit utilizatorilor să folosească tastatura pentru navigare.

  6. Testați pe multiple platforme: Verificați că interfața arată și funcționează corect pe diferite sisteme de operare.

  7. Folosiți Look and Feel consistent: Setați un look and feel adecvat pentru aplicație: 
    try {
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
    e.printStackTrace();
}

Resurse Suplimentare