Istruzione IF (nel caso che)

L'istruzione IF esegue i codici all'interno delle parentesi graffe {…} solo se la condizione specificata è vera
Se la condizione è falsa passa oltre - non esegue alcun codice all'interno delle parentesi {…}

ESEMPIO

public class TryClass {
public static void main (String [ ] args){
int a=200;
int b=100;
if (a>b) // se true -vero - avvia il prossimo comando
{ System.out.print ( "a è maggiore di b.");
}}}

(Output: a is greater than b.)

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |a=200|; // assegna un valore alla variabile
int |b=100|; // assegna un valore all'altra variabile
if (|a|>|b|) // se la condizione è vera, passa al prossimo comando
{ System.out.print ( |"a è maggiore di b."|);
}}}

Queste istruzioni apparentemente non hanno senso, ma servono per imparare la sintassi.

 

 

2

 

 

 

 

Istruzione If-else

Mettiamo che (a>b) sia un'espressione di prova, per esempio (100>200), se restituisce 'true', le imporremo di restituire "a è maggiore di b". se restituisce 'false', le imporremo di restituire "a è minore di b".

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int a=100; int b=200;
if (a>b) // if true do this
{ System.out.print ( "a is greater than b.");}
else // if false do this
{System.out.print ( "a is less than b");}
}}

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |a=100|; // assegna un valore alla variabile
int |b=200|; // assegna un valore alla variabile
if (|a|>|b|) // se la condizione è vera, passa al prossimo comando
{ System.out.print ( |"a è maggiore di b."|);}
else // se la condizione è falsa
{ System.out.print ( |"a è minore di b."|);}
}}

Ovviamente poiché abbiamo impostato a=100 e b=200 il valore di a è minore del valore di b, quindi il sistema darà che "a è minore di b."

 

---

3

 

 

 

Istruzione Switch

Equivale al DO CASE .CASO1... CASO 2 ... cASO N ... ENDCASE di altri linguaggi di prgrammazione. Ovvero dato un certo valore di una variabile il sistema lo confronterà con un elenco di valori. Se nell'elenco dei casi si trova un valore uguale a quello della variabile, se eseguirà quel codice corrispondente a quel caso. L'istruzione break "rompere;" termina l'esecuzione del codice. Altrimenti si passa oltre.

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int number=20;
switch ( number ) { // “number” value compares each case
case 10 : System.out.print ("Running case 10"); break;
case 20 : System.out.print ("Running case 20"); break;
case 30 : System.out.print ("Running case 30"); break;
default : System.out.print ("Running default code"); break;
}}}

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |nome di variabile 'numero'|=|20|;
switch (|numero|)// “numero” viene paragonato con i casi seguenti
{
case |10|: System.out.print (|"trovato il caso 10|"); break;
case |20|: System.out.print (|"trovato il caso 20"|); break;
case |30|: System.out.print (|"trovato il caso 30|"); break;
default : System.out.print (|"AVVIO DEL CODICE DI DWFAULT|"); break; }
}}

Spiegazione: assegnato un valore a una variabile ('numero' in questo caso) si esaminano vari casi di corrispondenza con numeri diversi, uno dei quali abbiamo posto uguale al valore della variabile 'numero'. Qui il sitema stamperà che ha trovato il caso '20'.

La cosa può sembrare scema, ma cambia aspetto se teniamo presente che i valori dei casi possono essere passati al programma mediante variabili riempite da altri programmi, e che se viene incontrato un determinato caso, si può lanciare un altro programma relativo ad esso.

---

4

 

 

 

 

Istruzione FOR (Loop: ciclo ripetuto x volte)

Un ciclo di istruzioni viene eseguito per un numero assegnato di volte. Il ciclo viene chiamato 'LOOP'

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int x;
for (x = 0; x <= 5; x++) { // repeat at most 5 times
System.out.print( x );
}}}

ogni volta che aggiunge 1 a x (x++) e stampa il numero
(l'Output: 0 1 2 3 4 5 )

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |X|;
for (|X|= |0|; |X| <= |5|; |X|++) // LOOPPA 5 VOLTE
{ System.out.print(|X|);}
}}

 

Il nome alle variabili scritte tra |....| cioè |X|, |nome della classe|, |nome del programma|, può essere assegnato a piacere

 

---

5

Istruzione LOOP WHILE

"Counter (contatore) < x" è l'espressione di controllo del loop. In questo caso si è posto x= 8. Finché la condizione è vera, il codice dentro il loop verrà ripetuto 8 volte (il valore iniziale x=0), finché il contatore non sarà 8. Quando x sarà 8 il codice smetterà di funzionare

ESEMPIO

public class TryClass{
public static void main (String [ ] args)
{ int counter=0; while (counter < 8) // loop 8 volte
{ System.out.print ("&"); counter++;}
}}

( Output: &&&&&&&& )

 

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args)
{ int |variabile contatore|=|valore min|;
while (|variabile contatore| < |valore max 8|) // loop 8 volte
{ System.out.print |carattere "&"|); |variabile contatore|++;}
}}

Se si pone :
|nome della classe| TryClass
|main, nome del programma| main

|variabile contatore| = Counter
|valore min| = 0
|valore max| = 8
|carattere| = "&"

l'Output sarà: &&&&&&&& (cioè 8 caratteri "&")

---

 

6

Loop Do-While

