Post
Cicli while
§ L’enunciato while esegue ripetutamente un blocco di
codice.
§ Una condizione di terminazione controlla quante volte
viene
eseguito il ciclo.
while (condizione)
enunciato;
§ Il più delle volte l’enunciato è un blocco di enunciati,
vale
a dire una serie di enunciati racchiusa fra parentesi graffe
{...}.
Calcolare la crescita di un investimento
§ Saldo iniziale $10,000, tasso di interesse annuo 5%
Anno Saldo
0 $10,000.00
1 $10,500.00
2 $11,025.00
3 $11,576.25
4 $12,155.06
5 $12,762.82
Calcolare la crescita di un investimento
§ Quando il conto raggiunge un particolare saldo?
while (balance <
targetBalance)
{
years++;
double interest = balance *
rate / 100;
balance = balance + interest;
}
File Investment.java
01: /**
02: Una classe per controllare la crescita di un investimento
03: che accumula interessi a un tasso annuale fisso.
04: */
05: public class Investment
06: {
07: /**
08: Costruisce un oggetto Investment con un saldo iniziale
09: e un tasso di interesse.
10: @param aBalance il saldo iniziale
11: @param aRate il tasso di interesse percentuale
12: */
13: public Investment(double
aBalance, double aRate)
14: {
15: balance =
aBalance;
16: rate = aRate;
17: years = 0;
18: }
19
20: /**
21: Continua ad accumulare interessi finché il saldo
22: non raggiunge un valore desiderato.
23: @param
targetBalance the desired balance
24: */
25: public void waitForBalance(double
targetBalance)
26: {
27: while (balance
< targetBalance)
28: {
29: years++;
30: double interest =
balance * rate / 100;
31: balance = balance + interest;
32: }
33: }
34:
35: /**
36: Restituisce il saldo attuale dell’investimento.
37: @return il saldo attuale
38: *
39: public double getBalance()
40: {
41: return balance;
42: }
43:
44: /**
45: Restituisce il numero di anni per i quali
46:
l'investimento ha accumulato interessi.
47: @return il numero di anni trascorsi dall'inizio
dell’investimento
48: */
49: public int getYears()
50: {
51: return years;
52: }
53:
54: private double balance;
55: private double rate;
56: private int years;
57: }
File InvestmentRunner.java
01: /**
02: Questo programma calcola quanto tempo occorre per il
03: raddoppio di un investimento.
04: */
05: public class InvestmentRunner
06: {
07: public static void
main(String[] args)
08: {
09: final double INITIAL_BALANCE
= 10000;
10: final double RATE
= 5;
11: Investment invest
= new Investment(INITIAL_BALANCE,
RATE);
12: invest.waitForBalance(2
* INITIAL_BALANCE);
13: int years =
invest.getYears();
14: System.out.println("The
investment doubled after "
15: + years + " years");
16: }
17: }
Visualizza
The
investment doubled after 15 years
Cicli while
Diagramma
di flusso
di un
ciclo while
Sintassi 6.1: L'enunciato while
while
(condizione)
enunciato
Esempio:
while
(balance < targetBalance)
{
years++;
double interest = balance * rate / 100;
balance
= balance + interest;
}
Obiettivo:
Eseguire
un enunciato finché una condizione è vera.
Errori comuni: cicli infiniti
§ int years = 0;
while (years < 20)
{
double interest = balance * rate / 100;
balance = balance + interest;
// manca years++
}
§ Un ciclo che viene eseguito ininterrottamente e che si può fermare
solo
annullando l’esecuzione del programma o riavviando il
computer.
int years = 20;
while (years > 0)
{
years++;
// Avrebbe dovuto essere years--
double interest = balance * rate / 100;
balance = balance + interest;
}
Errori comuni: errori per scarto di uno
int years = 0;
while (balance < 2 * initialBalance)
{
years++;
double interest = balance * rate / 100;
balance = balance + interest;
}
System.out.println("The investment
reached the target after "
+
years + " years.");
§ Il conteggio della variabile years
inizia da 0 o da 1?
§ Nella condizione bisogna inserire l'operatore di confronto < oppure <=?
Errori comuni: errori per scarto di uno
§ Ipotizzate uno scenario con valori semplici:
un saldo iniziale di $ 100
tasso di interesse: 50%
Dopo un anno, il saldo sarà di $ 150
dopo due anni, di $ 225, e comunque oltre $ 200
L’investimento raddoppia dopo due anni.
se il ciclo si esegue due volte, e se ciascuna volta si incrementa
years, significa che years deve
partire da zero, non da uno.
§ Tasso di interesse: 100%
dopo un anno: investimento raddoppiato
il ciclo viene eseguito una volta sola
Occorre utilizzare l'operatore <
Cicli do
§ Eseguire un ciclo almeno una volta:
do
enunciato
while
(condizione);
§ Esempio: verificare l'input
double value;
do
{
System.out.print("Please enter a
positive number: ");
value
= in.nextDouble();
}
while
(value <= 0);
Cicli do
§ Alternativa, utilizzare una variabile di controllo
booleana:
boolean done = false;
while (!done)
{
System.out.print("Please enter a
positive number: ");
value = in.nextDouble();
if (value > 0) done = true;
}
Cicli do
Diagramma
di flusso
di un
ciclo do
Ciclo for
§
Esempio:
for
(inizializzazione; condizione; aggiornamento)
enunciato
for
(int i = 1; i <= n; i++)
{
double interest = balance * rate / 100;
balance = balance + interest;
}
Ciclo for
§ Si usa un ciclo for quando una variabile viene modificata
da un valore
iniziale a un valore finale con un incremento o decremento
costante.
§ Equivale a
inizializzazione;
while
(condizione)
{
enunciato; aggiornamento; }
§ Altri esempi:
for (years = n; years > 0; years--)
. . .
for (x = -10; x <= 10; x = x + 0.5)
. . .
Diagramma
di flusso
per un
ciclo for
Sintassi 6.2: L'enunciato for
for (inizializzazione; condizione; aggiornamento)
enunciato
Esempio:
for (int i = 1; i <= n; i++)
{
double
interest = balance * rate / 100;
balance =
balance + interest;
}
Obiettivo:
Eseguire una inizializzazione, quindi ripetere l'esecuzione di un
enunciato
e aggiornare un'espressione, finché una condizione è vera.
File Investment.java
01: /**
02: Una classe per controllare la crescita di un investimento
03: che accumula interessi a un tasso annuale fisso.
04: */
05: public class Investment
06: {
07: /**
08: Costruisce un oggetto Investment con un saldo iniziale
09: e un tasso di interesse.
10: @param aBalance il saldo iniziale
11: @param aRate il tasso d’interesse percentuale
12: */
13: public Investment(double
aBalance, double aRate)
14: {
15: balance =
aBalance;
16: rate = aRate;
17: years = 0;
18: }
19:
20: /**
21: Continua ad accumulare interessi finché il saldo
22: non raggiunge un valore desiderato.
23: @param targetBalance il saldo desiderato
24: */
25: public void waitForBalance(double
targetBalance)
26: {
27: while (balance
< targetBalance)
28: {
29: years++;
30: double interest =
balance * rate / 100;
31: balance = balance + interest;
32: }
33: }
34:
35: /**
36: Continua ad accumulare interessi per un dato numero di anni.
37: @param n il numero di anni
38: */
39: public void waitYears(int
n)
40: {
41: for (int i = 1; i
<= n; i++)
42: {
43: double interest =
balance * rate / 100;
44: balance = balance
+ interest;
45: }
46: years = years + n;
47: }
48:
49: /**
50: Restituisce il saldo attuale dell’investimento.
51: @return il saldo attuale
52: */
53: public double getBalance()
54: {
55: return balance;
56: }
57:
58: /**
59: Restituisce il numero di anni per i quali l’investimento
60: ha accumulato interessi.
61: @return il numero di anni dall’inizio dell’investimento
62: */
63: public int getYears()
64: {
65: return years;
66: }
67:
68: private double balance;
69: private double rate;
70: private int years;
71: }
File InvestmentRunner.java
01: /**
02: Questo programma calcola di quanto aumenta un investimento
03: in un dato numero di anni.
04: */
05: public class InvestmentTester
06: {
07: public static void
main(String[] args)
08: {
09: final double INITIAL_BALANCE
= 10000;
10: final double RATE
= 5;
11: final int YEARS = 20;
12: Investment invest
= new Investment(INITIAL_BALANCE, RATE);
13: invest.waitYears(YEARS);
14: double balance =
invest.getBalance();
15: System.out.printf("The
balance after %d years is %.2f\n",
16: YEARS, balance);
17: }
18: }
Visualizza
The balance after 20 years is 26532.98
Nessun commento:
Posta un commento