Nel linguaggio Java, come in altri linguaggi, un’Interfaccia Grafica è composta da immagini, icone, finestre, pulsanti e molti altri elementi. Le interfacce grafiche si indicano con il termine GUI (Graphical Unit Interface).

La videata degli schermi grafici è composta da una matrice di punti, chiamati pixel. A ogni pixel può essere associato un colore ed il loro insieme forma l’immagine completa. La dimensione della matrice dei pixel che compongono lo schermo è definita Risoluzione.
Un punto all’interno di una finestra può essere indicato usando una coppia di numeri (coordinate). Il sistema di riferimento ha lo zero (0,0) nell’angolo in alto a sinistra della finestra.

L’elemento grafico principale di una interfaccia grafica è la Finestra. Rappresenta un’area dello schermo all’interno del quale vengono eseguite le applicazioni.

Altri elementi grafici possono essere Pulsanti, Caselle di testo, Aree di testo, Caselle combinate (Select), Pulsanti di opzione..
Un modo naturale di rappresentare questi elementi all’interno della programmazione è di trattarli come Oggetti, con le loro caratteristiche (attributi) e le loro funzioni (metodi).
Ad ognuno di questi possono essere associati Eventi, attraverso i quali, ad ogni interazione dell’utente attraverso gli elementi grafici, è associata un’azione appropriata.

Gli eventi sono generati da azioni dell’utente, ed a loro viene associata una reazione nel programma gestita dal Gestore degli Eventi (Handler).

 

Librerie Grafiche in Java

La parte grafica di Java è contenuta nei package java.awt e javax.swing. E’ quindi necessario importare entrambe le librerie in ogni programma in cui viene utilizzata la grafica per realizzare una GUI.

La libreria AWT (Abstract Windiw Tollkit) è utilizzata da Java per definire un insieme di elementi grafici indipendenti dalla piattaforma su cui vengono visualizzati, garantendo la portabilità delle applicazioni Java tra piattaforme diverse.
La libreria Swing rappresenta una evoluzione di AWT, mettendo a disposizione nuovi componenti, metodi e funzionalità.

Un’interfaccia grafica è composta da 2 elementi principali, i Componenti e i Contenitori.
Un Componente (Component) è un oggetto con una rappresentazione grafica (bottoni, caselle di testo, barre di scorrimento..), e la sua caratteristica fondamentale è di offrire una interazione con l’utente. Ogni componente gestisce il modo con cui viene visualizzato, conosce il suo contenuto e reagisce alle eventuali interazioni dell’utente.
Un Contenitore (Container)è un oggetto che può contenere le componenti. Il compito del contenitore è quello di posizionare e di dimensionare le componenti all’interno dell’interfaccia. Un contenitore sempre usato è la Finestra (JFrame), cui caratteristiche sono il titolo e i bottoni di ridimensionamento e chiusura, ed al cui interno vengono posizionati i componenti.
Gli oggetti della classe Container implementano concretamente i contenitori che possono essere utilizzati per costruire una interfaccia grafica. Tra i contenitori è presente anche la classe Applet.

Nella libreria Swing i nomi delle componenti e dei contenitori iniziano con la lettera J e sidistinguono in:

• Contenitori principali (finestra principale JFrame, finestra di dialogo JDialog e finestra di applet JApplet)
• Contenitori intermedi indicati con il termine Pane che contengono altre componenti (JPanel)
• Componenti atomiche (etichetta JLabel, bottone JButton, casella di testo JTextField, area di testo JTextArea, casella di testo JComboBox, tabelle JTable)

Ogni contenitore Top-Level di Swing contiene un contenitore intermedio Content Pane, e le componenti non possono essere direttamente inserite nel contenitore principale ma solo nel content pane.

 

L’esempio seguente crea una finestra grafica composta da una etichetta e da un pulsante all’interno di un pannello inserito all’interno di una finestra. Da notare che a queste componenti non viene associato nessun Evento.

import javax.swing.*;
import java.awt.*;

