When i clicked on the button "cancel" of the first JoptionPane in
Inizializza(), return this error:

java.lang.NullPointerException
       at QuadratoMagico.inizializza(QuadratoMagico.java:469)
       at QuadratoMagico.<init>(QuadratoMagico.java:41)
       at QuadratoTest.main(QuadratoTest.java:12)

I want that after i pressed the button "cancel" of JoptionPane the program
exit without any error.
thx!!!!.

import java.awt.*;
import java.awt.event.*;
import java.util.Random;
import javax.swing.*;

/**
*Un oggetto QuadratoMagico rappresenta un pannello grafico:
*Il pannello realizza un ambito grafico in cui ? possibile visualizzare una
griglia di interi
*scegliendo fra 5 tipi:
*- Matrice vuota
*- Matrice random
*- Matrice random 2
*- Quadrato magico
*- Quadrato magico incompleto
*/

public class QuadratoMagico extends JFrame  {
  /**dichiarazione della variabile dimensione della griglia */
  private static int  N;
  /**Variabili  array che conterrano i valori per la realizzazione della
griglia*/
  private int[][] ArrayVuoto;
  private int[][] ArrayRandom1;
  private int[][] ArrayRandom2;
  private int[][] ArrayPerfetto;
  private int[][] ArrayQuasiPerfetto;
  private int[][] mat;
  private JButton[][] jb;

  /**Inizializza i 3 pannelli che conterranno rispettivamente: Griglia,
Men? a tendina, Pulsante "verifica"*/
  private JPanel pannello = new JPanel();  // crea il nuovo oggetto Jpannel
  private JPanel pannello2= new JPanel();
  private JPanel pannello3= new JPanel();

  /**Inizializza il bottone "verifica" e il menu a tendina"scelta array"*/
  private JButton Verifica= new JButton("verifica");
  private JComboBox SceltaArray;

  /**Metodo che inizializza il programmma*/
public QuadratoMagico()
  {
    inizializza(); //Richiama il metodo per la inizializzazione degli array
in base al valore N inserito
    ArrayVuoto=MatriceVuota(); //assegna alla variabile ArrayVuoto il
valore di ritorno del metodo MatriceVuota
    ArrayRandom1=MatriceRandom();//assegna alla variabile ArrayVuoto il
valore di ritorno del metodo MatriceRandom
    ArrayRandom2=MatriceRandom();//assegna alla variabile ArrayVuoto il
valore di ritorno del metodo MatriceRandom
    ArrayPerfetto=MatricePerfetta();//assegna alla variabile ArrayVuoto il
valore di ritorno del metodo MatricePerfetta
    ArrayQuasiPerfetto=MatriceQuasiPerfetta();//assegna alla variabile
ArrayVuoto il valore di ritorno del metodo MatriceQuasiPerfetta

    /*Inserimento degli elementi nel men? a tendina*/
    SceltaArray=new JComboBox();    // crea il nuovo oggetto JComboBox
    SceltaArray.addItem("<seleziona>");  //inserisce i nuove elementi in
cascata
    SceltaArray.addItem("Matrice vuota");
    SceltaArray.addItem("Matrice Random");
    SceltaArray.addItem("Matrice Random 2");
    SceltaArray.addItem("Matrice con quadrato magico");
    SceltaArray.addItem("Matrice con quadrato magico incompleto");
    SceltaArray.setEditable(true);      //Metodo per visualizzare il men?
tendina in formato editabile
  SceltaArray.addActionListener(new ChoiceListener());  //Aggiunge un
ActionListener al men? a tendina che genera gli eventi
    Verifica.addMouseListener(new MouseInterceptor());//aggiunge un
mouseListener al pulsante

    pannello3.add(Verifica); // aggiunge al pannello3 il pulsante
    pannello2.add(SceltaArray); // aggiunge al pannello 2 il men? a tendina

    /*Assegna dimensioni e posizione all'interno del Jframe*/
    pannello3.setPreferredSize(new Dimension(120, 100));
    pannello2.setPreferredSize(new Dimension(120, 100));
    getContentPane().add(pannello2, BorderLayout.NORTH); //contiene il men?
a tendina
    getContentPane().add(pannello, BorderLayout.CENTER); //contiene la
futura griglia
    getContentPane().add(pannello3, BorderLayout.SOUTH); //contiene il
pulsante

  }

