Newsgroup: it.comp.java
Titolo: aiuto problema con IOException

Slave
ho un simulatore di una Macchina di Turing che devo fare la stesura è finita
solo che quando vado a compilare l'interfaccia grafica mi da questo errore:
D:\java\TuringAll\TuringMachine\TuringMachine.java:986: unreported exception
java.io.IOException; must be caught or declared to be thrown
        LetturaDaFile f=new LetturaDaFile(jTextField1.getText());
xche il metodo lettura da file o meglio il costruttore a una IOExcepiton ma
il metodo voi che viene eseguito sul mouseventClick non puo essere throw
IOException....o per lo meno cosi mi dice...io di intgerfacce ne so molto
poco se mi date una mano....
allego qui sott il codice dell'interfaccia grafica a della classe
letturadafile che serve a leggere da un file le informazioni e i dati
necessari al funzionamentoi della mdt:
/***************************************************************************
*La classe LetturaDaFile è la classe che permette il riconoscimento e la
*codifica del file che sarà tipizzato come specifica la relazione allegata.
*Questa classe si occupa anche del controllo degli errori sull'integrità
*dell'immissione del file; controlla anche infine la logicita dei valori
*letti seguendo le istruzioni impartite dalla specifica.
***************************************************************************/
class LetturaDaFile
{
 private Vector vettoreStati=new Vector();
 private Vector vettoreSimboli=new Vector();
 private Vector vettoreSimbInput=new Vector();
 private Vector vettoreAzioni=new Vector();
 private Stato stIniz=new Stato("");
 private Vector vettoreStFinali=new Vector();
 private Vector nastro=new Vector();
 private boolean existence=true;
/***************************************************************************
    *Costruttore. Crea tutti le informazioni del nucleo della classe
leggendole
    *dal file che sarà specificato dalla stringa percorsoFile che ha come
    *parametro il costruttore.
***************************************************************************/
 LetturaDaFile(String percorsoFile) throws IOException
 {
  FileInputStream file;
  int datoLetto;
  int numberVector=0;
  int indice;
  int app=0;
  Stato st=new Stato("");
  Stato stNew=new Stato("");
  StringBuffer simbolo;
  String simbApp;
  String simbAtt=new String();
  String simbNew=new String();
  String dir=new String();
  Azione mossa;
/***************************************************************************
        *Serve a verificare che il file immesso esista veramente.
***************************************************************************/
  try
  {
   file=new FileInputStream(percorsoFile);
  } catch(FileNotFoundException e)
  {
   existence=false;
   return;
  }
  do
  {
   datoLetto=file.read();
   if ((char)datoLetto==':')
      {
       do
    {
     indice=0;
     simbolo=new StringBuffer();
     datoLetto=file.read();
     while ((char)datoLetto!=','&&(char)datoLetto!=';')
     {
       simbolo.insert(indice,(char)datoLetto);
          datoLetto=file.read();
          indice++;
     }
     if (indice!=0)
     {
      simbApp=new String(simbolo);
      switch (numberVector)
            {
             case 0:
                       vettoreStati.addElement(simbApp);
                    break;
             case 1:
                    vettoreSimboli.addElement(simbApp);
                     break;
             case 2:
                    vettoreSimbInput.addElement(simbApp);
                    break;
             case 3:
                    switch (app)
                    {
                     case 0:
                            simbAtt=new String(simbApp.substring(1));
                            st=new Stato(simbAtt);
                            break;
                     case 1:
                            simbAtt=new String(simbApp);
                            break;
                     case 2:
                            stNew=new Stato(simbApp);
                            break;
                     case 3:
                            simbNew=new String(simbApp);
                            break;
                     case 4:
                            dir=new
String(simbApp.substring(0,simbApp.length()-1));
                            mossa=new
Azione(st,simbAtt,stNew,simbNew,dir.charAt(0));
                            vettoreAzioni.addElement(mossa);
                            app=-1;
                            break;
                    }
                    app++;
                    break;
             case 4:
                    stIniz=new Stato(simbApp);
                    break;
             case 5:
                    vettoreStFinali.addElement(simbApp);
                    break;
             case 6:
                    nastro.addElement(simbApp);
                      break;
             default:
                        break;
               }
        }
    }
    while ((char)datoLetto!=';');
    numberVector++;
    if (numberVector==2)
    {
     vettoreSimboli.addElement(new String("B"));
    }
   }
  }
  while (datoLetto!=-1);
  file.close();
 }
/***************************************************************************
    *Il metodo controlla se i Vettori che devono esistere per la specifica
    *sono stati inseriti.
***************************************************************************/
 private boolean crtlEsistenzaSettupla()
 {
  if (vettoreStati.size()==0)
  {
   return false;
  }
  if (vettoreSimboli.size()==0)
  {
   return false;
  }
  if (vettoreSimbInput.size()==0)
  {
   return false;
  }
  if (vettoreAzioni.size()==0)
  {
   return false;
  }
  if (stIniz.getNomeST().equals(""))
  {
   return false;
  }
  /*if (vettoreStFinali.size()==0)
  {
   return false;
  }*/
  return true ;
 }
/***************************************************************************
    *Il metodo controlla se:
    *-lo stato iniziale fa parte degli stati possibili della macchina di
Turing
    *-tutti gli stati finali fanno a loro volta parte degli stati della T.M.
    *-gli stati contenuti nella quintupla d'azione fanno a loro volta parte
degli
    * stati della T.M.
***************************************************************************/
 private boolean crtlStati()
 {
  boolean ok=false;
  int k,h;
  Stato stApp;
  String simbApp,simbApp2;
  Azione mossaApp;
  for(k=0;k<vettoreStati.size();k++)
  {
   simbApp=new String((String)vettoreStati.elementAt(k));
   if (simbApp.equals(stIniz.getNomeST()))
   {
    ok=true;
   }
  }
  if (ok)
  {
   ok=false;
  } else
  {
   return(false);
  }
  for(k=0;k<vettoreStFinali.size();k++)
  {
   for(h=0;h<vettoreStati.size();h++)
   {
    simbApp=new String((String)vettoreStati.elementAt(h));
    simbApp2=new String((String)vettoreStFinali.elementAt(k));
    if (simbApp.equals(simbApp2))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
   {
    return(false);
   }
  }
  for(k=0;k<vettoreAzioni.size();k++)
  {
   for(h=0;h<vettoreStati.size();h++)
   {
    simbApp=new String((String)vettoreStati.elementAt(h));
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    stApp=new Stato(mossaApp.getStAttuale().getNomeST());
    if (simbApp.equals(stApp.getNomeST()))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
      {
         return(false);
      }
  }
  for(k=0;k<vettoreAzioni.size();k++)
  {
   for(h=0;h<vettoreStati.size();h++)
   {
    simbApp=new String((String)vettoreStati.elementAt(h));
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    stApp=new Stato(mossaApp.getStNuovo().getNomeST());
    if (simbApp.equals(stApp.getNomeST()))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
      {
          return(false);
      }
  }
  return(true);
 }
/***************************************************************************
    *Il metodo controlla se:
    *-tra i simboli di input non è (come deve) stato inserito il carattere
"B"
    * che corrisponde per specifica allo spazio vuoto della macchina di
Turing
    *-tutti i simboli di input appartengono ai simboli possibili della T.M
    *-i simboli contenuti nella quintupla d'azione appartengono a loro volta
    * ai simboli della T.M.
    *-i simboli del nastro di partenza siano tutti inclusi nei simboli di
input
***************************************************************************/
 private boolean crtlSimboli()
 {
  boolean ok=false;
  int k,h;
  String simbApp,simbApp2;
  Azione mossaApp;
  for(k=0;k<vettoreSimbInput.size();k++)
  {
   simbApp=new String((String)vettoreSimbInput.elementAt(k));
   if (simbApp.equals("B"))
   {
    return(false);
   }
  }
  for(k=0;k<vettoreSimbInput.size();k++)
  {
   for(h=0;h<vettoreSimboli.size();h++)
   {
    simbApp=new String((String)vettoreSimboli.elementAt(h));
    simbApp2=new String((String)vettoreSimbInput.elementAt(k));
    if (simbApp.equals(simbApp2))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
   {
    return(false);
   }
  }
  for(k=0;k<vettoreAzioni.size();k++)
  {
   for(h=0;h<vettoreSimboli.size();h++)
   {
    simbApp=new String((String)vettoreSimboli.elementAt(h));
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    simbApp2=new String(mossaApp.getSimbAttuale());
    if (simbApp.equals(simbApp2))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
   {
    return(false);
   }
  }
  for(k=0;k<vettoreAzioni.size();k++)
  {
   for(h=0;h<vettoreSimboli.size();h++)
   {
    simbApp=new String((String)vettoreSimboli.elementAt(h));
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    simbApp2=new String(mossaApp.getSimbNuovo());
    if (simbApp.equals(simbApp2))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
   {
    return(false);
   }
  }
  for(k=0;k<nastro.size();k++)
  {
   for(h=0;h<vettoreSimbInput.size();h++)
   {
    simbApp=new String((String)vettoreSimbInput.elementAt(h));
    simbApp2=new String((String)nastro.elementAt(k));
    if (simbApp.equals(simbApp2))
    {
     ok=true;
    }
   }
   if (ok)
        {
         ok=false;
      } else
   {
    return(false);
   }
  }
  return(true);
 }
/***************************************************************************
    *Il metodo controlla se nella quintupla d'azione le direzioni della
macchina
    *di Turing sono state definite (come devono da specifica) solo dai
caratteri
    * "D" e "S".
***************************************************************************/
 private boolean crtlDirezione()
 {
  int k;
  char dir;
  Azione mossaApp;
  for(k=0;k<vettoreAzioni.size();k++)
  {
   mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
   dir=mossaApp.getDirezione();
   if ((dir!='D')&&(dir!='S'))
   {
    return(false);
   }
  }
  return(true);
 }
/***************************************************************************
    *Il metodo setta gli stati della quintupla d'azione andando a settare la
    *finalità a quegli stati che appartengono al Vettore degli stati finali.
***************************************************************************/
 private void setStatiAzione()
 {
  int k,h;
  Azione mossaApp;
  Stato stApp;
  String simbApp;
  for(k=0;k<vettoreAzioni.size();k++)
  {
   for(h=0;h<vettoreStFinali.size();h++)
   {
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    stApp=new Stato(mossaApp.getStAttuale().getNomeST());
    simbApp=new String((String)vettoreStFinali.elementAt(h));
    if (simbApp.equals(stApp.getNomeST()))
    {
     stApp.setStFinal(true);
     mossaApp.setStAttuale(stApp);              // Forse al posto di queste
2
     vettoreAzioni.insertElementAt(mossaApp,k); // si potrebbe usare solo la
     vettoreAzioni.removeElementAt(k+1);        // setElementAt
    }
    mossaApp=new Azione((Azione)vettoreAzioni.elementAt(k));
    stApp=new Stato(mossaApp.getStNuovo().getNomeST());
    simbApp=new String((String)vettoreStFinali.elementAt(h));
    if (simbApp.equals(stApp.getNomeST()))
    {
     stApp.setStFinal(true);
     mossaApp.setStNuovo(stApp);              // Forse al posto di queste 2
     vettoreAzioni.insertElementAt(mossaApp,k); // si potrebbe usare solo la
     vettoreAzioni.removeElementAt(k+1);        // setElementAt
    }
   }
  }
 }
/***************************************************************************
    *Il metodo setta la finalità allo stato iniziale nel caso in cui questo
    *appartenga al Vettore degli stati finali.
***************************************************************************/
 private void setStatoIniziale()
 {
  int h;
  String simbApp;
  for(h=0;h<vettoreStFinali.size();h++)
   {
    simbApp=new String((String)vettoreStFinali.elementAt(h));
    if (simbApp.equals(stIniz.getNomeST()))
    {
     stIniz.setStFinal(true);
    }
   }
 }
/***************************************************************************
    *Il metodo richiama tutti i metodi precedenti (e privati) per il
controllo
    *della correttezza del file e restituisce una stringa di errore che
specifica
    *la tipologia dell'errore commesso.
***************************************************************************/
 public String crtlFile()
 {
  if (existence==false)
  {
   return("File non trovato.");
  }
  if (!crtlEsistenzaSettupla())
  {
   return("Errore nell'immissione del file. Mancano parti fondamentali per
l'esecuzione della T.M.");
  }
  if (!crtlStati())
  {
   return("Errore nell'immissione degli Stati.");
  }
  if (!crtlSimboli())
  {
   return("Errore nell'immissione dei Simboli.");
  }
  if (!crtlDirezione())
  {
   return("Errore nell'immissione delle Direzioni della Turing Machine.");
  }
  return("OK");
 }
/***************************************************************************
    *Metodo che ritorna il Vettore del nastro di partenza.
***************************************************************************/
 public Vector getNastro()
 {
  return(nastro);
 }
/***************************************************************************
    *Metodo che ritorna il Vettore della quintupla d'azione.
***************************************************************************/
 public Vector getAzione()
 {
  setStatiAzione();
  return(vettoreAzioni);
 }
/***************************************************************************
    *Metodo che ritorna lo stato iniziale della macchina di Turing.
***************************************************************************/
 public Stato getStatoIniz()
 {
  setStatoIniziale();
  return(stIniz);
 }
}
class Interfaccia  extends javax.swing.JFrame
{
 private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JButton jButton4;
    private javax.swing.JButton jButton5;
    private javax.swing.JButton jButton3;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JTextArea jTextArea1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JScrollPane jScrollPane3;
    private javax.swing.JTextArea jTextArea2;
    private javax.swing.JLabel jLabel3;
    public Interfaccia()
    {
        initComponents();
        setSize(640,480);
    }
    private void initComponents()
    {
        buttonGroup1 = new javax.swing.ButtonGroup();
        jLabel1 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jButton4 = new javax.swing.JButton();
        jButton5 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();
        jScrollPane2 = new javax.swing.JScrollPane();
        jTextArea1 = new javax.swing.JTextArea();
        jLabel2 = new javax.swing.JLabel();
        jScrollPane3 = new javax.swing.JScrollPane();
        jTextArea2 = new javax.swing.JTextArea();
        jLabel3 = new javax.swing.JLabel();
        getContentPane().setLayout(new
org.netbeans.lib.awtextra.AbsoluteLayout());
        setTitle("Tm Simulator for Java v 1.0");
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
        setForeground(java.awt.Color.lightGray);
        setResizable(false);
        setBackground(java.awt.Color.lightGray);
        addWindowListener(new java.awt.event.WindowAdapter()
        {
            public void windowClosing(java.awt.event.WindowEvent evt)
            {
                exitForm(evt);
            }
        });
        jLabel1.setText("Inserici il nome e il percorso del file con le
istruzioni");
        jLabel1.setForeground(java.awt.Color.black);
        getContentPane().add(jLabel1, new
org.netbeans.lib.awtextra.AbsoluteConstraints(120, 150, 310, -1));
        jTextField1.setText("Inserisci il file di acquisizione dati");
        getContentPane().add(jTextField1, new
org.netbeans.lib.awtextra.AbsoluteConstraints(20, 170, 570, -1));
        jButton4.setToolTipText("Esci da TM Simulator for Java");
        jButton4.setText("Esci");
        jButton4.setBackground(java.awt.Color.blue);
        jButton4.addMouseListener(new java.awt.event.MouseAdapter()
        {
            public void mouseClicked(java.awt.event.MouseEvent evt)
            {
                exitform(evt);
            }
        });
        getContentPane().add(jButton4, new
org.netbeans.lib.awtextra.AbsoluteConstraints(440, 390, -1, -1));
        jButton5.setToolTipText("Cancella tutti i campi e ti permette
l'immissione di una nuova macchina");
        jButton5.setText("Reset");
        jButton5.setBackground(java.awt.Color.blue);
        jButton5.addMouseListener(new java.awt.event.MouseAdapter()
        {
            public void mouseClicked(java.awt.event.MouseEvent evt)
            {
                reset(evt);
            }
        });
        getContentPane().add(jButton5, new
org.netbeans.lib.awtextra.AbsoluteConstraints(280, 390, -1, -1));
        jButton3.setToolTipText("Inizia la computazione");
        jButton3.setText("Calcola");
        jButton3.setBackground(java.awt.Color.blue);
        jButton3.addMouseListener(new java.awt.event.MouseAdapter()
        {
            public void mouseClicked(java.awt.event.MouseEvent evt)
            {
                calcola(evt) ;
            }
        });
        getContentPane().add(jButton3, new
org.netbeans.lib.awtextra.AbsoluteConstraints(130, 390, 80, -1));
        jTextArea1.setEditable(false);
        jTextArea1.setText("Benvenuto.\nQuesto programma simula una macchina
di Turing.\nLa macchina di Turing a dispetto della sua semplicita' ha una
capacita' elevatissima di calcolo.\nPartendo da le tue istruzioni, che
verranno acquisite da un file di testo, la macchina eseguira una serie di
calcoli che potrai seguire passo passo.\nIl file dal quale la macchina
acquisira' le informazioni dovra' essere cosi strutturato:\nStati: [elenco
stati separatoi da virgola];\nSimboli: [elenco insieme di simboli separati
da virgola];\nAzioni: [ elenco di quintuple di azioni separate da virgola\n
( le azioni saranno
:(simbololetto,statoletto,nuovosimb,nuovostat,dir))];\necc...\n
//////////Manca roba..... \nGrazie! \n       ");
        jTextArea1.setBackground(java.awt.Color.lightGray);
        jScrollPane2.setViewportView(jTextArea1);
        getContentPane().add(jScrollPane2, new
org.netbeans.lib.awtextra.AbsoluteConstraints(10, 10, 620, 130));
        jLabel2.setText(" ");
        jLabel2.setToolTipText("");
        jLabel2.setForeground(java.awt.Color.black);
        getContentPane().add(jLabel2, new
org.netbeans.lib.awtextra.AbsoluteConstraints(40, 200, 540, 30));
        jTextArea2.setEditable(false);
        jTextArea2.setText(" ");
        jScrollPane3.setViewportView(jTextArea2);
        getContentPane().add(jScrollPane3, new
org.netbeans.lib.awtextra.AbsoluteConstraints(10, 250, 610, 140));
        jLabel3.setText("Visualizza qui passo passo cio che fa la macchina
da te definita:");
        jLabel3.setForeground(java.awt.Color.red);
        getContentPane().add(jLabel3, new
org.netbeans.lib.awtextra.AbsoluteConstraints(120, 230, 400, -1));
    }
    private void reset(java.awt.event.MouseEvent evt)
    {
        jTextArea2.setText(" ");
        jLabel2.setText(" ");
        jTextField1.setText("file acquisizione dati");
        validate();
    }
    private void exitform(java.awt.event.MouseEvent evt)
    {
        System.exit(0);
    }
    private void calcola(java.awt.event.MouseEvent evt)
    {
        LetturaDaFile f=new LetturaDaFile(jTextField1.getText());
        jLabel2.setText(f.crtlFile());
        if (f.crtlFile().equals("OK"))
        {
         TuringMachine macchina=new
TuringMachine(f.getAzione(),f.getStatoIniz(),f.getNastro(),2);
            jTextArea2.setText(macchina.esegui());
            validate();
        }
    }
    private void exitForm(java.awt.event.WindowEvent evt)
    {
        System.exit(0);
    }
 public static void main(String args[])
 {
        new Interfaccia().show();
    }
}
GRAZIE MILLE A TUTTI COLORO CHE MI AIUTERANNO!

 ha scritto nel messaggio
news:lGu38.31223$ly.10...@twister1.libero.it...
