C:\Users\Marco\Desktop\progetto>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" LeggiEStampaEta.java

C:\Users\Marco\Desktop\progetto>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" LeggiEStampaEta
Digita la tua eta': 13
La tua eta' e': 13

import java.io.*;

public class LeggiEStampaEta
{
    public static void main (String args[])
    {
        // Impostazione per lo standard input
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader Tastiera = new BufferedReader(input);
        int Eta;
        String TestoLetto;
        
        try {
               System.out.print("Digita la tua eta': ");
               TestoLetto=Tastiera.readLine();
               Eta=Integer.valueOf(TestoLetto).intValue();
        }
        catch (Exception e)
        {
            System.out.println("\nNon hai digitato un numero!");
            return;
        }
        System.out.println("La tua eta' e': " + Eta);
    }
}

Esempio 2: Semplice programma di I/O (stringhe)

Per compilare scriviamo:

C:\Users\Marco\Desktop\Java\gui1>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Esercizio2.java

C:\Users\Marco\Desktop\progetto>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" Esercizio2
Digita la stringa: Ciao Sono Io
Il numero di lettere maiuscole e': 3

import java.io.*; // Import necessario per lo stream di input

public class Esercizio2
{
    public static void main (String args[])
    {
        // Impostazione per lo standard input
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader Tastiera = new BufferedReader(input);
        String TestoLetto;
        
        // INPUT
        try {
               System.out.print("Digita la stringa: ");
               TestoLetto=Tastiera.readLine();
        }
        catch (Exception e) {
            return;
        }
        // ALGORITMO
        int  NrMaiuscole=0;
        for (int i=0; i <TestoLetto.length() ; i++)
        {
            if (TestoLetto.charAt(i)>='A' && TestoLetto.charAt(i)<='Z' )
                NrMaiuscole++;
        }
        
        // OUTPUT
        if (NrMaiuscole>0)
           System.out.println("Il numero di lettere maiuscole e': "+NrMaiuscole);
        else
           System.out.println("Non ho nessuna lettera maiuscola");
    }
}

C:\Users\Marco\Desktop\progettoCerchio>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Cerchio.java

C:\Users\Marco\Desktop\progettoCerchio>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" ProgCerchio.java

C:\Users\Marco\Desktop\progettoCerchio>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" ProgCerchio
Circonferenza: 31.41592653589793
Area         : 78.53981633974483

/* ---------+--------+---------+---------+------
Modifier    | Class  | Package | Subclass| World
------------+--------+---------+---------+------
public      |   x    |    x    |    x    |   x
------------+--------+---------+---------+------
protected   |   x    |    x    |    x    |   .
------------+--------+---------+---------+------
no modifier |   x    |    x    |    .    |   .
------------+--------+---------+---------+------
private     |   x    |    .    |    .    |   .    
------------------------------------------------ */
public class Cerchio
{
    protected double Raggio;
    /* Costruttore */
    public Cerchio(double r)
    {
        Raggio = r;
    }

    public double Circonferenza()
    {
        return 2*Raggio*Math.PI;
    }
    public double Area()
    {
        return (Raggio*Raggio*Math.PI);
    }
}

public class ProgCerchio
{
    public static void main (String args[])
    {
        Cerchio c = new Cerchio(5);
        System.out.println("Circonferenza: "+c.Circonferenza());
        System.out.println("Area         : "+c.Area());
    }
}

C:\Users\Marco\Desktop\progettoCilindro>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Cerchio.java

C:\Users\Marco\Desktop\progettoCilindro>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Cilindro.java

C:\Users\Marco\Desktop\progettoCilindro>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" progCilindro.java

C:\Users\Marco\Desktop\progettoCilindro>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" ProgCilindro
Circonferenza: 31.41592653589793
Superficie   : 471.23889803846896
Volume       : 785.3981633974483