"Do | blocco di codice| while | condizione |" esegue il blocco di codice una volta, e se la condizione specificata è vera ripete il ciclo.

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int counter=0;
do {
System.out.print ( "@"); counter++; // blocco di codice
   }
while (counter<8); // condizione specificata: looppa 8 volte
}}

( Output: @@@@@@@@ )

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma| (String [ ] args){
int |variabile contatore|=|valore min|;
do {
System.out.print ( |carattere "@"|); |variabile contatore|++;
}
while (|variabile contatore|<|valore max|); // loop 8 volte
}}

 

Se si pone :
|nome della classe| TryClass
|main, nome del programma| main

|variabile contatore| = counter
|valore min| = 0
|valore max| = 8
|carattere| = "@"

l'Output sarà: @@@@@@@@ (cioè 8 caratteri @)

---

 

 

 

 

 

 

Istruzione Break

La parola chiave "break" viene utilizzata per interrompere l'esecuzione di un ciclo in base alla condizione verificata.

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int num=0;
while (num<10){
if (num==5) break; // esce dal loop while
num++;
}
System.out.print( num );
}}

( Output: 5)

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |variabile NUM|=|valore min|;
while (|variabile NUM|<|valore max|){
if (|variabile NUM|==|valore intermedio|) break; // esce dal loop while
|valore num|++;
}
System.out.print( |valore num| );
}}

Se si pone :
|nome della classe| TryClass
|main, nome del programma| main

|variabile contatore| = Num
|valore min| = 0
|valore di break| = 5
|valore max| = 10

l'Output sarà: |valore num al break| = 5

---

 

 

 

 

 

 

Istruzione 'Continue'

La parola chiave "continue" si usa per interrompere l'iterazione corrente, ignorando le istruzioni che la seguono, quindi per cominciare di nuovo il ciclo daccapo, saltando quell'iterazione.

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int num=0;
while (num<10){
num++;
if (num==5) continue; // condizione specificata salta questo valore
System.out.print( num );
}}}

( Output: 1234678910)

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma|(String [ ] args){
int |variabile contatore|=|valore min|;// condizione iniziale
while (|variabile contatore|<|valore max|)
{
|variabile contatore|++; // incrementa di 1 la variabile
if (|variabile contatore|==|valore medio|)// valore da omettere
continue; // se condizione raggiunta: riprende il loop daccapo
System.out.print(|variabile contatore|);
}
}}

Se si pone :
|nome della classe| TryClass
|main, nome del programma| main

|variabile contatore| = Num
|valore min| = 0
|valore da saltare| = 5
|valore max| = 10

l'Output sarà: 1 2 3 4 6 7 8 9 10

il |valore da saltare| = 5 non è stato stampato

---

 

 

 

 

Espressione condizionale Booleana

Questo programmino dimostra che il sistema dichiara ERRORE se l'espressione condizionale non è una espressione logica, o una variabile logica che sia True o False o una eguaglianza che può essere vera o falsa.

ESEMPIO

public class TryClass{
public static void main (String [ ] args){
int num=10;
if( num ){ // errore! num non è variabile booleana
System.out.print ("No good");
}
while ( num ){ // errore! num non è variabile booleana
System.out.print ("No good");
}}}

SINTASSI

public class |nome della classe|{
public static void |main, nome del programma| (String [ ] args){
int |variabile NUMERICA|= |valore |;
if( |variabile NUMERICA| )// errore! non è variabile booleana
{System.out.print ( |"Errore!"|);}
while (|variabile NUMERICA| ) // errore! non è variabile booleana
{System.out.print ( |"Errore"|);}
}}

ove si è posto

|nome della classe| TryClass
|main, nome del programma| main

|variabile NUMERICA| = Num

---

 

 

 

 

Pratica di progetto: esegui 100 volte

Un programma con l'istruzione While -

Avviamo il progetto WhileStatement

Start up Eclipse > Select “myPackage” > new > class > name > WhileStatement >
Finish.

Ecco il codice del progetto WhileStatement scritto con Eclipse

package myPackage;
public class WhileStatement {
public static void main(String[ ] args) {
int n = 1;
int sum = 0;
while(n <= 100) // run 100 times
{ sum += n; // sum = sum + n
n++; }
System.out.println("Sum = " + sum);
}
}

SINTASSI

package |nome del PACKAGE|;
public class |nome della classe| {
public static void main(String[ ] args) {
int |variabile numerica n| = |valore iniziale è 1|;
int |variabile numerica per la somma| = |valore iniziale è 0|;
while(|variabile numerica n|<=|valore massimo QUI =100|)//GIRA 100 VOLTE
{|variabile numerica per la somma|+= |variabile numerica n|;
//+= significa variabile somma (sum) = sum + n
|variabile numerica n|++;} //+= significa variabile n = n + 1
System.out.println(|"simbolo della variabile somma ="| + |variabile numerica per la somma|);
}
}

Dove si è posto
|nome del PACKAGE|   myPackage
|nome della classe|  WhileStatement
|variabile numerica n| = 1 (valore iniziale)
|variabile numerica per la somma =sum | =0 (come valore iniziale)
|variabile numerica n valore Massimo| = 100

 

il programma somma n = n+1 nella variabile sum per 100 volte. Il risultato è una progressione. Gira finché n =100
Si tratta di una particolare progressione che fornisce sum =5050

Come al solito si clicca il triangolo bianco sul bottone nverde nella toolbar per avviare il programma.