Algoritmi - Aggiungere metodi ad una classe

Ciao, ho bisogno di una informazione. Ho creato un progetto in java che deve calcolare dove e quando due treni che partono uno dalla stazione centrale e l'altro da una stazione periferica si incontreranno. essi viaggiano l'uno verso l'altro lungo la stesso itinerario.
1. Tutti i treni trascorrono una quantità di tempo fissata in ogni stazione.
2. Tutti i treni accelerano e decelerano allo stesso tasso (costante); tutti i treni hanno la stessa velocità massima
3. Quando un treno lascia la stazione, accellera (ad un tasso costante) finché non raggiunge la sua velocità massima. Un treno mantiene la velocità massima finché non comincia a decelerare (allo stesso tasso costante) in prossimità della stazione successiva. I treni lasciano la stazione con una velocità iniziale pari a zero (0.0) e si fermano ad ogni stazione intermedia con una velocità finale pari a zero. Stazioni adiacenti lungo un dato itinerario sono sufficientemente distanti da consentire ai treni raggiungere la velocità massima prima di cominciare a decelerare
4. Entrambi i treni partono nello stesso momento
5. Un itinerario è; composto da al più 50 fermate

Io ho creato 3 classi, il progetto funziona però, a detta della professoressa (progetto universitario) è troppo " sequenziale". Dovrei modificarlo aggiungendo dei metodi..solo che non so da dove cominciare :? qualcuno può darmi una mano? vi posto le tre classi intanto...