class Cerchio
{
    protected double Raggio;
    /* Costruttore */
    public Cerchio(double r)
    {
        Raggio = r;
    }
    public final double Circonferenza()
    {
        return 2*Raggio*Math.PI;
    }
    public double Area()
    {
        return (Raggio*Raggio*Math.PI);
    }
}

final class Cilindro extends Cerchio
{
    private double altezza;

    /** Costruttore degli oggetti di classe  Cilindro */
    public Cilindro(double r, double h)
    {
        super(r);       // riferimento alla sopraclasse
        this.altezza=h; // this => riferimento all'oggetto stesso
    }
    // Overriding del metodo Area
    public double Area()
    {
        // Richiama il metodo Area() della sopraclasse 
        // Circonferenza non richiede super poichè viene ereditato e non viene sovrascritto
        return super.Area()*2+Circonferenza()*altezza;
    }
    public double Volume()
    {
        // Richiama il metodo Area() della sopraclasse
        return super.Area()*altezza;
    }
}

public class ProgCilindro
{
    public static void main (String args[])
    {
        Cilindro c = new Cilindro(5,10);
        System.out.println("Circonferenza: "+c.Circonferenza()); // Metodo ereditato
        System.out.println("Superficie    : "+c.Area());  // Metodo ridefinito (overriding)
        System.out.println("Volume       : "+c.Volume()); // Nuovo metodo
        Cerchio base=(Cerchio)c; 
        System.out.println("Area base     : "+base.Area()); 
    }
}

C:\Users\Marco\Desktop\progettoVector>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Elenco.java

C:\Users\Marco\Desktop\progettoVector>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" ProgrElenco.java

C:\Users\Marco\Desktop\progettoVector>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" ProgrElenco
Lista numeri:
1) Valore: 1
2) Valore: 2
Lista numeri:
1) Valore: 3
2) Valore: 4
3) Valore: 5
4) Valore: 6

import java.util.Vector;

class Elenco
{
    private Vector<Integer> Valori;

    public Elenco()
    {
        Valori=new Vector<Integer>();
    }
    public Elenco(int...Numeri)
    {
        Valori=new Vector<Integer>();
        for (int X : Numeri)              
            Valori.addElement(X);
    }
    public void Aggiungi(int X)
   {
        Valori.addElement(X);
    }
    public void Togli(int posiz)
    {
        try 
        {
            Valori.removeElement(posiz);
        } 
        catch (Exception e) 
        {
            System.out.println("Non ho elementi:");
            return;
        }
    }
    public void Stampa()
    {
        System.out.println("Lista numeri: ");
        for (int i=0; i < Valori.size(); i++)
             System.out.println((i+1)+") Valore: "+(int)Valori.elementAt(i));
    }
}

public class ProgrElenco
{
    public static void main (String args[])
    {
        Elenco X=new Elenco();
        X.Aggiungi(1);
        X.Aggiungi(2);
        X.Stampa();
        Elenco Y=new Elenco(3,4,5,6);
        Y.Stampa();
    }
}

Per compilare ed eseguire scriviamo:

C:\Users\Marco\Desktop\Java\array1> "C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Array1.java

C:\Users\Marco\Desktop\Java\array1>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" Array1
Digita il 1^ elemento del vettore: 1
Digita il 2^ elemento del vettore: 2
Digita il 3^ elemento del vettore: 3
Digita il 4^ elemento del vettore: 4
Digita il 5^ elemento del vettore: 5
Digita il 6^ elemento del vettore: 6
Digita il 7^ elemento del vettore: 7
Digita il 8^ elemento del vettore: 8
Digita il 9^ elemento del vettore: 9
Digita il 10^ elemento del vettore: 10
Il vettore contiene i seguenti elementi: | 1 |2 |3 |4 |5 |6 |7 |8 |9 |10 |

C:\Users\Marco\Desktop\Java\array1>

In questo caso l'uso dei vettori non è dissimile alle modalità viste in altri linguaggi

