Stringa vuota

[mirko89]

Devo controllare se l'utente inserisce una stringa vuota. Per farlo uso il metodo trim. Il tutto funziona ma accade una cosa strana ... Se all'inserimento non scrivo niente e premo invio non compare il messaggio di errore che ho impostato e affinchè questo accada devo premere invio nuovamente. Questo mi accade solo per il primo inserimento; infatti sempre nella stessa esecuzione ma ad inserimenti successivi questo non succede. Come mai ???

[andbin]

Originariamente inviato da mirko89
Come mai ???

Non sono bravo come indovino .... posta il codice.

[mirko89]

[b]QUESTA E LA CLASSE COL MAIN[b/]

public class CuoriSolitariMain 
{
 private static final String MESSAGGIO_NICKNAME="Inserire nickname: ";
 private static final String MESSAGGIO_ETA="Inserire età: ";
 private static final String MESSAGGIO_SESSO="Inserire M se maschio oppure F se femmina: ";
 private static final String MESSAGGIO_SEGNO="Inserire segno zodiacale%n";
 private static final String MESSAGGIO_SEGNO_PARTNER="Inserire segno zodiacale del partner ideale%n";
 private static final String MESSAGGIO_INIZIALE="Benvenuto!";
 private static final String MESSAGGIO_INTESTAZIONE="%nInserisci i tuoi dati Cuore Solitario!%n";
 private static final int MAGGIORE_ETA=18;
 private static final int SOGLIA_ETA=120;
 private static final String MESSAGGIO_MAGGIORE_ETA="Servizio riservato ai maggiorenni!";
 private static final String MESSAGGIO_SOGLIA_ETA="Età improbabile!";
 
 public static void main(String[] args) 
 {
  saluta();
  stampa_intestazione();
  CuoreSolitario persona1=creaDati();
  stampa_intestazione();
  CuoreSolitario persona2=creaDati(); 
  persona1.check_affinità(persona2);
 }
	 
 
 public static void saluta()
 {
  System.out.println(MESSAGGIO_INIZIALE);
 }
	 
 
 public static CuoreSolitario creaDati()
 {
  String nickname_in=MyUtil.leggiStringa(MESSAGGIO_NICKNAME);
  int età_in=MyUtil.leggiInteroRange(MESSAGGIO_ETA, MESSAGGIO_MAGGIORE_ETA, MESSAGGIO_SOGLIA_ETA, MAGGIORE_ETA, SOGLIA_ETA);
  char sesso_in=MyUtil.leggiCarattere(MESSAGGIO_SESSO);
  Zodiaco segno_in=Zodiaco.leggiSegno(MESSAGGIO_SEGNO);
  Zodiaco segnoPartner_in=Zodiaco.leggiSegno(MESSAGGIO_SEGNO_PARTNER);
  return new CuoreSolitario(nickname_in,età_in,sesso_in,segno_in,segnoPartner_in);
 }
	 
 
 public static void stampa_intestazione()
 {
  System.out.printf(MESSAGGIO_INTESTAZIONE);
 }
}

E QUESTA E' UNA CLASSE DOVE C'E' UN METODO PER LEGGERE STRINGHE CON RELATIVI CONTROLLI

import java.util.*;
public class MyUtil 
{
 private static Scanner lettore=creaLettore();
 private static final String ERRORE_STRINGA_VUOTA="Errore: nessun carattere inserito!";
 private static final String ERRORE_FORMATO_CARATTERE="Errore: inserire M o F!";
 private static final String ERRORE_FORMATO_INTERO="Errore: inserire un numero intero!";
 
 public static Scanner creaLettore()
 {
  Scanner lettore=new Scanner(System.in);
  String aCapo=System.getProperty("line.separator");
  lettore.useDelimiter(aCapo);
  return lettore;
 }

 
 public static String leggiStringa(String messaggio)
 {
  boolean finito=false;
  String stringaLetta="";
  do
  {
   System.out.printf(messaggio);  
   stringaLetta=lettore.next();
   stringaLetta=stringaLetta.trim();
   if (!stringaLetta.equals(""))
	    finito=true;
   else
	    System.out.println(ERRORE_STRINGA_VUOTA);
  }
  while(!finito);
  return stringaLetta;
 }

 
 public static int leggiIntero(String messaggio)
 {
  boolean finito=false;
  int valoreLetto=0;
  do
  {
   System.out.printf(messaggio);
   if(lettore.hasNextInt())
   	{
	 valoreLetto=lettore.nextInt();
	 finito=true;
   	}
   else
   {
	 System.out.println(ERRORE_FORMATO_INTERO);
	 String daButtare=lettore.next();
   }
  }
  while(!finito);
  return valoreLetto;
 }

 
 public static char leggiCarattere(String messaggio)
 {
  boolean finito=false;
  char carattereLetto='\0';
  do
  {
   String lettura=leggiStringa(messaggio);
   lettura=lettura.toUpperCase();  
   if (lettura.length()>2)									//controllo che venga inserito 1 solo carattere
	    System.out.println(ERRORE_FORMATO_CARATTERE);
   else
       {
	    carattereLetto=lettura.charAt(0);
	    if((carattereLetto=='M')||(carattereLetto=='F'))
	    	finito=true;
	    else
	    	System.out.println(ERRORE_FORMATO_CARATTERE);	
       }
  }
  while(!finito);
  return carattereLetto;
 }
 
 
 public static int leggiInteroRange(String messaggio,String messaggioErroreMin,String messaggioErroreMax,int sogliaMin,int sogliaMax)
 {
  boolean finito=false;										
  int valoreLetto=0;
  do
  {
   valoreLetto=leggiIntero(messaggio);
   if ((valoreLetto>=sogliaMin)&&(valoreLetto<=sogliaMax))
	   finito=true;
   else
   	{
	   if (valoreLetto>sogliaMax)
	   {
	   	System.out.println(messaggioErroreMax);
	    finito=false;   
	   }
	   else
	   {
		System.out.println(messaggioErroreMin);
	    finito=false;
	   }
   	}
  }
  while(!finito);
 return valoreLetto;
 }
}