TRENO

    import java.io.IOException;
    import java.util.*;


    public class Treno {
       
       public float tempopercorrenza1;
       public float tempopercorrenza2;
       public float diststsuccessiva;
       public float diststsuccessiva2;
       public float velocita_maxpiedi;
       public float acceldecel;
       public float spazio_decelerazione_accel;
       public float tempo_acceldec;
       public float cost_acc_dec;
       public float piedi=5280;
       public int numstaz=0;
       public int d=0;
       public int e=0;
       public int w=0;
       public Vector <Float> punto_incontro=new Vector <Float>();
       public Vector <Float> tempo_incontro=new Vector <Float>();
       public Vector <Float> distanzasuccessivatr=new Vector <Float>();
       public Vector <Float> distanzasuccessivatr2=new Vector <Float>();
       public Vector <Float> tempopercorrenzatr=new Vector <Float>();
       public Vector <Float> tempopercorrenzatr2=new Vector <Float>();
       public float difftempoper;
       public float tempopercor;
       public float tempopercor2;
       public int z;
       public int f=0;
       public float stazione;
       public Scenario sc=new Scenario();
       
       
       public void datitreno() throws IOException {
          sc.leggiinput();
          int r=0;
          z=0;
          int g;
          Treno tr=new Treno();
          cost_acc_dec=0.5f;
          tempo_acceldec=(sc.velmax/sc.accelerazione);
          spazio_decelerazione_accel=cost_acc_dec*(sc.accelerazione*(tempo_acceldec*tempo_acceldec));
          System.out.println(spazio_decelerazione_accel);
          while (sc.stazioni[z+1]!=null){
             if(sc.stazioni[z]!=-1.0f){
             calcolaittreno1();
             calcolaittreno2();
             if(diststsuccessiva>spazio_decelerazione_accel&&diststsuccessiva2>spazio_decelerazione_accel){
             if(sc.stazioni[z+1]==0.0f){
                if (tr.diststsuccessiva==tr.diststsuccessiva2&&tr.tempopercorrenza1==tr.tempopercorrenza2){
                punto_incontro.addElement((sc.stazioni[z]/2)*1000);
                tempo_incontro.addElement ((tempopercorrenza1-sc.tempofermata.elementAt(e))/2);
                System.out.println(punto_incontro.elementAt(r));
                System.out.println(tempo_incontro.elementAt(r));
                d=0;
                distanzasuccessivatr.clear();
                distanzasuccessivatr2.clear();
                tempopercorrenzatr.clear();
                tempopercorrenzatr2.clear();
                }
             }
             else{
             if(sc.stazioni[z]==stazione){
                   System.out.println("x");
                   g=0;
                   while (g<tempopercorrenzatr.size()){
                      tempopercor=tempopercor+tempopercorrenzatr.elementAt(g);
                      g++;
                   }
                   g=0;
                   while(g<tempopercorrenzatr2.size()){
                      tempopercor2=tempopercor2+tempopercorrenzatr2.elementAt(g);
                      g++;
                   }
                   if(sc.tempofermata.elementAt(e)>Math.abs(tempopercor-tempopercor2)){

                      if(tempopercor<tempopercor2){
                         System.out.println("tempopercor="+tempopercor2);
                         tempo_incontro.addElement(tempopercor2-sc.tempofermata.elementAt(e));
                         punto_incontro.addElement((sc.stazioni[z])*1000);
                      }
                      if(tempopercor>tempopercor2){
                         System.out.println("tempopercor="+tempopercor);
                      tempo_incontro.addElement(tempopercor-sc.tempofermata.elementAt(e));
                      punto_incontro.addElement((sc.stazioni[z])*1000);}
                      if(tempopercor==tempopercor2){
                         System.out.println("tempopercor="+tempopercor2);
                         tempo_incontro.addElement(tempopercor2-sc.tempofermata.elementAt(e));
                         punto_incontro.addElement((sc.stazioni[z])*1000);
                      }
                      
                      
                   }
                   d=0;
                   tempopercor=0;
                   tempopercor2=0;
                   distanzasuccessivatr.clear();
                   distanzasuccessivatr2.clear();
                   tempopercorrenzatr.clear();
                   tempopercorrenzatr2.clear();

                   
             }
             else{
                      float tdiff;
                      float tdiffVelmax;
                      float sdiffVelmax;
                      float sdiffpercor=0;
                      float spaziorim;
                      float spaztr1=0;
                      float tvelmax;
                      float distanzatr1=0;
                      float distanzatr2=0;
                      g=0;
                      while(g<tempopercorrenzatr.size()){
                         tempopercor=tempopercor+tempopercorrenzatr.elementAt(g);
                         distanzatr1=distanzatr1+distanzasuccessivatr.elementAt(g);
                         g++;
                      }
                      g=0;
                      while(g<tempopercorrenzatr2.size()){
                         tempopercor2=tempopercor2+tempopercorrenzatr2.elementAt(g);
                         distanzatr2=distanzatr2+distanzasuccessivatr2.elementAt(g);
                         g++;
                      }
                      if (tempopercor<tempopercor2){
                         tdiff=tempopercor2-tempopercor;
                         tempopercor2=tempopercor2+cost_acc_dec;
                      }
                      else{tdiff=tempopercor-tempopercor2;
                         tempopercor=tempopercor+cost_acc_dec;
                         spaztr1=distanzatr1+spazio_decelerazione_accel;
                      }
                      if(tdiff<cost_acc_dec){
                         tdiffVelmax=tdiff-cost_acc_dec;
                         sdiffVelmax=sc.velmax*tdiffVelmax;
                         sdiffpercor=(sdiffVelmax+spazio_decelerazione_accel)+(sc.velmax*cost_acc_dec);
                      }
                      if(tempopercor<tempopercor2){
                         spaziorim=(stazione-sdiffpercor)-spaztr1;
                      }
                      else{
                         spaziorim=(stazione+spazio_decelerazione_accel)-(sc.stazioni[z]+sdiffpercor);
                      }
                      tvelmax=spaziorim/sc.velmax;
                      tempo_incontro.addElement((tempopercor+(tvelmax/2)));
                      punto_incontro.addElement((sc.stazioni[z]*1000)+(spaziorim/2));
                      }}
                      d=0;
                      tempopercor=0;
                      tempopercor2=0;
                      distanzasuccessivatr.clear();
                      distanzasuccessivatr2.clear();
                      tempopercorrenzatr.clear();
                      tempopercorrenzatr2.clear();
                      while (sc.stazioni[z]!=0.0f){
                         z++;
                         f++;}
                      if(sc.stazioni[z]==0.0f){z++;}
                      e++;
             }
             else{System.out.println("Lista terminata");}            
             }
             else {System.out.println("stazioni non sufficientemente lontane");}
          }
          
          }

             
       public void calcolaittreno1 () throws IOException{

       
          float stazionepar=0.0f;
          float tempovelmax;
          float s_velmax;
          if (d==0){
          diststsuccessiva=((sc.stazioni[z]-stazionepar)*piedi);}
          if (d!=0){
          diststsuccessiva=Math.abs((sc.stazioni[z]-sc.stazioni[z+1])*piedi);}
          System.out.println("la stazione successiva tr1 è"+sc.stazioni[z]);
          System.out.println(diststsuccessiva);
          System.out.println(spazio_decelerazione_accel*2);
          s_velmax=diststsuccessiva-(spazio_decelerazione_accel*2);
          System.out.println(s_velmax);
          tempovelmax=s_velmax/sc.velmax;
          System.out.println(tempovelmax);
          System.out.println(sc.tempofermata.elementAt(e));
          tempopercorrenza1=((tempo_acceldec*2)+tempovelmax)+sc.tempofermata.elementAt(e);
          System.out.println(tempopercorrenza1);
          distanzasuccessivatr.addElement(diststsuccessiva);
          tempopercorrenzatr.addElement(tempopercorrenza1);
          }
       
       public void calcolaittreno2(){/**treno che parte dalla stazione periferica*/
          float tempovelmax2;
          float s_velmax2;
          
          if(sc.stazioni[z+1]==0.0f){
             diststsuccessiva2=Math.abs(sc.stazioni[z]*piedi);
             f++;
             System.out.println("la stazione successiva tr2 è"+sc.stazioni[z+1]);
          }
          if (sc.stazioni[z+1]!=0.0f){
             while (sc.stazioni[f+1]!=0.0f){f++;}
          diststsuccessiva2=Math.abs((sc.stazioni[f]-sc.stazioni[f-1])*piedi);
          stazione=sc.stazioni[f-1];   
          System.out.println("la stazione successiva tr2 è"+sc.stazioni[f-1]);}
          s_velmax2=Math.abs(diststsuccessiva2-(spazio_decelerazione_accel*2));
          System.out.println(s_velmax2);
          tempovelmax2=Math.abs(s_velmax2/sc.velmax);
          System.out.println(tempovelmax2);
          System.out.println(sc.tempofermata.elementAt(e));
          tempopercorrenza2=((tempo_acceldec*2)+tempovelmax2)+sc.tempofermata.elementAt(e);
          System.out.println(tempopercorrenza2);
          distanzasuccessivatr2.addElement(diststsuccessiva2);
          tempopercorrenzatr2.addElement(tempopercorrenza2);
       }
    }