import java.io.*;
// Per esempi da svolgere: 
//    http://www.dis.uniroma1.it/~liberato/java/Array.html
public class Array1
{
   public static void main (String args[])  throws Exception
   {
        // Impostazione per lo standard input
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader Tastiera = new BufferedReader(input);
        int i;
        int v[]=new int[10];
        String Linea;
        // Lettura dati e memorizzazione nel vettore
        for (i=0 ; i < v.length ; i++)
        {
            System.out.print("Digita il "+(i+1)+"^ elemento del vettore: ");
            Linea=Tastiera.readLine();
            v[i]=Integer.parseInt(Linea);
        }
        // Stampa dati letti
        System.out.print("Il vettore contiene i seguenti elementi: | ");
        for (i=0 ; i < v.length ; i++)
            System.out.print(v[i]+" |");
        System.out.println("");
        
   }
}

C:\Users\Marco\Desktop\Java\gui1>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" gui1.java

C:\Users\Marco\Desktop\Java\gui1>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" Gui1

JOptionPane.
INFORMATION_MESSAGE	WARNING_MESSAGE	QUESTION_MESSAGE	ERROR_MESSAGE

import javax.swing.*;
public class Gui1 
{
    // --------------------------------------------------------------------------
    // http://docs.oracle.com/javase/tutorial/uiswing/components/dialog.html
    // --------------------------------------------------------------------------
    public static void main(String[] args) 
    {
       String s;
       // ----------------------------------------------------------------------------------------
       // Finestra di dialogo con 3 bottoni con etichetta personalizzata
       // argomento1 => componente padre (deve essere un frame, una componente in un frame o null)
       // argomento2 => testo che spiega la richiesta
       // argomento3 => titolo sulla finestra
       // argomento4 => icona : JOptionPane.INFORMATION_MESSAGE, JOptionPane.ERROR_MESSAGE , 
       //               JOptionPane.WARNING_MESSAGE, JOptionPane.QUESTION_MESSAGE, 
       //               JOptionPane.PLAIN_MESSAGE (nessuna icona)
       // argomento5 => bottoni : JOptionPane.DEFAULT_OPTION, JOptionPane.YES_NO_OPTION, 
       //               JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.OK_CANCEL_OPTION
       // ----------------------------------------------------------------------------------------
       // showInputDialog con listbox
       // ----------------------------------------------------------------------------------------
       Object[] Valori = {"showInputDialog", "showOptionDialog", "showMessageDialog"};
       s=(String)JOptionPane.showInputDialog(null,"Scegli il tipo di finestra di dialogo da provare: ", "Input con ListBox", 
                                             JOptionPane.QUESTION_MESSAGE, 
                                             null,       // indico che non voglio usare un'icona personalizzata
                                             Valori,     // i valori nel listbox
                                             Valori[0]); // valore di default
       if (s==Valori[0])
       {
           // ----------------------------------------------------------------------------------------
           // showInputDialog: Finestra di dialogo per chiedere all'utente un valore
           // ----------------------------------------------------------------------------------------
           s=JOptionPane.showInputDialog(null, "Digita qualcosa: ","Titolo Finestra",JOptionPane.QUESTION_MESSAGE);
           // Finestra di dialogo con messaggio - Utile per avvisare l'utente
           s="Hai digitato: " + s;
       }
       else if (s==Valori[1])
       {
           Object[] Etichette = {"Bottone SI", "Bottone NO", "Bottone CANCEL"};
           int risposta = JOptionPane.showOptionDialog(null, 
                                                   "Clicca su uno dei bottoni: ", "Titolo: Esempio showOptionDialog", 
                                                   JOptionPane.YES_NO_CANCEL_OPTION,
                                                   JOptionPane.QUESTION_MESSAGE,
                                                   null,          // indico che non voglio usare un'icona personalizzata
                                                   Etichette,     // le etichette dei bottoni
                                                   Etichette[2]); // etichetta del bottone di default
           /* -- Esempio con 2 bottoni
           int risposta = JOptionPane.showConfirmDialog(null, 
                                                   "Clicca su uno dei bottoni: ", "Titolo: Esempio showOptionDialog", 
                                                   JOptionPane.YES_NO_CANCEL_OPTION ); // etichette dei bottoni standard
           */
           if (risposta==JOptionPane.YES_OPTION)
              s="Hai cliccato su \"Bottone SI\"";
           else if (risposta==JOptionPane.NO_OPTION)
              s="Hai cliccato su \"Bottone NO\"";
           else if (risposta==JOptionPane.CANCEL_OPTION)
              s="Hai cliccato su \"Bottone CANCEL\"";
           else
              s="Non hai cliccato su nessun bottone SI, NO, CANCEL";
       }
       else if (s==Valori[2])
       {
           JOptionPane.showMessageDialog(null, "Esempio di \"showMessageDialog\"","titolo",JOptionPane.WARNING_MESSAGE);
           System.exit(0); // Uscita dal programma
       }
       else
       {
           JOptionPane.showMessageDialog(null, "Non hai selezionato alcuna finestra di dialogo","titolo",JOptionPane.ERROR_MESSAGE);
           System.exit(0); // Uscita dal programma
       }
       JOptionPane.showMessageDialog(null, s,"titolo",JOptionPane.INFORMATION_MESSAGE);
    }
}