[Gianpaolo69]

Una curiosità: perchè fai tutto static?

[Pacio88]

Originariamente inviato da Gianpaolo69
Una curiosità: perchè fai tutto static?

Mi unisco per chiedere perchè oltre a mettere tutto static metti tutto anche final.. dal momento in cui si mette final non è superfluo mettere static?

[LeleFT]

Originariamente inviato da Pacio88
dal momento in cui si mette final non è superfluo mettere static?

No: il modificatore final ha significato diverso da static:

Il modificatore final:
- Quando è applicato ad una variabile indica che si tratta di una costante.
- Quando è applicato ad un metodo indica che questo non può essere ridefinito tramite overriding nelle sottoclassi.
- Quando è applicato ad una classe indica che non è possibile creare delle sottoclassi.


Il modificatore static indica, invece, che quella variabile/metodo non è legata ad una particolare istanza della classe, ma è legatto alla classe stessa.


Ciao.

[Pacio88]

Originariamente inviato da LeleFT
No: il modificatore final ha significato diverso da static:

Il modificatore final:
- Quando è applicato ad una variabile indica che si tratta di una costante.
- Quando è applicato ad un metodo indica che questo non può essere ridefinito tramite overriding nelle sottoclassi.
- Quando è applicato ad una classe indica che non è possibile creare delle sottoclassi.


Il modificatore static indica, invece, che quella variabile/metodo non è legata ad una particolare istanza della classe, ma è legatto alla classe stessa.


Ciao.

Grazie per il breve riassunto.. ma continuo a non capire...
Se la variabile di una classe è costante non è sottointeso che sarà uguale per ogni istanza di quella classe e quindi è come se fosse dichiarata con "static"?

[andbin]

Originariamente inviato da Pacio88
Se la variabile di una classe è costante non è sottointeso che sarà uguale per ogni istanza di quella classe e quindi è come se fosse dichiarata con "static"?

class Qualcosa {
    static final int a = 123;
    static int b = 123;
    final int c = 123;
    int d = 123;
}

'a' è "di classe" e final. Essendo di classe ce n'è solo 1 di quella variabile, indipendentemente dal numero di istanze (oggetti) della classe ed essendo final non è modificabile = è una "costante".

'b' è "di classe" ma non è final. Ce n'è solo 1 di quella variabile e non essendo final è modificabile. Concettualmente la puoi vedere come una variabile "globale".

'c' è "di istanza" e final. Ogni istanza della classe ha la "sua" variabile 'c' ed essendo final non è modificabile = è una costante. Messa così ha poco senso/utilità .... se alla variabile fosse assegnato un valore calcolato o il valore di ritorno di un metodo, avrebbe più senso/utilità.

'd' è "di istanza" e non final. Ogni istanza della classe ha la "sua" variabile 'd', il cui valore può cambiare non essendo final.

[LeleFT]

Originariamente inviato da Pacio88
Grazie per il breve riassunto.. ma continuo a non capire...
Se la variabile di una classe è costante non è sottointeso che sarà uguale per ogni istanza di quella classe e quindi è come se fosse dichiarata con "static"?

No: se una variabile è costante significa che, per quelll'istanza della classe, quella variabile assumerà quel determinato valore costante. Questo non significa che tutte le istanze di quella classe condividono la stessa variabile, quindi non significa affatto che quella variabile possa essere acceduta con la forma NomeClasse.variabile.

Per capire bene questa differenza ti consiglio anche un interessante link: http://en.wikipedia.org/wiki/Final_(Java)

Una variabile final diventa costante perchè l'assegnazione a tale variabile può avvenire una sola volta: questo significa che il valore "costante" può essere deciso all'interno del costruttore della classe e, quindi, essere diverso da istanza a istanza. Il valore non è noto a tempo di compilazione (diverso è per i valore static final), ma solo a tempo di esecuzione.

Esempio:

public class MiaClasse {
   private final int valoreCostante;

   public MiaClasse(int val) {
      // assegno qui il valore e non lo posso più cambiare dopo
      valoreCostante = val;
   }
}

In questo caso, quindi, ciascuna istanza può avere il suo valore costante:

MiaClasse[] mc = new MiaClasse[10];
for(int j=0; j<10; j++) {
   mc[j] = new MiaClasse( j );
}

Ciao.

[Pastore12]

Ti consiglierei di modificare questo pezzo di codice:

   stringaLetta=stringaLetta.trim();
   if (!stringaLetta.equals(""))
      finito=true;
   else
      System.out.println(ERRORE_STRINGA_VUOTA);

con:

   if (stringaLetta!=null && !stringaLetta.trim().equals(""))
      finito=true;
   else
      System.out.println(ERRORE_STRINGA_VUOTA);

Ovviamente sarebbe interessante scoprire se ottenevi una NullPointerException o altro...