else{ //istruzione di default.
Siamo nel caso: d1 > 1 e d2 > 1. Il punteggio Punt aumenta: Punt = Punt+(d1+d2). Si verifica se il giocatore ha vinto:
if(Punt > = Win){ //......
Se sì, la partita è finita: finePartita();
Altrimenti, se la partita non è finita, si chiede al giocatore se vuole rigiocare: rigiocare?(). Se il giocatore non vuole rigiocare, si deve uscire dal ciclo e per questo basta impostare c = 0. Altrimenti, se il giocatore vuole rigiocare, basta non modificare c; siccome siamo in un ciclo "while", il computer prenderà a ripetere le istruzioni seguenti "while(c == 1)" ; cioè:
tiraDadi(); //ecc si riprende tutto da capo.
Bene, ma in tutto questo non abbiamo definito cosa significhano: tiraDadi() e finePartita(); anche se, nella nostra mente, queste due funzioni sono abbastanza chiare. Le cose non sono così semplici, anche se per noi è chiaro cosa intendiamo con, per esempio, tiraDadi(), lo dobbiamo spiegare al computer. Osserviamo che l'operazione di tirare i dadi è la medesima sia per il computer che per il giocatore corrente. Quindi, forse, ci basta definre questa operazione una volta per tutte. Quindi definiamo una funzione tiraDadi() che si applicherà, sia quando gioca il computer, che quando giochiamo noi. In Java una tale funzione viene chiamata metodo.
Dobbiamo definire questa funzione (metodo).
La sintassi di base per definire un metodo in Java ha una struttura particolare, ossia:
tipo valore di ritorno nome(elenco-parametri)
Cosa significa tutto ciò? Una funzione (un metodo) prende dei dati (variabili), li combina e restituisce un valore. Per esempio la funzione x -> 2x (moltiplicazione per due), prende un intero x, lo moltiplica per due e restituisce ("ritorna") 2x. In questo caso c'è un unico parametro (variabile): è l'intero x; il valore di ritorno è 2x e il suo tipo è un int
In Java il metodo della moltiplicazione per due (sugli int) potrebbe essere scritto così:
int PerDue(int x){
int a;
a = 2*x;
return a;
}
int PerDue(int x){
dichiara un metodo (funzione) che si applica ad un int x (il cui argomento, la cui variabile è un int x). Il metodo funziona così: ad un int a=0 assegno il valore 2*x e, poi, restituisco a = 2*x. Il tipo (= "la specie") del valore restituito (2*x) è un int.
Alcuni metodi potrebbero non ritornare alcun valore, in questo caso il tipo del valore di ritorno è "void", e questo va specificato. Per esempio:
void Stampa(String S){
System.out.println(S);
}
Questo metodo stampa la stringha S.
La definizione di metodo data qui sopra è quella più semplice, è possibile introdurre altre specificazioni. Per esempio un controllo dell'accesso ("public" / "private"): un metodo è "public" se è accessibile anche al di fuori della classe in cui è definito (altrimenti, sostanzialmente, è "private"). Se non viene dichiarato nulla, per default, il metodo è "public".
E' possibile introdurre altre specifiche nella dichiarazione di un metodo, per esempio un metodo può essere dichiarato "static"; per esempio la formula magica:
public static void main(String[] arg){
significa che main è un metodo pubblico, statico, che non ritorna niente (il tipo del valore di ritorno è "void" = vuoto), che prende come variabili (parametri) un "array" (=matrice) di stringhe (String[]), chiamati arg (potrebbero chiamarsi anche marte2, la tradizione vuole che si chiamino arg).
Tutto questo è ancora assai misterioso (specie lo "static"), ci torneremo su più avanti. Per il momento, ci accontentiamo della definizione base:
tipo valore di ritorno nome(elenco-parametri)
Ecco per esempio un modo complicato di stampare 2*3:
|
|
public class PerDue{
public static void main(String[] arg){
int y = 3;
int z = PerDue(y); //il metodo Per Due(int x) è definito qui sotto
Stampa(""+z);} //il metodo Stampa(String S) è definito qui sotto
static int PerDue(int x){ //definizione "rapida" del metodo *2
return 2*x;}
static void Stampa(String S){ //definizione del metodo Stampa(String S)
System.out.println(S);
}
}
Osservazione: I metodi PerDue e Stampa sono dichirati "static" perchè vengono usati nel metodo, necessariamente "static", main.
Parametri: Un metodo può anche non avere bisogno di parametri, in questo caso si lascia uno spazio vuoto tra le parentesi. Per esempio per simulare il tiro di un dado si potrebbe definire il metodo tiraUnDado() nel modo seguente:
|
|
int tiraUnDado(){
int a = (int)(Math.random()*6)+1;
return a;}
Come già visto, (int)(Math.random()*6), è un intero "pseudo"-casuale, n, con 0 <= n < 6 e, quindi, a è un intero "pseudo"-casuale con 1 <= a <= 6. (Qui abbiamo usato il metodo random(), senza parametri, della classe Math).