Per compilare ed eseguire scriviamo:

C:\Users\Marco\Desktop\Java\gui2>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" Gui2.java

C:\Users\Marco\Desktop\Java\gui2>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" Gui2

L'applicazione che viene generata gestisce i seguenti menu:

Compiliamo il seguente sorgente:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.EtchedBorder;

public class Gui2
{
    public static void main(String arqs[])
    {
        // **************************************
        // GESTIONE DELLA FINESTRA
        // **************************************
        JFrame finestra = new JFrame("Esempio GUI con Swing");
        finestra.setBounds(200, 200, 400, 200);
        finestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) ; // Altrimenti non chiude la finestra ma la nasconde
        
        // **************************************
        // GESTIONE BARRA DI STATO
        // **************************************
        final JLabel StatusBar = new JLabel("Barra di stato");
        StatusBar.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
        finestra.add(StatusBar, BorderLayout.SOUTH);
        
        // **************************************
        // GESTIONE TOOLBAR (CON 1 BOTTONE)
        // **************************************
        JToolBar ToolBar = new JToolBar();
        JButton exitButton = new JButton(new ImageIcon("exit.png"));
        ToolBar.add(exitButton);
        finestra.add(ToolBar, BorderLayout.NORTH); // sistemo il toolbar in alto
        
