Da questa puntata svilupperemo un’applicazione interessante, cha aggiunge alcune cose a quelle che già conosciamo, oltre ad illustrare il funzionamento delle istruzioni presentate nella lezione precedente.
Lo scopo del programma è leggere una stringa immessa dall’utente, esaminandone il primo e l’ultimo carattere per vedere se si tratta di un numero, una lettera o un carattere speciale.
Nel caso che sia un carattere dirà se si tratta di una vocale o di una consonante e se è maiuscola o minuscola; per alcuni caratteri speciali dirà anche il tipo di carattere (punto, virgola, asterisco, etc.).
L’applicazione consiste di una sola classe, TestCondizionali, dotata di un metodo main (necessario per i motivi visti nella lezione 17) e di un metodo controllaCarattere(char), che riceve in ingresso il carattere da controllare.
Per il momento ci occuperemo solo di questo metodo, il cui corpo è riportato di seguito:

public static void controllaCarattere(char c) {
if (Character.isDigit(c)) {
System.out.println("Il carattere è un numero");
} else if (Character.isLetter(c)){
String m = Character.isUpperCase(c) ? "maiuscola" : "minuscola";
      String v = null;
                 
      switch (Character.toLowerCase(c)) {
            case 'a' :
            case 'e' :
            case 'i' :
            case 'o' :
            case 'u' : v = "vocale";
                       break;
            default : v = "consonante";
      }
      System.out.println("Il carattere e' una " + v + " " + m);
} else {
String speciale;
      switch (c) {
            case ' ' : speciale = "uno spazio"; break;
            case '.' : speciale = "un punto"; break;
            case ',' : speciale = "una virgola"; break;
            case ';' : speciale = "un punto e virgola"; break;
            case '?' : speciale = "un punto interrogativo"; break;
            case '!' : speciale = "un punto esclamativo"; break;
            case '*' : speciale = "un asterisco"; break;
            case '+' : speciale = "un segno piu'"; break;
            case '-' : speciale = "un segno meno"; break;
            default : speciale = "un carattere speciale";
      }
      System.out.println("Il carattere e' " + speciale);
}
}

Il corpo del metodo contiene un’unica grande istruzione if-else (evidenziata in blu nel codice), che controlla se il carattere ricevuto come parametro è un numero, una lettera o un carattere speciale.
Per fare questo controllo vengono usati due metodi statici della classe Character, appartenente al package java.lang:

public static boolean isDigit(char ch)
Restituisce true se ch è una cifra (0-9), false altrimenti.

public static boolean isLetter(char ch)
Restituisce true se ch è una lettera (a-z, A-Z), false altrimenti.

L’algoritmo controlla innanzitutto che il carattere sia un numero.
Se lo è (blocco if) viene stampato a video il messaggio corrispondente, altrimenti controlla se è una lettera (blocco else-if): se questo test è positivo, viene eseguito il blocco corrispondente (evidenziato in rosso nel codice), altrimenti (blocco else) l’algoritmo conclude che si tratta di un carattere speciale ed intraprende le azioni appropriate.
Esaminiamo il blocco else-if (quello evidenziato in rosso).
La prima istruzione dichiara una variabile m di tipo String, inizializzandola al valore “maiuscola” o “minuscola” a seconda che il carattere c sia maiuscolo o minuscolo.
Per fare questo controllo viene usato un altro metodo della classe Character:

public static boolean isUpperCase(char ch)
Restituisce true se ch è un carattere maiuscolo, false altrimenti.

La classe Character fornisce anche il metodo duale del precedente:

public static boolean isLowerCase(char ch)
Restituisce true se ch è un carattere minuscolo, false altrimenti.

Per assegnare il valore ad m utilizziamo l’operatore ternario, che restituisce la stringa “maiuscola” se il test Character.isUpperCase(c) ritorna true, “minuscola” in caso contrario.
L’istruzione switch successiva viene utilizzata per assegnare alla variabile v il valore “vocale” o “consonante” a seconda del valore di c ed è molto interessante, perché ci consente di vedere come sfruttare la proprietà di fall through dello switch a nostro vantaggio.
L’espressione da valutare è Character.toLowerCase(c) che restituisce il corrispondente carattere minuscolo di c; se c è già minuscolo, viene restituito c stesso.
L’analogo metodo per ricavare il corrispondente maiuscolo di c è Character.toUpperCase(c).
La segnatura di questi metodi è:

public static char toLowerCase(char ch)
public static char toUpperCase(char ch)

Questa espressione viene utilizzata per ridurre il numero di case dello switch, perché non sappiamo a priori se c è maiuscolo o minuscolo.
Se l’espressione restituita è uguale ad uno dei caratteri elencati nei primi 5 case (‘a’, ‘e’, ‘i’, ‘o’, ‘u’), saranno eseguite le istruzioni che seguono i due punti (:) corrispondenti al carattere appropriato e, poiché manca il break, l’esecuzione proseguirà attraverso i case successivi: il risultato è che a v sarà assegnato il valore “vocale”.
Se nessun carattere elencato nei primi 5 case corrisponde al valore restituito dall’espressione, v conterrà la stringa “consonante”.
Il blocco else rappresenta un esempio classico di utilizzo dell’istruzione switch, con un break per ogni case.
In attesa della prossima lezione, potete creare delle applicazioni che utilizzano questo metodo, che potete provare a modificare ed arricchire a vostro piacimento.

Torna all'indice Generale del corso di Corso di Java di Software Planet