Benvenuti a tutti in questo nuovo articolo, dove voglio finire la parte del corso base di Java. Questo articolo premetto che non sarà cortissimo, ma anzi molto lungo. Chi lo vuole leggere tutto per terminare il mio corso base di Java, ma non ha tempo, può leggerlo e seguirlo a parti. Questo articolo l’ho suddiviso in varie parte con dei sottotitoli, in modo che i vari argomenti siano ben divisi ed è possibile distinguerli facilmente. Per tutto ciò che vi potrà sembrare poco chiaro, vi invito a commentare o ad inviarmi una richiesta privata nell’area assistenza del blog.
Ti consiglio, come ho sempre fatto negli articoli precedenti riguardanti questo corso, di guardarti tutti gli articoli precedenti, nel caso non l’abbia fatto, in modo che riuscirai a capire al meglio ogni cosa.
Molto bene, fatto questa piccola premessa, direi che è possibile iniziare.
Nello scorso articolo sulle basi del Java, stavamo vedendo la terza parte riguardante la forma condizionale e più nello specifico, stavamo analizzando lo Switch, una forma di condizione che è uguale all’if e else, ma è più veloce. Certo ha qualche piccola limitazione (ad esempio non supporta le condizioni decimali), ma comunque è veramente molto utile per scrivere e gestire un grandissimo numero di condizioni in tempi piuttosto rapidi e veloci…. insomma senza enormi problemi. Avevamo visto che gestire un vasto numero di condizioni con l’if e l’else è praticamente un cancro. Meglio evitare.
Meglio evitare anche perché un programma è fatto bene ed è ben ottimizzato soltanto se è scritto nel minor numero possibile di righe di codice e il programma sia veloce e realmente molto efficiente. E’ importante quindi usare strutture come lo Switch per ottenere tutto ciò.
Con lo switch abbiamo finito la seconda forma principale della programmazione. Fino ad ora abbiamo visto la prima forma, la struttura sequenziale, abbiamo visto la seconda struttura, ovvero la condizionale. Ora per finire il corso base, non ci resta che vedere la terza struttura fondamentale, ovvero l’iterativa.
Forma Iterativa
La struttura iterativa ha un concetto che può sembrare molto complicato da capire, ma in realtà è piuttosto semplice.
La struttura iterativa deriva dal termine iterare, ripetere. Grazie a questa struttura si è in grado di ripetere una serie di istruzioni fino ad ottenere il risultato desiderato.
Come esempio possiamo crearci un problema. Abbiamo un ristorante e abbiamo 100 ordinazioni differenti. Dobbiamo fare alla fine un conto finale di quanti soldi abbiamo guadagnato. E’ possibile fare 2 cose. La prima è quella di continuare a creare delle println con la somma delle variabili e quindi dei vari prezzi fino a sommare il tutto. Cosa alquanto da evitare in quanto è fastidiosa e soprattutto molto lenta, senza contare il fatto che la probabilità di creare errori è veramente molto alta.
Con la forma iterativa è possibile fare tutto ciò in sole 3 righe di codice…. direi molto buono no? Durante l’articolo vi posterò il codice per realizzare questo programma.
La forma iterativa si appoggia alla forma sequenziale e alla forma condizionale. Alla forma condizionale è ovvio, perché come abbiamo visto in precedenza, un algoritmo non può essere un’insieme illogico di istruzioni, ma un’insieme logico e che siano in ordine a tal modo da risolvere un problema, non crearne un’altro perché non mettiamo logica nella realizzazione di un programma. Abbiamo visto che il compilatore Java e anche la JVM leggono in sequenza un’istruzione dopo l’altra e se queste istruzioni dovessero essere in un qualche modo scorrette di ordine, il programma o parti del programma non funzionerebbero o funzionerebbero, ma non correttamente.
Nella forma condizionale c’è anche la parte della condizionale. Questo perché come dicevamo prima questo sistema è in grado di ripetere delle istruzione fino al raggiungimento di un determinato risultato. Ma come facciamo ad impostare questo risultato? Beh con la forma condizionale. In poche parole scriviamo nel programma di ripetere le istruzioni, finché un determinato valore non arriva al risultato voluto.
Quindi struttura sequenziale per far funzionare il programma e struttura condizionale per far funzionare e per controllare il funzionamento dell’iterazione.
Esistono diverse strutture in grado di ripetere delle operazioni. Queste strutture si chiamano cicli. In questo corso andremo a vedere 2 cicli. Il ciclo for e il ciclo while.
Ciclo For
Bene. Per primo andiamo a vedere il ciclo For. Vediamo la sua sintassi.
[java]
for(inizializzazione; condizione; iterazione){
}
[/java]
Come possiamo ben notare innanzi tutto è necessario inserire la keyword for prima delle parentesi tonda per inizializzare il ciclo, per dire al compilatore Java e alla JVM di comportarsi in un certo modo, perché si ha davanti un ciclo.
Una volta scritto la keyword for e aperto le parentesi, l’area di controllo del ciclo (che è all’interno delle parentesi tonde) è suddivisa in tre parti.
L’inizializzazione, che serve per inizializzare una variabile nel ciclo. Ad esempio è possibile creare una nuova variabile e dargli un valore di partenza. Oppure è possibile usare una variabile già esistente. Ad es:
[java]
public static void main (String[] args)
{
int a = 20;
for(a = 0; ….. ; ……)
{
}
}
[/java]
oppure
[java]
public static void main(String[] args){
for(int a = 0; ……. ; ………….)
{
}
}
[/java]
Com’è possibile notare nel secondo esempio, nella parte di inizializzazione del ciclo, è possibile anche creare delle nuove variabili (ovviamente va anche specificato il tipo di variabile, ad esempio se è int, float, double ecc…
Ovviamente com’è possibile vedere nel primo esempio, è possibile usare per la parte di inizializzazione di questo ciclo una variabile già bella che esistente. Insomma… è possibile fare come si è più comodi, il ciclo è molto dinamico sotto l’aspetto della personalizzazione di certi parametri.
Il ciclo for è suddiviso in 3 parti e tra una parte e un’altra c’è un bel punto e virgola (;). Quindi ora siccome ho scritto la prima parte del ciclo, inseriamo il punto e virgola per riuscire a concludere la prima parte e iniziare la seconda, ovvero la parte della condizione, in cui è possibile impostare una condizione (un limite) al nostro ciclo, ad esempio deve continuare a essere in funzione finché il valore della variabile impostata nella parte dell’inizializzazione, non raggiunga il valore 100. E’ importante che nella condizione del ciclo venga usata la variabile o il valore dato nella parte dell’inizializzazione, se no il ciclo non avrebbe più senso.
Vediamo cosa intendo dire con tutto questo con un semplice esempio:
[java]
public static void main(String[] args){
int a = 0;
for (a = 0; a <= 100; iterazione){
}
}
[/java]
Bene, ora vediamo l’ultima parte. L’iterazione. Questa parte è molto semplice. Si usano solitamente gli operatori unari. Quindi ad esempio:
[java]
for (int a = 0; a <= 100; a++){
}
[/java]
Con quest’ultima parte, abbiamo detto di aggiungere ad ogni ripetizione 1 al valore contenuto nella variabile contatore a. Si chiama variabile contatore perché tiene il conto del valore e il ciclo continua a ripetersi finché il valore della variabile contatore non raggiunge il risultato stabilito nella parte della condizione.
Durante l’esecuzione del ciclo si ripeteranno le istruzioni contenute all’interno del blocco di istruzioni del ciclo for. Per intenderci, le istruzioni contenute nelle parentesi graffe {}.
Ok ora con queste nozioni alla mano, è possibile vedere di risolvere il problema precedente, quello delle ordinazioni. Scriverò il codice qui sotto.
[java]
import java.util.Scanner;
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int prezzo-ordinazione, contototale;
prezzo_ordinazione = 0;
contototale = 0;
for(int i = 0; i <= 100; i++){
System.out.println("Inserisci il prezzo dell’ordinazione");
prezzo_ordinazione = sc.nextInt();
contototale += prezzo_ordinazione;
}
System.out.println("Il prezzo totale delle ordinazioni e’ -> " + contototale);
}
[/java]
Ecco qui, il programma è scritto. Non c’è praticamente nulla da spiegare dato che le istruzioni usate all’interno del ciclo for le conoscerete bene, dopo i tutorial precedenti.
Vi spiego una sola cosa sulla variabile contatore. Ho scelto di usare una variabile che si chiama i perché in tutti i cicli for la lettera “i” è il nome standard globale per la variabile contatore. Quindi non a caso ho usato la lettera i. Ti consiglio di abituarti ad usare sempre questa lettera per non sbagliarti in futuro.
Ok direi che con questo il ciclo for l’abbiamo visto. Ma prima di partire con il ciclo while, vediamo un’ultima cosa sul ciclo for. Abbiamo detto che questo ciclo è composto da 3 parti, inizializzazione, condizione e iterazione. Ok. Non si è obbligati a mettere tutte queste 3 cose. Volendo è possibile non inserire l’inizializzazione, la condizione o l’iterazione o più di 1. Questa procedura potrebbe servire in certi ambiti più complessi, anche se ormai non viene più usata. Però per correttezza l’ho detto comunque.
Bene, ora possiamo passare al ciclo While.
Il Ciclo While
Il ciclo While, come il ciclo for, serve per ripetere delle operazioni fino ad ottenere un determinato risultato. Ma questo ciclo somiglia molto alla struttura dell’if, senza else.
Il ciclo funziona così. Si inserisce una condizione. All’avvio del ciclo, se la condizione non è verificata (ovvero che il valore stabilito nella condizione non è ancora presente nella variabile) il ciclo entra in azione. Se la condizione è verificata (ovvero che il valore della condizione è uguale a quello della variabile) il ciclo non entra in azione.
Ad esempio:
[java]
int variabile = 5;
while (variabile <= 5){
}
[/java]
In questo caso il ciclo non entrerà mai in azione in quanto la condizione è verificata.
[java]
int variabile = 5;
while (variabile >= 10){
}
[/java]
In questo caso dato che la condizione non è verificata il ciclo funzionerà fino a raggiungere il valore della condizione.
Vediamo ora la sintassi del ciclo.
while è la keyword del ciclo while.
() contengono la condizione del ciclo
All’interno delle parentesi tonde c’è la condizione del ciclo, che ha la stessa sintassi della condizione della struttura dell’if.
Poi il blocco di istruzioni del ciclo while è delimitato dalle 2 parentesi graffe {}.
Se qualcuno avrà visto il ciclo while gli sarà sopraggiunta una domanda: e dov’è il controllo dell’iterazione per incrementare il valore della variabile?
Il controllo di iterazione si mette all’interno del blocco di istruzioni. Solitamente utilizzando (come nel caso del ciclo for) gli operatori unari.
Quindi come esempio
[java]
int variabile = 5;
while (variabile >= 10){
// ……. prima le istruzioni e poi il controllo di iterazione.
variabile++;
}
[/java]
Ok. Nel ciclo While è possibile aggiungere più di una condizione, proprio come si faceva con la forma condizionale. I caratteri e la sintassi per aggiungere più condizioni sono i medesimi.
Bene, direi che il ciclo While l’abbiamo visto. Più avanti (non in questo articolo, ma nella parte più avanzata del corso) vedremo il ciclo do while.
Bene ora possiamo andare a vedere un nuovo tipo di variabili.
Fino a questo momento noi abbiamo usato le cosiddette variabili primitive, variabili che sono in grado di memorizzare un solo valore, numerico o letterale che sia. Con queste variabili, se abbiamo bisogno di conservare tanti valori, dobbiamo fare così:
int v1 = 1;
int v2 = 2;
ecc…
Si può già ben capire che questo procedimento è molto lungo, fa sprecare del tempo al programmatore, si scrivono troppe linee di codice (quindi il software non è ben ottimizzato e non è molto comprensibile il codice sorgente.
Esiste però in aiuto un tipo di variabile chiamata array. Però esistono tantissimi tipi di array. Noi andremo a vedere quelli più comuni….. i vettori.
I Vettori
I vettori sono variabili in grado di contenere molti valori. Tutti quelli che noi vogliamo. Ma come funzionano? Come fanno?
Vediamo di capirlo.
Fino ad ora, come dicevamo anche prima, abbiamo visto le variabili primitive. Le variabili primitive non sono altro (detto in modo molto semplificato) uno spazio della memoria ram allocato (occupato, riservato) per contenere un determinato valore. La dimensione di questo spazio dipende dal tipo di variabile. Nella lezione 3 del corso base di Java, quando avevo affrontato le variabili, avevo scritto anche le varie grandezze, per essere più preciso e per permettervi di imparare le variabili nel modo più completo possibile.
Il funzionamento dei vettori è molto simile. Praticamente non fa altro che moltiplicare il numero di celle per aumentare il numero di valori in cui è possibile immettere. Qual’è il numero massimo di celle disponibili? Nessuno, dato che il numero di celle del vettore da creare le decidiamo al momento in cui creiamo il vettore.
Ad ogni cella corrisponde un valore. Così non c’è più bisogno di scrivere 1500 variabili per conservare una serie di valori, ma ne basta una sola.
Le celle di un vettore sono numerate. La numerazione parte da 0. Quindi se noi con il vettore creassimo 20 celle, la numerazione andrebbe da 0 a 19. La numerazione è molto importante per gestire le celle di un vettore, per leggere i suoi valori ecc…. Questo perché un vettore si deve gestire per forza con il ciclo for, per leggere i numeri in esso contenuti e per scriverne dei nuovi. Non è diciamo così immediato come delle classiche variabili primitive.
Vediamo innanzi tutto come si crea un vettore.
[java]
int vettore[] = new int[20];
[/java]
Vediamo di capire la sintassi
int è il tipo di vettore, il tipo di variabile, come nelle classiche variabili primitive.
vettore è l’identificatore. Potrete dargli il nome che volete, ma dato che io ho una scarsa fantasia, gli ho dato il nome vettore.
[] è per dire al compilatore Java che questo è un vettore e ha delle celle.
= diamo con questo simbolo un valore al vettore
new = con questa keyword speciale di Java istanziamo il vettore nella memoria ram
int Istanziamo il vettore con la grandezza di una variabile int. Questo vuol dire che ogni cella del vettore avrà la grandezza di una normale variabile int.
[20] è il numero di celle. Potrete metterci dentro il numero che volete, dipende dalla vostra necessità.
Bene, ora la sintassi l’abbiamo vista.
Ora vediamo come scrivere dei numeri all’interno di un vettore di 20 celle e poi leggere i valori del vettori, cella per cella.
[java]
import java.util.Scanner;
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int vettore[] = new int[20];
for (int i = 0; i <= 19; i++){
System.out.println("Inserisci un valore");
vettore[i] = sc.nextInt();
}
// Questo serve per la scrittura dei dati nel vettore
for (int i = 0; i <= 19; i++){
System.out.println("Il valore da visualizzare e’ -> " + vettore[i]);
}
// Questo serve per la lettura del vettore
}
[/java]
Qui non c’è quasi nulla da spiegare, in quanto ormai è tutto chiaro. Ma c’è qualche dettaglio da far vedere. Quando io richiamo il vettore “vettore[i]”, richiamo il numero della cella del vettore per scriverci o per leggere il suo contenuto (se precedentemente ha già inserito dei dati all’interno di una cella). Al posto del numero della cella metto la variabile contatore i. Questo perché la variabile contatore con il ciclo incrementa ad ogni ripetizione e ad ogni incremento fa riferimento a una cella da leggere o da scrivere da me interessata. Ho già deciso tutto nella parte della condizione del ciclo for.
Bene, una volta visto i vettori la parte base del corso Java è praticamente finita. Per un po’ di tempo (non molto, non preoccupatevi) sospenderò il corso di Java, per poi riprenderlo trattando della OOP (la parte del Java che sussegue dalle basi e che è programmazione orientata agli oggetti, un tipo di programmazione un po’ più complessa, ma più completa, in cui sarà possibile vedere la vera potenza del Java.
Quindi con questo io vi aspetto al prossimo articolo. Ciao.