        // **************************************
        // GESTIONE DEL SOTTOMENU L 
        // **************************************
        // -----------------------------------------------
        // 1° Voce: menu normale -------------------------
        // -----------------------------------------------
        JMenuItem sub_L1_mnu=new JMenuItem("SottoMenu L1 - Normale");
        sub_L1_mnu.setMnemonic(KeyEvent.VK_L);  // Mette ALT+L come ShortCut
        sub_L1_mnu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_L, ActionEvent.ALT_MASK));
        // -----------------------------------------------
        // 2° Voce: menu con sottomenu radio ----
        // -----------------------------------------------
        JMenu sub_rb_mnu = new JMenu("SottoMenu L2 - Radio Button");
        // 1° Voce con radio button
        JRadioButtonMenuItem rbMenuItem1 = new JRadioButtonMenuItem("Scelta 1");
        rbMenuItem1.setMnemonic(KeyEvent.VK_1); // Mette ALT+1 come ShortCut
        rbMenuItem1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_1, ActionEvent.ALT_MASK));
        // 2° Voce con radio button
        JRadioButtonMenuItem rbMenuItem2 = new JRadioButtonMenuItem("Scelta 2");
        rbMenuItem2.setMnemonic(KeyEvent.VK_2);  // Mette ALT+1 come ShortCut
        rbMenuItem2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_2, ActionEvent.ALT_MASK));
        // Raggruppo i 2 radio button in modo che funzionino in modo mutuamente esclusivo
        ButtonGroup GruppoRadio = new ButtonGroup();
        GruppoRadio.add(rbMenuItem1);
        GruppoRadio.add(rbMenuItem2);
        // Aggiungo le 2 voci al SottoMenu L2
        sub_rb_mnu.add(rbMenuItem1);
        sub_rb_mnu.add(rbMenuItem2);
        // -----------------------------------------------
        // 3° Voce: menu con CheckBox --------------------
        // -----------------------------------------------
        JCheckBoxMenuItem sub_cb_Mnu = new JCheckBoxMenuItem("SottoMenu L3 - Nascondi Status Bar");
        sub_cb_Mnu.setState(true); // metto la spunta sul Check Box
        // -----------------------------------------------
        // 4° Voce: menu con Icona -----------------------
        // -----------------------------------------------
        JMenuItem sub_ico_mnu = new JMenuItem("Esci", new ImageIcon("exit.png"));
        sub_ico_mnu.setAccelerator(KeyStroke.getKeyStroke("alt F4"));

        // **************************************
        // GESTIONE DEL SOTTOMENU R
        // **************************************
        // 1° Voce: sottomenu gerarchico
        JMenu sub_R1_mnu=new JMenu("SottoMenu R1 - Gerarchico");
        JMenu sub_R1_A_mnu=new JMenu("SottoMenu R1->A");
        JMenu sub_R1_B_mnu=new JMenu("SottoMenu R1->B");
        String[ ] MenuItemsA = new String[ ] { "SottoMenu R1->A->a", "SottoMenu R1->A->b", "SottoMenu R1->A->c", "SottoMenu R1->A->d" };                                     
        String[ ] MenuItemsB = new String[ ] { "SottoMenu R1->B->a", "SottoMenu R1->B->b" };
        for (int i=0; i < MenuItemsA.length; i++) 
            sub_R1_A_mnu.add(new JMenuItem(MenuItemsA[i]));
        for (int i=0; i < MenuItemsB.length; i++) 
            sub_R1_B_mnu.add(new JMenuItem(MenuItemsB[i]));
        sub_R1_mnu.add(sub_R1_A_mnu);
        sub_R1_mnu.add(sub_R1_B_mnu);

        // **************************************
        // GESTIONE BARRA DEI MENU PRINCIPALE
        // **************************************
        JMenuBar barraMenu =new JMenuBar(); // Barra principale
        finestra.setJMenuBar(barraMenu);

        // -----------------------------------------------
        // Crea gli elementi della Barra Menu principale
        // -----------------------------------------------
        JMenu subMn1 =new JMenu("Menu L");  // 1° menu
        subMn1.setMnemonic(KeyEvent.VK_L);
        JMenu subMn2 =new JMenu("Menu R");  // 2° menu
        subMn2.setMnemonic(KeyEvent.VK_R);
        // --------------------------------------
        // Aggancio i 4 sottomenu del Menu L
        // --------------------------------------
        subMn1.add(sub_L1_mnu);
        subMn1.addSeparator();
        subMn1.add(sub_rb_mnu);
        subMn1.add(sub_cb_Mnu);
        subMn1.addSeparator();
        subMn1.add(sub_ico_mnu);
        // --------------------------------------
        // Aggancio l'unico sottomenu del Menu R
        // --------------------------------------
        subMn2.add(sub_R1_mnu);
        // --------------------------------------
        // Aggancio i menu L e R alla barra principale
        // --------------------------------------
        barraMenu.add(subMn1);
        barraMenu.add(Box.createHorizontalGlue()); // Menu completamente a destra
        barraMenu.add(subMn2);
 
        // **************************************
        // GESTIONE DEL POPUP
        // **************************************
        JPopupMenu popup = new JPopupMenu();
        // -----------------------------------------------
        // 1° Voce: menu con sottomenu -------------------
        // -----------------------------------------------
        JMenu sub_menu = new JMenu("SottoMenu PU - Gerarchico");
        sub_menu.add(new JMenuItem("SottoMenu PU->A"));
        sub_menu.add(new JMenuItem("SottoMenu PU->B"));
        // -----------------------------------------------
        // 2° Voce: menu con Icona -----------------------
        // -----------------------------------------------
        JMenuItem sub_ico_pu_mnu = new JMenuItem("Esci", new ImageIcon("exit.png"));
        // --------------------------------------
        // Aggancio i 2 sottomenu al PopUp Menu
        // --------------------------------------
        popup.add(sub_menu);
        popup.add(sub_ico_pu_mnu);
        
        finestra.setVisible(true); // completata la preparazione rendo visibile il frame

        // =======================================================================
        // =======================================================================
 
        // **************************************
        // GESTIONE EVENTI
        // **************************************
        // Eventi per i 
        ActionListener GestoreClick = new ActionListener(  )
        {
            public void actionPerformed(ActionEvent event) 
            {
                JOptionPane.showMessageDialog(null,"Click sul Menu[" + event.getActionCommand(  ) + "]" ,"Menu Selezionato",JOptionPane.INFORMATION_MESSAGE);
            }
        };
        sub_L1_mnu.addActionListener(GestoreClick);
        // 1° modo per scorrere i sottomenu
        for (int i=0; i < sub_R1_A_mnu.getItemCount(); i++)
            (sub_R1_A_mnu.getItem(i)).addActionListener(GestoreClick);
        // 2° modo per scorrere i sottomenu
        Component[] subMenus = sub_R1_B_mnu.getMenuComponents();
        for (Component subMenu : subMenus) 
            if (subMenu instanceof JMenuItem)
               ((JMenuItem)subMenu).addActionListener(GestoreClick);
        // Potevo usare un for di questo tipo:
        //  for (int i=0; i < subMenus.length; i++)
        //      if (subMenus[i] instanceof JMenuItem)
        //         ((JMenuItem)subMenus[i]).addActionListener(GestoreClick);
        
        // --------------------------------------
        // Gestione uscita applicazione
        // --------------------------------------
        ActionListener AzioneEsci =new ActionListener() 
        {
            @Override
            public void actionPerformed(ActionEvent event) 
            {
                System.exit(0);
            }
        };
        exitButton.addActionListener(AzioneEsci);
        sub_ico_mnu.addActionListener(AzioneEsci);
        sub_ico_pu_mnu.addActionListener(AzioneEsci);
        
        // --------------------------------------
        // Gestione movimento del mouse
        // --------------------------------------
        MouseAdapter MotoMouse =new MouseAdapter() 
        {
             @Override
             public void mouseMoved(MouseEvent e)
             {
                 Object x=(Object)(e.getSource());
                 // Estraggo in nome della classe
                 String className = x.getClass().getName();
                 String[] split = className.split("\\.");
                 int lastIndex = split.length - 1;
                 className= (lastIndex >= 0) ? split[lastIndex] : className;
                 StatusBar.setText(className+" : "+ e.getX()+", "+e.getY());
             }
        };
        finestra.addMouseMotionListener(MotoMouse);
        ToolBar.addMouseMotionListener(MotoMouse);
        subMn1.addMouseMotionListener(MotoMouse);
        subMn2.addMouseMotionListener(MotoMouse);

        // --------------------------------------
        // Gestione menu con checkbox per occultare la status bar
        // --------------------------------------
        sub_cb_Mnu.addActionListener(new ActionListener() 
        {
            @Override
            public void actionPerformed(ActionEvent event) 
            {
                  JCheckBoxMenuItem source = (JCheckBoxMenuItem)(event.getSource());
                  if (StatusBar.isVisible()) 
                  {
                      StatusBar.setVisible(false);
                      source.setText("SottoMenu L3 - Mostra Status Bar");
                  } 
                  else 
                  {
                      StatusBar.setVisible(true);
                      source.setText("SottoMenu L3 - Nascondi Status Bar");
                  }
            }
        });

        // -------------------------------------------------
        // Aggiungo le routine evento per il popup menu che lo
        // rende visibile con i click destro del mouse
        // -------------------------------------------------
        PopupListener popupListener = new PopupListener(popup);
        finestra.addMouseListener(popupListener);
        
        finestra.setVisible(true); // completata la preparazione rendo visibile il frame
    }

    // --------------------------------------
    // Per gestire il PopUp Menu
    // --------------------------------------
    static class PopupListener extends MouseAdapter 
    {
        JPopupMenu popup;
 
        PopupListener(JPopupMenu popupMenu) {
            popup = popupMenu;
        }
 
        public void mousePressed(MouseEvent e) {
            maybeShowPopup(e);
        }
 
        public void mouseReleased(MouseEvent e) {
            maybeShowPopup(e);
        }
 
        private void maybeShowPopup(MouseEvent e) {
            if (e.isPopupTrigger()) {
                popup.show(e.getComponent(),
                           e.getX(), e.getY());
            }
        }
    }
}