  /**Implementazione del ricevitore per le azioni del mouse rispettivo al
pulsante residente nella griglia*/

  private ActionListener buttonListener = new ActionListener()

  {
    public void actionPerformed(ActionEvent e)
    {
      JButton pressedButton = (JButton) e.getSource(); //Variabile pulsante
di appoggio per la risoluzione del metodo

      // Prende la riga e la colonna usufruendo del comando
getClientProperty e le memorizza negli indici row e col
      int riga = ((Integer)
pressedButton.getClientProperty("MAT_ROW")).intValue();
      int colonna = ((Integer)
pressedButton.getClientProperty("MAT_COL")).intValue();

      int valore = mat[riga][colonna]; //Memorizza il valore dell'array
degli indici riportati in una varibiale intera

      /*Richiama il metodo showInputDialog per l'inserimente di un nuovo
valore, e visualizza come intero di default il valore
       *dell'elemento della matrice che si sta per modificare, il valore
inserito sara memorizzato
       *nella variabile stringa input*/

      String input =  JOptionPane.showInputDialog(QuadratoMagico.this,
"Inserisci un nuovo valore:", Integer.toString(valore));

      if (input != null) //condizione utile per non permettere all'utente
di non cancellera il dialog
      {
        try
        {
          valore = Integer.parseInt(input.trim());   //assegnamo a "valore"
il contenuto in intero di input, privo di spazzi grazie al metodo  trim()

          /* per soddisfare la propriet? del quadrato magico il valore
inserito deve essere compreso tra 1 e NxN*/
          if (valore > 0 && valore < N*N)
          {
            mat[riga][colonna] = valore;   //se il valore ? compreso tra 1
e NxN assegnamo all'array il nuovo valore inserito dall'utente
            pressedButton.setText(Integer.toString(valore)); //cambiamo il
nome al pulsante con il nuovo valore inserito
          }
          else
          {
            throw new NumberFormatException(
              "value must be >= 0 and < " + N*N);
          }
        }
        catch (NumberFormatException ex)
        {
          /*se l'input non ? valido appare una messaggio di errore e
l'intero all'interno dell'array non verr? modificato*/
          JOptionPane.showMessageDialog(QuadratoMagico.this, "Valore
inserito: " + input + "\n" + ex.getMessage(),
            "hai inserito un valore non valido, inserire un intero",
JOptionPane.ERROR_MESSAGE);
        }
      }
    }
  };

  /**La classe MouseAdapter inplementa l'interfaccia MouseListener in modo
che tutti i metodi non facciano nulla
   *la classe MouseAdaptor viene estesa ereditando tutti i metodi e
sovrascrivendo solo il metodo necessario: mouseClicked*/