SCENARIO

import java.io.*;
import java.util.*;
public class Scenario {
   public String scenari=new String();
   public float velmax;
   public float accelerazione;
   public Float stazioni[]=new Float[50];

   public Vector <Float> tempofermata=new Vector <Float>();
   
      
public void leggiinput() throws IOException{
   int i=0;
   int z=0;
   FileReader file=new FileReader ("Input.txt");
   BufferedReader fileinp=new BufferedReader(file);
   try{
      String s="";
      while(s!=null){
         s=fileinp.readLine();
         if(s!=null){
         StringTokenizer st=new StringTokenizer(s);
         while(st.hasMoreTokens()){
         String token=st.nextToken();
         stazioni[i]=Float.parseFloat(token);
         System.out.println(stazioni[i]);
         i++;}
         s=fileinp.readLine();
            StringTokenizer st2=new StringTokenizer(s);
            while(st2.hasMoreTokens()){
            String token1=st2.nextToken();
            accelerazione=Float.parseFloat(token1);
         }
            s=fileinp.readLine();
            StringTokenizer st3=new StringTokenizer(s);
            while(st3.hasMoreTokens()){
            String token2=st3.nextToken();
            velmax=Float.parseFloat(token2);
            s=fileinp.readLine();
               }
            StringTokenizer st4=new StringTokenizer(s);
            while(st4.hasMoreTokens()){
            String token3=st4.nextToken();
            Float tf=Float.parseFloat(token3);
            tempofermata.addElement(tf);
            z++;
               }
         }
            file.close();
            }
   }
   catch(IOException e){
      System.out.println("Lettura File Completata");
   }
   treni();
}
public void treni(){
   int f=0;
   int x=0;
   while (stazioni[x]!=null){
      System.out.println(stazioni[x]);
      x++;}
   while (f!=tempofermata.size()){
      System.out.println(tempofermata.elementAt(f));
      f++;}
}

}