Ecco la gerarchia delle classi correlate ai menu di Java:

L'esempio è stato costruito consultando i seguenti link: http://docs.oracle.com/javase/tutorial/uiswing/components/menu.html e http://zetcode.com/tutorials/javaswingtutorial/menusandtoolbars/ .

C:\Users\Marco\Desktop\Java\gui2>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" ProgDisegno.java

C:\Users\Marco\Desktop\Java\gui2>"C:\Program Files\Java\jdk1.7.0_21\bin\java.exe" ProgDisegno

import java.awt.*;
import java.awt.event.*;

public class ProgDisegno
{
	public static void main (String argv[])
	{
		// Finestra
		Frame f=new Frame("Disegno");
		f.setIconImage(Toolkit.getDefaultToolkit().getImage("Exit.png")); // Imposto l'icona
		// Non è un JFrame per cui non posso usere:
		// f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setSize(300,300);
		f.setLocation(100,100);
		f.setLayout(new BorderLayout());
		f.setVisible(true);
		
		Panel p=new BorderPanel();
		// Etichetta
		Label l=new Label("Colore linee: ");
		l.setBackground(Color.gray);
		l.setForeground(Color.white);
		p.add(l);
		// Listbox
		Choice colori = new Choice();
		colori.addItem("rosso");
		colori.addItem("verde");
		colori.addItem("blu");
		p.add(colori);
		// Bottone
		Button b=new Button("Reset colore");
		p.add(b);
		f.add(p,"South");
		
		// Canvas - La direttiva final consente la visibilità di a all'interno del listener
		final Area a = new Area(); // Dichiarandolo come Final è visibile nel listener
		a.setName("AreaDisegno");
		f.add(a);
		
		// **************************************
		// GESTIONE EVENTI
		// **************************************
		p.addMouseListener(new MyMouseListener());
		f.addWindowListener(new GestoreFinestra()); 
		b.addActionListener(new ActionListener() 
		{
			public void actionPerformed(ActionEvent e)
			{
				a.ridisegna(Color.GRAY);
				// Se non avessi dichiarato la variabile "a" come final
				// dovevo utilizzare questa porzione di codice
				// Panel p=(Panel) ((Button)e.getSource()).getParent();
				// Frame f =(Frame)p.getParent();
				// Area b=(Area)findComponentByName(f,"AreaDisegno",0);
				// if (b==null) return;
				// b.ridisegna(Color.GRAY);
			}
		});

		colori.addItemListener(new ItemListener() 
		{
			public void itemStateChanged(ItemEvent e) 
			{
				if (e.getStateChange() == ItemEvent.SELECTED) 
				{
					Choice choice = (Choice)e.getSource();
					String selection = choice.getSelectedItem();
					if (selection.equals("rosso"))
						a.ridisegna(Color.RED);
					else if (selection.equals("blu"))
						a.ridisegna(Color.BLUE);
					else if (selection.equals("verde"))
						a.ridisegna(Color.GREEN); 
				}
			}
		});
	}