   public class MouseInterceptor extends MouseAdapter{
 public void mouseClicked(MouseEvent event) {
  if (verifica(mat))      //Se il metodo verifica() restituisce il valore
"true"..
              JOptionPane.showMessageDialog(QuadratoMagico.this,"? un
quadrato magico");     //il metodo showMessageDialog mostra il messaggio "?
un quadrato magico"
           else
              JOptionPane.showMessageDialog(QuadratoMagico.this,"non ? un
quadrato magico");   //il metodo showMessageDialog mostra il messaggio "non
? un quadrato magico"
  }

}

  /**Implementazione del ricevitore di eventi del men? a tendina
"SceltaArray"*/
  private class ChoiceListener implements ActionListener {

 public void actionPerformed(ActionEvent event) {

     /*la variabile stringa riceve la stringa dell'elemento selezionato nel
men? a tendina*/
     String SceltaCorrente=(String)SceltaArray.getSelectedItem();

     /*usiamo una serie di condizioni per assagnare all'array mat,
utilizzato dal metodo CreaPannello, il respettivo array*/
     if (SceltaCorrente=="Matrice vuota"){
         mat = ArrayVuoto;
         CreaPannello();
     }

     if (SceltaCorrente=="Matrice Random"){
         mat = ArrayRandom1;
         CreaPannello();
     }

     if (SceltaCorrente=="Matrice Random 2"){
         mat = ArrayRandom2;
         CreaPannello();
     }

     if (SceltaCorrente=="Matrice con quadrato magico"){
         mat = ArrayPerfetto;
         CreaPannello();
     }

     if (SceltaCorrente=="Matrice con quadrato magico incompleto"){
         mat = ArrayQuasiPerfetto;
         CreaPannello();
     }

   }
}

/** Metodo per creare un pannello in cui verr? visualizata la griglia di
pulsanti*/
public void CreaPannello(){

JButton pulsante; //dichiaro una variabile istanza di appoggio

pannello.invalidate();  //invalida il pannello
pannello.removeAll();   //rimuove il contenuto del pannello
pannello.setLayout(new GridLayout(N, N));  //imposta il Layout come griglia
di dimensione N x N
    for (int i = 0; i < N; i++)
      for (int j = 0; j < N; j++)
      {

       /*per visualizzare un pulsante con testo inesistente (nel caso che
l'elemento dell'array abbia un valore uguale a 0)
        *o un pulsante contenente come testo il valore dell'array (nel caso
che l'elemento dell'array abbia un valore diverso da 0)
        *? stata implementata una condizione su mat[i][j] che, se viene
soddisfatta, crea un pulsante privo di scritte e colorato
        *altrimenti un pulsante con all'interno il valore dell'array*/

        if (mat[i][j] == 0){
         pulsante = new JButton("");      //associa alla variabile pulsante
un nuovo oggetto JButton con stringa vuota
         pulsante.setBackground(Color.cyan); //imposta il colore al
pulsante
        }
        else{
         pulsante = new JButton(Integer.toString(mat[i][j])); //associa
alla variabile pulsante un nuovo oggetto Jbutton contenet il valore intero
dell'array mat
        }

        jb[i][j] = pulsante; //assegna all'array di pulsanti il pulsante
creato

        /*Per risolvere il problema dell'identificazione della posizione
pulsante all'interno della griglia, per cos?
         *associarlo alla esatta posizione del valore interno all'array
"mat" ci serviamo del metodo putClientProperty()
         *che ci permette di associare al pulsante il nome di una variabile
e il rispettivo valore.
         *In questo caso gli associamo a ogni pulsante due variabili:
         *PROP_MAT_ROW: che conterra un nuovo intero con indice i per le
righe.
         *PROP_MAT_COL: che conterra un nuovo intero con indice j per le
colonne*/

        pulsante.putClientProperty("MAT_ROW", new Integer(i));
        pulsante.putClientProperty("MAT_COL", new Integer(j));
        pulsante.addActionListener(buttonListener); //mettiamo il pulsante
in ascolto

        }

     /* al termine dell'inserimento dei pulsanti nell'array di pulsanti
"jb" procediamo all'aggiunta del contenuto di
      *jb all'interno del "pannello"*/
       for (int i = 0; i < jb.length; i++)
             for (int j = 0; j < N; j++)
                    pannello.add(jb[i][j]); //aggiunge pulsante nella
griglia

     pannello.repaint();   //ridisegna pannello
     pannello.validate();  //valida pannello
     }

   /**Metodo che restituisce una array di valori nulli.
    *@return :Array restituisce l'array*/
   public static int[][] MatriceVuota(){
    int[][] Array= new int[N][N]; //Variabile Array di appoggio
    for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
               Array[i][j] = 0;
        return Array;
    }

   /**Metodo che restituisce una array di valori random.
    *@return :Array restituisce l'array*/
    public static int[][] MatriceRandom(){
    int[][] Array= new int[N][N]; //Variabile array di appoggio
    int Res;

     for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++){
               /**il metodo random restituisce un valore casuale tra 0 e
N*N*/
               Res = (int)(Math.random()*(N*N));
               Array[i][j] = Res+1;
               }
        return Array;
       }

