Roadmap -...

Modulo di Fondamenti di Programmazione P. Baroni - P.Martinelli - M. Rossi - A. Viola

Strutture di controllo 1

Fondamenti di Programmazione

RoadmapRoadmap

•• 0. Primi passi con Java0. Primi passi con Java

•• 1. Buone abitudini1. Buone abitudini

•• 2. Tipi di dati primitivi2. Tipi di dati primitivi

•• 3. Uso di classi3. Uso di classi

•• 4. Leggere e scrivere4. Leggere e scrivere

•• 5. Definire metodi5. Definire metodi

•• 6. Strutture di controllo6. Strutture di controllo


Strutture di controlloStrutture di controllo

•• Abbiamo iniziato a strutturare i programmi in Abbiamo iniziato a strutturare i programmi in classi con più metodi, ma i nostri metodi classi con più metodi, ma i nostri metodi “fanno poco” solo semplici istruzioni di input, “fanno poco” solo semplici istruzioni di input, elaborazione ed output eseguite in modo elaborazione ed output eseguite in modo strettamente sequenzialestrettamente sequenziale

•• Qualunque programma non banale richiede Qualunque programma non banale richiede flussi di esecuzione più articolati rispetto alla flussi di esecuzione più articolati rispetto alla semplice sequenza: servono anche selezione semplice sequenza: servono anche selezione e iterazione (teorema e iterazione (teorema BBööhmhm –– Jacopini)Jacopini)




RoadmapRoadmap

•• 6. Strutture di controllo6. Strutture di controlloCostrutto di selezione Costrutto di selezione ifif--elseelse


Poter scegliere (Poter scegliere (ifif -- else)else)

ifif ((espressione espressione booleanabooleana))istruzione semplice o compostaistruzione semplice o composta

else else istruzione semplice o compostaistruzione semplice o composta

valutazioneespressione

istruzione parte if

istruzione parte else

true false




Indice massa corporeaIndice massa corporea

•• L’indice di massa corporea è considerato L’indice di massa corporea è considerato normale se compreso tra 18.5 e 25normale se compreso tra 18.5 e 25

•• Vogliamo estendere la nostra classe con un Vogliamo estendere la nostra classe con un metodo metodo booleanobooleano che verifica se l’indice è che verifica se l’indice è normale o menonormale o meno

•• N.B. Anche se queste indicazioni sono prese N.B. Anche se queste indicazioni sono prese da fonti attendibili, sono presentate a puro da fonti attendibili, sono presentate a puro scopo di esercizioscopo di esercizio


Uso di Uso di ifif--elseelse

public class DatiPersonali{. . .private final static double MINIMO_NORMA = 18.5;private final static double MASSIMO_NORMA = 25;. . .

public boolean nellaNorma (){double myIndex = indiceMassaCorporea();

if ((myIndex >= MINIMO_NORMA)&&(myIndex<= MASSIMO_NORMA))return true

elsereturn false;

}. . .}




ifif isolatoisolato

ifif ((espressione espressione booleanabooleana))istruzione semplice o compostaistruzione semplice o composta


istruzione parte if

true

false


Indice massa corporeaIndice massa corporea

•• Se l’indice non è nella norma vogliamo dare Se l’indice non è nella norma vogliamo dare un avviso all’utenteun avviso all’utente

•• Modificheremo quindi il metodo Modificheremo quindi il metodo toStringtoString