class FinestraSwing {
     public static void main(String argv[]) {
          // Istanzio gli oggetti JFrame e JPanel
          JFrame f = new JFrame("Finestra Swing");
          JPanel p = new JPanel();
          // Instanzio gli oggetti JLabel e JButton
          JLabel l = new JLabel("Etichetta");
          JButton b = new JButton("Bottone");
          // Aggiungo al panel i componenti label e button
          p.add(l);
          p.add(b);
          // Istanzio il content pane e lo associo alla finestra JFrame
          Container c = f.getContentPane();
          // Aggiungo al container il panel con i componenti
          c.add(p);
          // Setto attributi finestra JFrame
          f.setSize(300,200);
          f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          f.setVisible(true);
     }
}

Il risultato dopo l’esecuzione è

Nel prossimo esempio verrà creata una finestra all’interno della quale vengono disegnate 4 aree di differente colore, una di sfondo e due sovrapposte ad essa ed un poligono, e viene inserito un testo.

La classe Graphics fornisce gli strumenti per il disegno, linee, contorni, rettangoli e poligoni a riempimento di colore, ecc..
Nell’esempio vengono utilizzati i metodi:
setColor() per definire il colore dello strumento che si andrà in seguito ad utilizzare
drawRect() per disegnare un contorno
fillRect() per disegnare un rettangolo a riempimento di colore
fillPolygon() per disegnare un poligono a riempimento di colore
setFont() per definire il font per disegnare stringhe
drawString() per disegnare una stringa

Il programma è strutturato utilizzando 2 sottoclassi, estese dalle classi Swing JFrame e JPanel. All’interno di ognuna di esse sono implementati nuovi metodi che vanno ad aggiungersi a quelli ereditati dalla classe generatrice.
Per la sottoclasse sub_JFrame il metodo costruttore crea una finestra con l’eventuale titolo passato come parametro e la dimensiona con larghezza e altezza uguali alla metà di quelle dello schermo, posizionandola al centro.
La sottoclasse sub_JPanel attraverso il metodo paintComponent crea un pannello ed al suo interno disegna e posiziona 2 rettangoli colorati ed il  testo.

La classe sub_JFrame:

import javax.swing.*;
import java.awt.*;

public class sub_JFrame extends JFrame {

     public sub_JFrame(String titolo){
     // super indica il riferimento alla sopraclasse JFrame
          super(titolo);
          // dimensiono il frame larghezza_schermo/2 e altezza_schermo/2
          Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
          int height = screenSize.height;
          int width = screenSize.width;
          this.setSize(width/2, height/2);
          // posiziono la finestra al centro dello schermo
          this.setLocationRelativeTo(null);
     }
}

La classe sub_JPanel:

import javax.swing.*;
import java.awt.*;

public class sub_JPanel extends JPanel {
        
    public void paintComponent(Graphics g){
        
        int x_win = super.getWidth();
        int y_win = super.getHeight();
        
        super.paintComponent(g);
        //sfondo con cornice
        g.setColor(Color.white);
        // white, gray, lightGray, darkGray
        // red, green, yellow, pink, etc. etc.
        g.fillRect(0,0,x_win,y_win);
        g.setColor(Color.blue);
        g.drawRect(10,10,x_win-20,y_win-20);
        
        //rettangolo rosso
        g.setColor(Color.red);
        g.fillRect(11,11,(x_win/2)-11,(y_win/2)-11);
        //rettangolo verde
        g.setColor(Color.green);
        g.fillRect(x_win/2,11,(x_win/2)-11,(y_win/2)-11);

        // Poligono
        g.setColor(Color.magenta);
        int x[]={10, 100, x_win-10, x_win-10};
        int y[]={y_win-10, y_win-10, 60, 10};
        Polygon pol = new Polygon(x, y, x.length);
        g.fillPolygon(pol);
        
        //scritta grafica
        g.setFont(new Font("Courier New", Font.BOLD, 25));
        g.setColor(Color.black);
        g.drawString("Prova Grafica in Java",(x_win/2),(y_win/2)+25);
    }
}

Il programma principale:

import javax.swing.*;
import java.awt.*;

public class Grafica_1 {

    public static void main(String[] args) {
        
        int x_win;
        int y_win;
        
        sub_JFrame win = new sub_JFrame("Finestra di Esempio");
        
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        win.setVisible(true);
        
        Container c = win.getContentPane();
        sub_JPanel panel = new sub_JPanel();
        c.add(panel);
    }
}

Il risultato grafico sarà la seguente finestra