     /**Metodo che restituisce una array i cui valori costituiscono un
quadrato magico.
    *@return :Array restituisce l'array*/
    public static int[][] MatricePerfetta(){
          int[][] Array = new int[N][N]; //Variabile array di appoggio
          int i, j, k, l, chiave;

          for (i=0;i<N;i++)
              for (j=0;j<N;j++)
                Array[i][j] = 0;

           Array[0][(int)(N-1)/2] = 1;
           /* Costruzione del quadrato magico*/
           chiave = 2;
           i = 0;
           j = (int)(N-1)/2;
           while ( chiave <= N*N )
           {
              k = i - 1;

              if ( k < 0 )
                    k += N;

              l = j - 1;

              if ( l < 0 )
                    l += N;

              if ( Array[k][l] != 0 )
                          i = (i+1) % N;
              else {
                   i = k;
                   j = l;
                   }

              Array[i][j] = chiave;
              chiave++;
           }
        return Array;
      }

     /**Metodo che restituisce una array i cui valori costituiscono un
quadrato magico incompleto.
    *@return :Array restituisce l'array*/
   public static int[][] MatriceQuasiPerfetta(){
          int[][] Array = new int[N][N];
          int i, j, k, l, n, chiave, Pro;

           for (i=0;i<N;i++)
              for (j=0;j<N;j++)
                Array[i][j] = 0;

           Array[0][(int)(N-1)/2] = 1;
           /* Costruzione del quadrato magico*/
           chiave = 2;
           i = 0;
           j = (int)(N-1)/2;
           while ( chiave <= N*N )
           {
              k = i - 1;

              if ( k < 0 )
                    k += N;

              l = j - 1;

              if ( l < 0 )
                    l += N;

              if ( Array[k][l] != 0 )
                          i = (i+1) % N;
              else {
                   i = k;
                   j = l;
                   }

              Array[i][j] = chiave;
              chiave++;
           }

        for (i=0; i<N; i++)     //indica una posizione random all'interno
dell'array in cui inserire il valore zero
            Array[(int)(Math.random()*N)][(int)(Math.random()*N)]=0;

        return Array;
      }

   /**Metodo che verifica se i valori dell'array costituiscono un quadrato
magico
    *@param m array bidimensionale
    *@return qm :verifica booleana del quadrato magico*/
   public static boolean verifica(int[][] m) {
       boolean qm = true;      // variabile booleana per la verifica del
quadrato magico
       int somma = sommaRiga(m, 0);

       if (verificanumeri(m)>1)  // richiama il metodo verifica numeri, se
torna un valore che indica la presenza di 2 o piu numeri uguali
           qm = false;           // il quadro magico non ? valido

       if (somma!=sommaDiagonaleDestra(m)) //richiama il metodo che
verifica che la somma della diagonale da sinistra a destra sia guale a
"somma"
           qm = false;

       if (somma!=sommaDiagonaleSinistra(m)) //richiama il metode che
verifica che la somma della diagonale da destra a sinistra sia guale a
"somma"
             qm = false;

       for (int i=1; i<m.length; i++) {
           if (somma!=sommaRiga(m, i))   //richiama metodo sommaRiga per
verificare che la somma di tutte le righe di indice i sia uguale a "somma"
               qm = false;
           if (somma!=sommaColonna(m, i)) //richiama metodo sommaColonna
per verificare che la somma di tutte le colonne di indice i sia uguale a
"somma"
               qm = false;

       }

       return qm;
   }
   /**Metodo che restituisce la somma degli elementi della riga m
    *@param m array bidimensionale
    *@param rig indice riga
    *@return s :somma della riga*/
   public static int sommaRiga(int[][] m, int rig) {
       int s = 0;
       for (int j=0; j<m.length; j++)
           s+=m[rig][j];
       return s;
   }