Uso di Uso di ifif isolatoisolatopublic class DatiPersonali{ . . .public String toString (){StringBuffer risultato = new StringBuffer();risultato.append(String.format(MESSAGGIO_BASE,peso,altezza));risultato.append(String.format(MESSAGGIO_MASSA, indiceMassaCorporea()));

if (!nellaNorma()){risultato.append(CORNICE);risultato.append(AVVERTIMENTO);risultato.append(SUGGERIMENTO);risultato.append(CORNICE);}

risultato.append(String.format(MESSAGGIO_CALORIE, calorieGiornaliere()));

return risultato.toString();}


Uso di Uso di ifif isolatoisolato

public class DatiPersonali{. . .private final static String AVVERTIMENTO = "Attenzione l'indice di massa corporea e' fuori dai valori normali\n";

private final static String SUGGERIMENTO = "E' consigliabile verificare la situazione con un medico\n";

private final static String CORNICE = "*****************************************************************\n";

. . .public String toString (){. . .}

}




Espressione con selezioneEspressione con selezione

espressione espressione booleanabooleana ? ? valoreTvaloreT : : valoreFvaloreF

valutazioneespressionebooleana

valoreT valoreF


Uso della selezioneUso della selezione

•• Calcolo del valore assoluto di un numero (p.e. Calcolo del valore assoluto di un numero (p.e. nella classe nella classe MathMath non c’e’ il metodo per non c’e’ il metodo per numeri short)numeri short)

public public staticstatic short short absabs (short (short numnum)){{return return numnum >= 0 ? >= 0 ? numnum : : -- numnum;;}}

L’intero costrutto viene valutatoin base all’espressione booleanase true viene restituito il valore prima dei : se false viene restituito quello dopo




ifif annidati (annidati (nestednested, nidificati), nidificati)

•• Spesso l’insieme di condizioni da verificare è Spesso l’insieme di condizioni da verificare è articolato e richiede che uno o entrambi i rami articolato e richiede che uno o entrambi i rami di un costrutto di un costrutto ifif a loro volta contengano un a loro volta contengano un ifif

•• In caso di uso articolato di In caso di uso articolato di ifif annidati può annidati può essere utile disegnare lo schema a blocchi essere utile disegnare lo schema a blocchi corrispondente per evitare di confondersicorrispondente per evitare di confondersi


Un avviso più precisoUn avviso più preciso

•• Nel caso di indice di massa corporea fuori Nel caso di indice di massa corporea fuori norma vogliamo distinguere i valori troppo norma vogliamo distinguere i valori troppo bassi da quelli troppo altibassi da quelli troppo alti

•• Questo può essere ottenuto definendo un Questo può essere ottenuto definendo un metodo che restituisce un numero intero e metodo che restituisce un numero intero e stabilendo una convenzione (0 normale, 1 stabilendo una convenzione (0 normale, 1 troppo alto, troppo alto, --1 troppo basso)1 troppo basso)

•• Una soluzione più sofisticata userebbe Una soluzione più sofisticata userebbe enumenum





myIndex<MINIMOfalse true

return NORMALE

return ALTO

myIndex<=MASSIMOtrue false return BASSO



public class DatiPersonali{. . .private final static int LIVELLO_NORMALE = 0;private final static int LIVELLO_ALTO = 1;private final static int LIVELLO_BASSO = -1;. . .

public int livelloIndice (){double myIndex = indiceMassaCorporea();if (myIndex < MINIMO_NORMA)

return LIVELLO_BASSO;else

if (myIndex <= MASSIMO_NORMA)return LIVELLO_NORMALE;

else return LIVELLO_ALTO;

}. . .}





public class DatiPersonali{. . .public public StringString toStringtoString ()(){{StringBufferStringBuffer risultato = new risultato = new StringBufferStringBuffer();();risultato.appendrisultato.append((String.formatString.format(MESSAGGIO_BASE,peso,altezza));(MESSAGGIO_BASE,peso,altezza));risultato.append(String.format(MESSAGGIO_MASSA, risultato.append(String.format(MESSAGGIO_MASSA, indiceMassaCorporeaindiceMassaCorporea()));()));

ifif (!(!nellaNormanellaNorma())()){{risultato.appendrisultato.append(CORNICE);(CORNICE);risultato.append(AVVERTIMENTO);risultato.append(AVVERTIMENTO);if (livelloIndice() == LIVELLO_BASSO)if (livelloIndice() == LIVELLO_BASSO)

risultato.appendrisultato.append(SOTTOPESO);(SOTTOPESO);elseelse

risultato.appendrisultato.append(SOVRAPPESO);(SOVRAPPESO);risultato.appendrisultato.append(SUGGERIMENTO);(SUGGERIMENTO);risultato.appendrisultato.append(CORNICE);(CORNICE);

}}risultato.appendrisultato.append((String.formatString.format(MESSAGGIO_CALORIE, (MESSAGGIO_CALORIE, calorieGiornalierecalorieGiornaliere()));()));

return return risultato.toStringrisultato.toString();();}}


else pendente (else pendente (danglingdangling else)else)

•• In caso di In caso di ifif annidati ogni else si riferisce annidati ogni else si riferisce all'ultimo all'ultimo ifif "aperto" che non è stato chiuso da "aperto" che non è stato chiuso da un elseun else

•• In caso di disattenzioni questo può causare In caso di disattenzioni questo può causare errori subdolierrori subdoli

•• Supponiamo di aver preso una strada diversa Supponiamo di aver preso una strada diversa per la valutazione del nostro indiceper la valutazione del nostro indice




else pendenteelse pendente

intint livello = LIVELLO_NORMALE;livello = LIVELLO_NORMALE;

ifif ((myIndexmyIndex >= MINIMO_NORMA)>= MINIMO_NORMA)ifif ((myIndexmyIndex > MASSIMO_NORMA)> MASSIMO_NORMA)livello = LIVELLO_ALTO; livello = LIVELLO_ALTO;

else // ERRORE !!else // ERRORE !!livello = LIVELLO_BASSO; livello = LIVELLO_BASSO;

return livello;return livello;

else si riferisce all’if più interno, indipendentemente dall’indentazione

Questa soluzione compila, gira ma scambia LIVELLO_NORMALE e LIVELLO_BASSO nei risultati prodotti !


else pendenteelse pendente

•• Il problema si risolve con un uso opportuno Il problema si risolve con un uso opportuno delle parentesi graffedelle parentesi graffe

intint livello = LIVELLO_NORMALE;livello = LIVELLO_NORMALE;ifif ((myIndexmyIndex >= MINIMO_NORMA)>= MINIMO_NORMA){{ifif ((myIndexmyIndex > MASSIMO_NORMA)> MASSIMO_NORMA)livello = LIVELLO_ALTO; livello = LIVELLO_ALTO;

} } else else livello = LIVELLO_BASSO; livello = LIVELLO_BASSO;

return livello;return livello;




RoadmapRoadmap


Costrutto di selezione Costrutto di selezione switchswitch


Selezione multipla (Selezione multipla (switchswitch))

•• Spesso si deve effettuare una selezione tra Spesso si deve effettuare una selezione tra molteplici alternative rappresentabili con molteplici alternative rappresentabili con numeri interi o singoli caratterinumeri interi o singoli caratteri

•• Se le alternative sono molte è decisamente Se le alternative sono molte è decisamente scomodo (anche se possibile) usare scomodo (anche se possibile) usare ifif--elseelse a a ripetizioneripetizione

•• Il costrutto Il costrutto switchswitch permette di specificare la permette di specificare la selezione in modo più comodoselezione in modo più comodo




Selezione multipla (Selezione multipla (switchswitch))

switchswitch ((espressione byte, short, espressione byte, short, intint, o , o charchar) {) {case case valore1 valore1 :: istruzioni1istruzioni1;; break ;break ;case case valore2 valore2 :: istruzioni2istruzioni2;; break ;break ;

......case case valoreNvaloreN :: istruzioniNistruzioniN;; break ;break ;defaultdefault : : istruzioneDefaultistruzioneDefault ;;

}}N.B. IlN.B. Il break break è fondamentale !è fondamentale !

switchswitch ((espressione intera o espressione intera o charchar) {) {case case valore1 valore1 ::case case valore2 valore2 :: istruzioni1&2istruzioni1&2;; break ;break ;

}}


Esempio uso di Esempio uso di switchswitch

int categoriaAuto;. . .switch (categoriaAuto) {

case 0 : System.out.println("Euro 0: di giorno hai il fermo!");

break ;case 1 : System.out.println("Euro 1: puoi circolare ma è un po’ vecchiotta: ci sono gli incentivi");

break ;

...case 4 : System.out.println("Euro 4: macchina nuova");

break ;

default : System.out.println("Errore: categoria inesistente");

}




Solo 1.5: Solo 1.5: switchswitch con con enumenum

public public enumenum Stagione {PRIMAVERA, ESTATE, AUTUNNO, Stagione {PRIMAVERA, ESTATE, AUTUNNO, INVERNO};INVERNO};

Stagione periodo; Stagione periodo; ......

switch (periodo)switch (periodo){{case Stagione.PRIMAVERA:case Stagione.PRIMAVERA:System.out.printlnSystem.out.println("Spuntano i fiori");("Spuntano i fiori");break;break;

case Stagione.ESTATE:case Stagione.ESTATE:System.out.printlnSystem.out.println("Fa caldo");("Fa caldo");break;break;

... // altri casi... // altri casi}}


Solo 7: Solo 7: switchswitch su stringhesu stringhe

StringString risposta; risposta; ......

switchswitch (risposta)(risposta){{

case "SI":case "SI":// azioni per risposta affermativa// azioni per risposta affermativabreak;break;

case "NO":case "NO":// azioni per risposta negativa// azioni per risposta negativabreak;break;

... // altri casi e/o ... // altri casi e/o defaultdefault}}




RoadmapRoadmap



Costrutti iterativiCostrutti iterativi


IterazioneIterazione

•• E' comune l'esigenza di ripetere (iterare) una E' comune l'esigenza di ripetere (iterare) una istruzione (semplice o composta) per un dato istruzione (semplice o composta) per un dato numero di volte e/o sotto certe condizioninumero di volte e/o sotto certe condizioni

•• Le strutture di controllo iterative Le strutture di controllo iterative comprendono:comprendono:–– ciclo ciclo forfor

–– ciclo ciclo whilewhile

–– ciclo ciclo dodo--whilewhile




RoadmapRoadmap




Ciclo Ciclo forfor


Investimento a tasso fissoInvestimento a tasso fisso

•• Supponiamo di voler calcolare l’andamento del valore Supponiamo di voler calcolare l’andamento del valore di un investimento pluriennale di durata nota e tasso di un investimento pluriennale di durata nota e tasso fisso, nel quale gli interessi vengono annualmente fisso, nel quale gli interessi vengono annualmente reinvestiti (interesse composto)reinvestiti (interesse composto)

•• Definiremo una classe Investimento i cui attributi Definiremo una classe Investimento i cui attributi sono: capitale iniziale, durata e tassosono: capitale iniziale, durata e tasso

•• Una volta acquisiti i dati e costruita l’istanza di Una volta acquisiti i dati e costruita l’istanza di Investimento servirà un metodo per visualizzare il Investimento servirà un metodo per visualizzare il valore anno per annovalore anno per anno




Investimento a tasso fissoInvestimento a tasso fisso

•• La visualizzazione dell’andamento richiede di La visualizzazione dell’andamento richiede di ripetere un numero prefissato di volte (la ripetere un numero prefissato di volte (la durata dell’investimento) le stesse operazioni: durata dell’investimento) le stesse operazioni: calcolare l’interesse di quell’anno, calcolare il calcolare l’interesse di quell’anno, calcolare il nuovo valore e visualizzarlonuovo valore e visualizzarlo

•• Il ciclo Il ciclo forfor è concepito esattamente per la è concepito esattamente per la ripetizione di operazioni un numero prefissato ripetizione di operazioni un numero prefissato di voltedi volte


Investimento: Investimento: la classe con il la classe con il mainmain

public class public class InvestimentoMainInvestimentoMain{{private final private final staticstatic StringString MESSAGGIO_CAPITALE = "Inserire il MESSAGGIO_CAPITALE = "Inserire il capitale iniziale dell’investimento a tasso fisso:";capitale iniziale dell’investimento a tasso fisso:";

private final private final staticstatic StringString MESSAGGIO_DURATA = "Inserire la MESSAGGIO_DURATA = "Inserire la durata in anni dell’investimento:";durata in anni dell’investimento:";

private final private final staticstatic StringString MESSAGGIO_TASSO = "Inserire il tasso MESSAGGIO_TASSO = "Inserire il tasso percentuale annuale dell’investimento:";percentuale annuale dell’investimento:";

public public staticstatic voidvoid mainmain ((StringString [] [] argsargs)){{

Investimento Investimento bondbond = = creaInvestimentocreaInvestimento();();bond.stampaAndamentobond.stampaAndamento();();

}}

private private staticstatic Investimento Investimento creaInvestimentocreaInvestimento()(){{doubledouble capitale = capitale = MyUtil.leggiDoubleMyUtil.leggiDouble(MESSAGGIO_CAPITALE);(MESSAGGIO_CAPITALE);intint durata = durata = MyUtil.leggiInteroMyUtil.leggiIntero(MESSAGGIO_DURATA);(MESSAGGIO_DURATA);doubledouble tasso = tasso = MyUtil.leggiDoubleMyUtil.leggiDouble(MESSAGGIO_TASSO);(MESSAGGIO_TASSO);return new Investimento(capitale,durata,tasso);return new Investimento(capitale,durata,tasso);

} } }}




La classe InvestimentoLa classe Investimentopublic class Investimentopublic class Investimento{{private private doubledouble capitale;capitale;private int durata;private int durata;private double tasso;private double tasso;

final static String MESSAGGIO_ANNO = "Anno:%2d final static String MESSAGGIO_ANNO = "Anno:%2d -- Valore: %1.2f%n";Valore: %1.2f%n";

public Investimento (public Investimento (doubledouble capitale, capitale, intint durata, durata, doubledouble tasso)tasso){{thisthis.capitale = capitale;.capitale = capitale;thisthis.durata = durata;.durata = durata;thisthis.tasso = tasso;.tasso = tasso;}}

public public voidvoid stampaAndamentostampaAndamento()(){{doubledouble valore = capitale;valore = capitale;forfor ((intint anno=1; anno <= durata; anno++)anno=1; anno <= durata; anno++){{doubledouble interesse = valore * tasso/100;interesse = valore * tasso/100;valore = valore + interesse;valore = valore + interesse;System.out.printfSystem.out.printf(MESSAGGIO_ANNO, anno, valore);(MESSAGGIO_ANNO, anno, valore);

} } } }

}}


Ciclo Ciclo forforforfor((inizializzazioneinizializzazione/i ; espressione /i ; espressione booleanabooleana; ; stepstep/s ) /s )

istruzione semplice o compostaistruzione semplice o composta

forfor ((intint anno=1; anno <= durata; anno++)anno=1; anno <= durata; anno++){{doubledouble interesse = valore * tasso/100;interesse = valore * tasso/100;valore = valore + interesse;valore = valore + interesse;System.out.printfSystem.out.printf(MESSAGGIO_ANNO, anno, valore);(MESSAGGIO_ANNO, anno, valore);} }

L’inizializzazione nella maggior parte dei casi riguarda una variabile int, detta variabile indice del ciclo (o variabile di ciclo)

L’espressione nella maggior parte dei casi riguarda un confronto tra la variabile indice e un valore limite

Lo step nella maggior parte dei casi è l’incremento o decremento della variabile indice

L’istruzione semplice o composta viene detta corpo del ciclo




Ciclo Ciclo forfor


corpo del ciclo

true

false

inizializzazioni

step(azioni fine iterazione)


Terminazione ciclo Terminazione ciclo forfor

•• Il corpo del ciclo Il corpo del ciclo forfor viene iterato fino a quando la viene iterato fino a quando la condizione di ingresso diviene falsacondizione di ingresso diviene falsa

•• E' compito del programmatore garantire che questo E' compito del programmatore garantire che questo avvenga definendo opportunamente la condizione avvenga definendo opportunamente la condizione stessa e le azioni di fine iterazionestessa e le azioni di fine iterazione

•• In caso di errore si verifica un ciclo infinito: il ciclo (e In caso di errore si verifica un ciclo infinito: il ciclo (e quindi il programma) non giunge mai a terminazione quindi il programma) non giunge mai a terminazione (spontaneamente)(spontaneamente)

•• Tipico errore: scambiare Tipico errore: scambiare ---- con ++con ++




Ciclo Ciclo forfor

•• Usare più di una Usare più di una inizializzazioneinizializzazione o di una o di una azione di fine iterazione è possibile ma in azione di fine iterazione è possibile ma in genere sconsigliato (genera confusione)genere sconsigliato (genera confusione)

•• Modificare la variabile di ciclo nel corpo del Modificare la variabile di ciclo nel corpo del ciclo è possibile ma sconsigliatociclo è possibile ma sconsigliato

•• Mettere un ; dopo il Mettere un ; dopo il forfor è sintatticamente è sintatticamente corretto ma di solito non voluto e subdolo corretto ma di solito non voluto e subdolo (ciclo con corpo vuoto)(ciclo con corpo vuoto)


RoadmapRoadmap




Ciclo Ciclo forfor

Ciclo Ciclo whilewhile





•• Non sempre è possibile predeterminare il Non sempre è possibile predeterminare il numero di iterazioni necessarie per il corpo di numero di iterazioni necessarie per il corpo di un certo ciclo: l’uscita dal ciclo può dipendere un certo ciclo: l’uscita dal ciclo può dipendere da una condizione che dipende da una condizione che dipende dall’esecuzione del corpo del ciclo stessodall’esecuzione del corpo del ciclo stesso

•• In questo caso la terminazione avviene al In questo caso la terminazione avviene al raggiungimento della condizione piuttosto che raggiungimento della condizione piuttosto che dopo un numero prefissato di voltedopo un numero prefissato di volte



whilewhile (espressione (espressione booleanabooleana))istruzione semplice o compostaistruzione semplice o composta


corpo del ciclo

true

false




Raddoppio del capitaleRaddoppio del capitale

•• Vogliamo stabilire in quanti anni si raddoppia Vogliamo stabilire in quanti anni si raddoppia il capitale di un investimentoil capitale di un investimento

•• Dovremo calcolare il suo valore anno per Dovremo calcolare il suo valore anno per anno e terminare il calcolo quando si anno e terminare il calcolo quando si raggiunge il raddoppioraggiunge il raddoppio

•• Dovremo anche considerare che il raddoppio Dovremo anche considerare che il raddoppio potrebbe non avvenire entro la durata potrebbe non avvenire entro la durata prevista dell’investimento prevista dell’investimento


Raddoppio del capitaleRaddoppio del capitale

•• Aggiungeremo un metodo alla classe Investimento Aggiungeremo un metodo alla classe Investimento che restituisce il numero di anni necessari al che restituisce il numero di anni necessari al raddoppioraddoppio

•• Stabiliamo di restituire Stabiliamo di restituire ––1 se il raddoppio non 1 se il raddoppio non avviene entro la durata dell’investimentoavviene entro la durata dell’investimento

•• Il corpo del ciclo determina il valore anno per anno Il corpo del ciclo determina il valore anno per anno come nel caso precedentecome nel caso precedente

•• La condizione di permanenza nel ciclo quindi sarà il La condizione di permanenza nel ciclo quindi sarà il mancato raggiungimento del raddoppio e il numero mancato raggiungimento del raddoppio e il numero di anni minore o uguale alla durata dell’investimentodi anni minore o uguale alla durata dell’investimento




La classe InvestimentoLa classe Investimentopublic class Investimentopublic class Investimento{{

. . .. . .public public intint anniPerRaddoppiareanniPerRaddoppiare()(){{doubledouble valore = capitale;valore = capitale;intint anno = 0;anno = 0;whilewhile (valore < 2*capitale && anno <= durata )(valore < 2*capitale && anno <= durata ){{

anno++;anno++;doubledouble interesse = valore * tasso/100;interesse = valore * tasso/100;valore = valore + interesse;valore = valore + interesse;

} } ifif (anno > durata) (anno > durata) return return ––1;1;

elseelsereturn anno;return anno;

} } }}

Cosa succede se non si mette questa istruzione ?


Terminazione ciclo Terminazione ciclo whilewhile

•• Il corpo del ciclo Il corpo del ciclo whilewhile viene iterato fino a viene iterato fino a quando la condizione di ingresso diviene falsa quando la condizione di ingresso diviene falsa (zero volte se è falsa in partenza)(zero volte se è falsa in partenza)

•• E' compito del programmatore garantire E' compito del programmatore garantire l’uscita dal ciclol’uscita dal ciclo

•• Tipico errore: scrivere “correttamente” il Tipico errore: scrivere “correttamente” il corpo del ciclo ma dimenticare l'azione corpo del ciclo ma dimenticare l'azione accessoria (p.e. incremento di una variabile) accessoria (p.e. incremento di una variabile) che porta all'uscitache porta all'uscita




RoadmapRoadmap




Ciclo Ciclo forfor


Ciclo Ciclo dodo--whilewhile



•• Il ciclo Il ciclo whilewhile antepone il controllo della antepone il controllo della condizione condizione booelanabooelana all’esecuzione del corpo all’esecuzione del corpo del ciclo: questo permette di avere anche del ciclo: questo permette di avere anche zero esecuzioni del corpo del ciclozero esecuzioni del corpo del ciclo

•• In alcuni casi però la condizione In alcuni casi però la condizione booleanabooleanadipende dall’esecuzione del corpo del ciclo dipende dall’esecuzione del corpo del ciclo stesso (almeno una volta): di conseguenza è stesso (almeno una volta): di conseguenza è più opportuno effettuare il controllo dopo più opportuno effettuare il controllo dopo l’iterazionel’iterazione





do do istruzione semplice o compostaistruzione semplice o composta

whilewhile (espressione (espressione booleanabooleana););


corpo del ciclo

true

false


Terminazione ciclo Terminazione ciclo dodo--whilewhile

•• Il corpo del ciclo Il corpo del ciclo dodo--whilewhile viene eseguito una viene eseguito una volta e quindi iterato fino a quando la volta e quindi iterato fino a quando la condizione di reingresso diviene falsacondizione di reingresso diviene falsa

•• E' compito del programmatore garantire che E' compito del programmatore garantire che questo avvenga (solito problema)questo avvenga (solito problema)

•• Il ciclo Il ciclo dodo--whilewhile è opportuno quando si deve è opportuno quando si deve eseguire almeno una volta un'azione prima che eseguire almeno una volta un'azione prima che abbia senso verificare se iterarlaabbia senso verificare se iterarla




Controllo inputControllo input

•• Un caso tipico di uso del ciclo Un caso tipico di uso del ciclo dodo--whilewhile è il è il controllo sull’input fornito dall’utentecontrollo sull’input fornito dall’utente

•• Prima l’utente fornisce un valore, poi si Prima l’utente fornisce un valore, poi si controlla se il valore è corretto: se non lo è lo controlla se il valore è corretto: se non lo è lo si “costringe” a ripetere l’input si “costringe” a ripetere l’input finchèfinchè non non inserisce il valore correttoinserisce il valore corretto

•• Possiamo modificare i metodi della classe Possiamo modificare i metodi della classe MyUtilMyUtil in questa direzionein questa direzione


Controllo inputControllo input

•• La classe Scanner ha dei metodi per La classe Scanner ha dei metodi per controllare se quello che è stato inserito ed è controllare se quello che è stato inserito ed è pronto da acquisire è convertibile in un certo pronto da acquisire è convertibile in un certo formato: formato: hasNextInthasNextInt(), (), hasNextDoublehasNextDouble(), etc.(), etc.

•• Se il formato è corretto possiamo acquisirlo e Se il formato è corretto possiamo acquisirlo e restituirlo altrimenti dobbiamo “ripulire” restituirlo altrimenti dobbiamo “ripulire” l’istanza di Scanner da quanto inserito e l’istanza di Scanner da quanto inserito e chiedere l’inserimento un’altra voltachiedere l’inserimento un’altra volta




Controllo input interoControllo input interoimport java.util.*;

public class MyUtil{private static Scanner lettore = new Scanner(System.in);private final static String ERRORE_FORMATO = "Attenzione: il dato inserito non e' nel formato corretto";

public static int leggiIntero (String messaggio){boolean finito = false;int valoreLetto = 0;do{System.out.print(messaggio);if (lettore.hasNextInt()){

valoreLetto = lettore.nextInt();finito = true;

}else{

System.out.println(ERRORE_FORMATO);String daButtare = lettore.next();

}} while (!finito);

return valoreLetto;}

}


Controllo input interoControllo input intero. . .

boolean finito = false;int valoreLetto = 0;do{System.out.print(messaggio);if (lettore.hasNextInt()){valoreLetto = lettore.nextInt();finito = true;

}else{System.out.println(ERRORE_FORMATO);String daButtare = lettore.next();

}} while (!finito);return valoreLetto;

Schema tipico del do-while:si inizializza una variabile a false

diventa true solonel caso desiderato

se true determinal’uscita




Controllo input interoControllo input intero. . .

boolean finito = false;int valoreLetto = 0;do{System.out.print(messaggio);if (lettore.hasNextInt()){valoreLetto = lettore.nextInt();finito = true;

}else{System.out.println(ERRORE_FORMATO);String daButtare = lettore.next();

}} while (!finito);return valoreLetto;

Si prepara una variabile per il risultato (il compilatore impone di inizializzarla)

viene assegnata solo nel caso corretto

Altrimenti si elimina l’inserimento errato e si riparte da capo


Riuso automaticoRiuso automatico

•• Si nota che le classi che facevano uso dei Si nota che le classi che facevano uso dei metodi di metodi di MyUtilMyUtil non devono essere non devono essere modificate modificate poiche’poiche’ il modo di invocare il modo di invocare MyUtilMyUtilnon è stato cambiatonon è stato cambiato

•• Le classi che facevano uso dei metodi di Le classi che facevano uso dei metodi di MyUtilMyUtil beneficiano “automaticamente” della beneficiano “automaticamente” della nuova versione più appropriatanuova versione più appropriata




Migliorare una classe senza doverne modificare altre è

segno di buona strutturazione del codice

Riuso automaticoRiuso automatico


Attenzione ai dettagliAttenzione ai dettagli

•• Se vogliamo ripulire l’intera riga inserita Se vogliamo ripulire l’intera riga inserita dall’utente anche qualora contenga spazi o dall’utente anche qualora contenga spazi o tabtab dobbiamo impostare opportunamente il dobbiamo impostare opportunamente il nostro oggetto Scannernostro oggetto Scanner

•• Per farlo possiamo creare un metodo apposito Per farlo possiamo creare un metodo apposito per la sua creazioneper la sua creazione





import java.util.*;

public class MyUtil{private static Scanner lettore = creaScanner();

. . .private static Scanner creaScanner (){Scanner creato = new Scanner(System.in);creato.useDelimiter(System.getProperty("line.separator"));return creato;}

}



•• La durata non può essere un numero La durata non può essere un numero negativo né nullonegativo né nullo

•• Se vogliamo effettuare questo controllo Se vogliamo effettuare questo controllo dobbiamo creare un nuovo metodo nella dobbiamo creare un nuovo metodo nella classe classe MyUtilMyUtil





import java.util.*;

public class MyUtil{private static Scanner lettore = creaScanner();private final static String ERRORE_FORMATO = "Attenzione: il dato inserito non e' nel formato corretto";

private final static String ERRORE_POSITIVO = "Attenzione: e' richiesto un valore maggiore di 0";

. . .

public static int leggiInteroPositivo (String messaggio){boolean finito = false;int valoreLetto = 0;do{valoreLetto = leggiIntero(messaggio);if (valoreLetto > 0)

finito = true;else

System.out.println(ERRORE_POSITIVO);} while (!finito);

return valoreLetto;}

}


RoadmapRoadmap




Ciclo Ciclo forfor



Cicli annidatiCicli annidati




Cicli annidati Cicli annidati ((nestednested, nidificati), nidificati)

•• Come nel caso del costrutto Come nel caso del costrutto ifif, capita spesso , capita spesso che il corpo del ciclo contenga un altro cicloche il corpo del ciclo contenga un altro ciclo

•• I cicli si possono innestare liberamente I cicli si possono innestare liberamente secondo le esigenze del problema da risolveresecondo le esigenze del problema da risolvere

•• Come al solito, può essere utile disegnare lo Come al solito, può essere utile disegnare lo schema a blocchi se la struttura è schema a blocchi se la struttura è particolarmente complessaparticolarmente complessa

•• Un caso tipico è il doppio ciclo per scandire Un caso tipico è il doppio ciclo per scandire strutture strutture tabellaritabellari//matricialimatriciali bidimensionalibidimensionali


Cicli annidati Cicli annidati ((nestednested, nidificati), nidificati)

•• Stampa tabella bidimensionaleStampa tabella bidimensionale

finite righe ?true

false

stampa elementotabella

finite colonne ?

false

true




Tabella delle potenzeTabella delle potenze

•• Supponiamo di volere una stampa della tabella delle Supponiamo di volere una stampa della tabella delle potenze di tutti i numeri minori o uguali di un certo potenze di tutti i numeri minori o uguali di un certo valore (base massima) e fino ad un certo valore valore (base massima) e fino ad un certo valore massimo di esponentemassimo di esponente

•• Per semplicità usiamo lo stile “usa e getta” e Per semplicità usiamo lo stile “usa e getta” e mettiamo tutto in una sola classe senza definire mettiamo tutto in una sola classe senza definire costanti costanti StringString e senza pensare all’allineamento della e senza pensare all’allineamento della tabellatabella

•• Ci porremo poi almeno il problema dell’allineamentoCi porremo poi almeno il problema dell’allineamento


Tabella delle potenzeTabella delle potenzepublic class public class TabellaPotenzeTabellaPotenze{{public public staticstatic voidvoid mainmain ((StringString [] [] argsargs)){{System.out.printlnSystem.out.println("Programma per la stampa di una tabella di("Programma per la stampa di una tabella di

potenze");potenze");intint maxBasemaxBase = = MyUtil.leggiInteroPositivoMyUtil.leggiInteroPositivo("Inserire il valore ("Inserire il valore

massimo per la base:");massimo per la base:");intint maxExpmaxExp = = MyUtilMyUtil. . leggiInteroPositivoleggiInteroPositivo("Inserire il valore ("Inserire il valore

massimo per l’esponente:");massimo per l’esponente:");

forfor ((intint x = 1; x <= x = 1; x <= maxBasemaxBase; x++); x++){{forfor ((intint y = 1; y <= y = 1; y <= maxExpmaxExp; y++); y++){ { intint potenza = (potenza = (intint))Math.powMath.pow(x, y);(x, y);System.out.printSystem.out.print(potenza + " ");(potenza + " ");}}

System.out.printlnSystem.out.println();();} // } // forfor

} // } // mainmain} // class} // class




AllineamentoAllineamento

•• Per ogni colonna y possiamo valutare il Per ogni colonna y possiamo valutare il numero di caratteri massimo richiesto: è la numero di caratteri massimo richiesto: è la lunghezza di lunghezza di maxBasemaxBase elevato alla y + 1(per elevato alla y + 1(per avere almeno uno spazio)avere almeno uno spazio)

•• Questo numero può essere usato per regolare Questo numero può essere usato per regolare la stampa con la stampa con printfprintf


AllineamentoAllineamento

. . .. . .forfor ((intint x = 1; x <= x = 1; x <= maxBasemaxBase; x++); x++){{forfor ((intint y = 1; y <= y = 1; y <= maxExpmaxExp; y++); y++){{intint maxColonnamaxColonna = (= (intint) ) Math.powMath.pow((maxBasemaxBase, y); , y); StringString piuLungapiuLunga = = String.valueOfString.valueOf((maxColonnamaxColonna););intint larghezzaColonnalarghezzaColonna = 1 + = 1 + piuLunga.lengthpiuLunga.length();();StringString format = "%"+larghezzaColonna+"d";format = "%"+larghezzaColonna+"d";int potenza = (int potenza = (intint))Math.powMath.pow(x, y);(x, y);System.out.printfSystem.out.printf(format,potenza);(format,potenza);

}}System.out.printlnSystem.out.println();();} }

. . .. . .




Allineamento: forma Allineamento: forma sintetica (e poco leggibile)sintetica (e poco leggibile)

•• Il corpo del ciclo Il corpo del ciclo forfor più interno può essere più interno può essere ridotto a due righe ma questo stile è ridotto a due righe ma questo stile è fortemente sconsigliabilefortemente sconsigliabile

. . .. . .intint larghezzaColonnalarghezzaColonna = 1+(= 1+(String.valueOfString.valueOf((((intint))Math.powMath.pow((maxBasemaxBase,y))),y))).length.length();();

System.out.printfSystem.out.printf("%"+larghezzaColonna+"d", (("%"+larghezzaColonna+"d", (intint))Math.powMath.pow(x, y));(x, y));

. . .. . .

•• I buontemponi possono ridurlo anche a una I buontemponi possono ridurlo anche a una riga solariga sola

System.out.printfSystem.out.printf("%"+(1+(("%"+(1+(String.valueOfString.valueOf((((intint))Math.powMath.pow((maxBasemaxBase,y))),y))).length.length()) ()) +"d", (+"d", (intint))Math.powMath.pow(x, y));(x, y));


RoadmapRoadmap




Ciclo Ciclo forfor



Cicli annidatiCicli annidati

Break e continueBreak e continue





•• L'istruzione L'istruzione breakbreak permette di uscire dal ciclo permette di uscire dal ciclo correntecorrente

•• L'istruzione L'istruzione continuecontinue permette di saltare alla permette di saltare alla prossima iterazione del ciclo correnteprossima iterazione del ciclo corrente

•• Esiste una variante "etichettata" di Esiste una variante "etichettata" di breakbreak e e continuecontinue utile per cicli annidati: si esce (o si utile per cicli annidati: si esce (o si salta) da tutti i cicli fino a quello preceduto salta) da tutti i cicli fino a quello preceduto dall'etichettadall'etichetta



•• Break e continue sono una versione "educata" Break e continue sono una versione "educata" della famigerata istruzione gotodella famigerata istruzione goto

•• Quasi tutti gli autori di testi di programmazione Quasi tutti gli autori di testi di programmazione considerano goto un brutto ricordo da considerano goto un brutto ricordo da cancellare (spaghetti code)cancellare (spaghetti code)

•• Si Si puo'puo' programmare in modo elegante ed programmare in modo elegante ed efficace anche senza break e continueefficace anche senza break e continue

Roadmap -...

Documents

Transcript of Roadmap -...