	// private static Component findComponentByName(Container container, String componentName, int lev) 
	// {
	// 		for (Component component: container.getComponents()) 
	// 		{
	//	 		Component c;
	// 			System.out.println(lev + ") - " + component.getClass().getName() + " - " + component.getName());
	// 			if (componentName.equals(component.getName() ))
	// 				return component;
	// 			if (component instanceof Container) 
	// 			{
	// 				Container newContainer = (Container)component;
	// 				c=findComponentByName(newContainer, componentName, lev+1);
	// 				if (c!=null) return c;
	// 			}
	// 		}
	// 		return null;
	// }
}

class Area extends Canvas
{
	// Metodo paint richiamato quando la classe canvas viene visualizzata
	public void paint(Graphics g)
	{
		Dimension size = getSize();
		this.ridisegna(Color.red);
		int stringLen = (int)g.getFontMetrics().getStringBounds("LINEE PARALLELE", g).getWidth();
		int stringHeight = (int)g.getFontMetrics().getStringBounds("LINEE PARALLELE", g).getHeight();
		int start = size.width/2 - stringLen/2;
		g.drawString("LINEE PARALLELE",start,size.height-8);
		Graphics2D g2d = (Graphics2D) g;
		//float dash[] = {10.0f};
		Stroke dashed = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 0, new float[] {3}, 0);
		g2d.setStroke(dashed);
		g.drawRect(2,2,size.width-5, size.height-5);
	}
	public void ridisegna(Color c)
	{
		Dimension size = getSize();
		Graphics g = this.getGraphics();
		g.setColor(c);
		for (int i=0; i <5 ; i++)
			g.drawLine(2,2+10*i,size.width-5, size.height-50+10*i);
	}
}