   /**Metodo che restituisce la somma degli elementi della colonna m
    *@param m array bidimensionale
    *@param col indice colonna
    *@return s :somma della colonna*/
   public static int sommaColonna(int[][]m, int col) {
       int s = 0;
       for (int i=0; i<m.length; i++)
           s+=m[i][col];
       return s;

   }

   /**Metodo che restituisce la somma degli elementi della diagonale da
sinistra a destra
    *@param m array bidimensionale
    *@return s :somma della diagonale da sinistra a destra*/
   public static int sommaDiagonaleDestra(int[][]m) {
       int s = 0;
       for (int i=0; i<m.length; i++)
           s+=m[i][i];
       return s;

   }

   /**Metodo che restituisce la somma degli elementi della diagonale da
destra a sinistra
    *@param m array bidimensionale
    *@return s :somma della diagonale da destra a sinistra */
   public static int sommaDiagonaleSinistra(int[][]m) {
     int s = 0;
     int i = 0;

     for (int j=N-1; j>=0; j--){
        s+=m[i][j];
           i++;
      }

     return s;
   }

   /**Metodo che restituisce il numero numero massimo di elementi uguali
trovati all'interno dell'array
    *@param m array bidimensionale
    *@return test :elementi uguali all'interno dell'array */
   public static int verificanumeri(int[][] m){
    int test=0;

    /* facciamo rifermento a due coppie ordinate di indici per verificare
se all'interno dell'array vi sono
     * due o piu interi uguali.
     * Se cos? fosse deve uscire dal ciclo annidato e restituire il valore
"test" che sar? valutato dalla condizione
     * del metodo verifica(int[][]) */
    for (int i = 0; i < N; i++){
         for (int j = 0; j < N; j++){
             for (int k = 0; k < N; k++){
                 for (int l = 0; l < N; l++){
                  if ((m[i][j]==m[k][l])&&(test<2))
                      test++;
                  else
                      return test;
             }
             }

           test = 0;
           }
        }

        return test;

       }

     /**Implementazione del metodo per la inizializzazione della variabile
N che identificher? la grandezza della griglia
      *e delle variabili array*/

     public void inizializza(){
      String input;
      int test = 0;

      while ((test%2)==0){

        input =  JOptionPane.showInputDialog("Inserisci la dimensione della
griglia:"); //Assegna alla variabile input il valore inserito
              test = Integer.parseInt(input.trim()); //variabile di
appoggio a cui ? assegnato la variabile input convertita in intero
                                                 //il metodo trim()
restituisce una stringa priva di spazzi

             if (input != null){

                 try{
                    if ((test%2)!=0){            //se il valore della
variabile test ? dispari
                     N = test;                   //assegna il valore di
test alla variabile N
                     ArrayVuoto = new int[N][N];     //inizializza gli
array di interi con dimensione N
                      ArrayRandom1 = new int[N][N];
                      ArrayRandom2 = new int[N][N];
                      ArrayPerfetto = new int[N][N];
                      ArrayQuasiPerfetto = new int[N][N];
                      mat = new int[N][N];
                      jb = new JButton[N][N];        //inizializza gli
array di pulsanti con dimensione N
                 }
                else{
                 throw new NumberFormatException("il valore deve essere
dispari");
                }

                 }
              catch (NumberFormatException ex) {
                      JOptionPane.showMessageDialog(QuadratoMagico.this,"Valore
inserito: " + input + "\n" + ex.getMessage(),"hai inserito un valore non
valido,inserire un intero con valore dispari",JOptionPane.ERROR_MESSAGE);
                       }
       }

    }

    }
}