PERCORSO

    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Vector;

    public class Percorso {
       public static int w;
       public static FileWriter file=null;
       public static PrintWriter Output= null;

       public static void main (String args[]) throws IOException{
          Treno tr=new Treno();
          Scenario sc=new Scenario();
          tr.datitreno();
          

          while (w!=tr.punto_incontro.size()){
             System.out.println(tr.punto_incontro.elementAt(w));
             System.out.println(tr.tempo_incontro.elementAt(w));
             w++;
       }
          try{
             
             file= new FileWriter("Output.txt");
             Output= new PrintWriter (file);
             int y=0;
             int d=0;
             int staz=0;
             boolean flag = false;
             int scenario=1;
             float stazione;
             Vector <Float> stazione1=new Vector <Float>();
             sc.leggiinput();
             while(sc.stazioni[d]!=null){
                stazione1.addElement(sc.stazioni[d]);
                d++;
             }
             d=0;
             int z=0;
             while(y<tr.tempo_incontro.size()){
                flag=false;
                Output.println("");
                Output.println("Scenario"+""+"#"+scenario);
                Output.println("Meeting time:"+tr.tempo_incontro.elementAt(y)+"minuti");
                stazione=(tr.punto_incontro.elementAt(y)/1000);
                z=0;
                while(z!=stazione1.size()){
                   d++;
                if(stazione==stazione1.elementAt(z)){
                   System.out.println("true");
                   flag=true;
                   staz=Math.round(tr.punto_incontro.elementAt(y));
                   Output.println("Meeting distance:"+""+staz+"miglia dalla stazione centrale,nella stazione"+d);
                }
                d++;
                z++;
                if(stazione1.elementAt(z)==0.0f){z++;
                d=0;}
                if(stazione1.elementAt(z)==-1.0f){z++; }
                }
                if(flag==false)
                   {staz=Math.round(tr.punto_incontro.elementAt(y));
                   Output.println("Meeting distance:"+""+staz+""+"miglia dalla stazione centrale");
                   }
                y++;
                scenario++;
                }   
          }
          catch(IOException e){
             System.out.println("Errore nell'apertura del file");
             System.exit(1);}
          try{
          file.close();
          System.out.println("File chiuso");}
          catch(IOException e){System.out.println("Errore nella chiusura del file");
          System.exit(1);
       }
       }
    }

Grazie in anticipo...

Hai seguito almeno qualche lezione?


Prima cosa: convenzioni Java per i nomi
java.about.com/od/javasyntax/a/…
Non ne hai azzeccata nemmeno una.

Una classe con VENTISETTE campi pubblici??? Le classi devono essere piccole e coese. I campi devono essere privati e associati eventualmente ad un getter pubblico.

Le classi devono avere metodi specifici per ogni funzionalità. Un metodo deve fare UNA sola cosa, e farla bene. Tu hai scritto, praticamente, un metodo che fa tutto, esattamente come un main del C (questo è un eufemismo, dato che anche i programmatori C spezzano il codice in sottofunzioni con logica).

Le classi devono avere interessi separati (separation of concern): non puoi usare la stessa classe per logiche di presentazione e di funzionalità (in questo caso, stai usando println in un metodo per il calcolo).

Non ripeterti: perché esistono variabili o metodi il cui nome differisce solo per un 2? Ti sembra che quel "2" dica a chi legge il codice alcunché sulla sua funzione? Che differenza c'è tra un treno che parte in centrale e uno che parte in periferia? Nessuna. Hanno esattamente le stesse caratteristiche. Partono solo da punti diversi. Se continuassi a ragionare così dovresti aggiungere un metodo per ogni treno che si aggiunge al calcolo.

Cosa sono d, e, w, z ed f? Ha senso renderli pubblici?
In genere il codice è illeggibile.

Il punto di incontro è una proprietà del treno? A me sembra di no.

Potrei continuare... In sostanza hai infranto ogni possibile principio di programmazione ad oggetti che mi viene in mente al momento. Questo è un record