class BorderPanel extends Panel 
{
	public void paint(Graphics g)
	{
		Dimension size = getSize();
		g.setColor(Color.GRAY);
		g.fillRect(0, 0, size.width, size.height);
		g.setColor(Color.BLACK);
		g.drawRect(2,2,size.width-5, size.height-5); // bordo a 2 pixel dal limite del pannello
	}
}

class GestoreFinestra implements WindowListener
{
	// WindowListener contiene dei metodi astratti che vengono ereditati dalla classe GestoreFinestra
	// Quest'ultima non essendo astratta deve implementare tutti i metodi ereditati dal Listener
	public void windowIconified(WindowEvent e) {}
	public void windowDeiconified(WindowEvent e) {}
	public void windowActivated(WindowEvent e) {}
	public void windowDeactivated(WindowEvent e) {}
	public void windowOpened(WindowEvent e) {}
	public void windowClosed(WindowEvent e) {}
	public void windowClosing(WindowEvent e) { System.exit(0); }
}

class MyMouseListener implements MouseListener 
{
	// MouseListener contiene dei metodi astratti che vengono ereditati dalla classe MyMouseListener
	// Quest'ultima non essendo astratta deve implementare tutti i metodi ereditati dal Listener
	public void mousePressed(MouseEvent e) { System.out.println("Bottone del mouse premuto!"); }
	public void mouseReleased(MouseEvent e) { System.out.println("Bottone del mouse rilasciato!"); }
	public void mouseClicked(MouseEvent e) { System.out.println("Click sul mouse (premuto e rilasciato)!"); }
	public void mouseEntered(MouseEvent e) { System.out.println("Cursore del mouse entrato nella componente!"); }
	public void mouseExited(MouseEvent e) { System.out.println("Cursore del mouse uscito dalla componente!"); }
}

C:\Users\Marco\Desktop\Java\gui1>"C:\Program Files\Java\jdk1.7.0_21\bin\javac.exe" applet1.java

C:\Users\Marco\Desktop\Java\gui1>"C:\Program Files\Java\jdk1.7.0_21\bin\appletviewer.exe" index.htm

...