 Buono sconto 4% su Toner e Cartucce agli utenti AZpoint. SU Iomiricarico.it!!
- I metodi in Java
Nella definizione di classe, quando si parla di caratteristiche, in pratica
ci si riferisce ai dati (variabili e costanti), mentre col termine funzionalità
ci si riferisce ai metodi. Abbiamo già detto che metodo è sinonimo di azione.
Quindi, affinché un programma esegua qualche istruzione, deve contenere metodi.
Infatti è il metodo main,
che per default, è il punto di partenza di ogni applicazione Java. Una classe
senza metodo main,
come la classe Punto,
non può essere mandata in esecuzione, ma solo istanziata all’interno di un
metodo di un’altra classe (nell’esempio precedente, nel metodo main
della classe Principale).
Il concetto di metodo è quindi anch’esso alla base della programmazione ad
oggetti. Senza metodi, gli oggetti non potrebbero comunicare tra loro. Essi
possono essere considerati messaggi che gli oggetti si scambiano. Inoltre
rendono i programmi più leggibili e di più facile manutenzione, lo sviluppo
più veloce e stabile, evitano le duplicazioni, e favoriscono il riuso del
software.
Il programmatore che si avvicina a Java dopo esperienze nel campo della
programmazione strutturata, spesso tende a confrontare il concetto di funzione
con il concetto di metodo. Sebbene simili nella forma e nella sostanza,
bisognerà tener presente, al momento dell’implementazione, che un metodo ha
un utilizzo differente dalla funzione. Nella programmazione strutturata infatti,
il concetto di funzione era alla base. Tutti i programmi erano formati da un
cosiddetto programma chiamante e da un certo numero di funzioni. Queste avevano
di fatto il compito di risolvere determinati "sotto-problemi" generati
da un analisi di tipo Top-Down, allo scopo di risolvere il problema generale.
Come vedremo più avanti, nella programmazione orientata agli oggetti, i
"sotto-problemi" saranno invece risolti tramite i concetti di classe
ed oggetto, che a loro volta, faranno uso di metodi.
È bene che il lettore cominci a distinguere nettamente due fasi per quanto
riguarda i metodi: dichiarazione e chiamata.
Dichiarazione di un metodo:
La dichiarazione definisce un metodo, ecco la sintassi:
[modificatori] tipo_di_ritorno nome_del_metodo ([parametri]) {
corpo_del_metodo}
dove:
- modificatori: parole chiavi di Java
che possono essere usate per modificare in qualche modo le funzionalità e le
caratteristiche di un metodo.
- tipo di ritorno: il tipo di dato che
un metodo potrà restituire dopo essere stato chiamato.
- nome del metodo: identificatore che
sarà utilizzato al momento della chiamata del metodo.
- parametri: dichiarazioni di variabili
che potranno essere passate al metodo, e di conseguenza essere sfruttate nel
corpo del metodo, al momento della chiamata.
- corpo del metodo: insieme di comandi
(statement) che verranno eseguiti quando il metodo sarà chiamato.
Per esempio viene presentata una classe chiamata Aritmetica
che dichiara un banale metodo che somma due numeri :
class Aritmetica
{
public int somma(int a, int b)
{
return (a+b);
}
}
Notare che: come modificatore il metodo presenta la parola chiave public.
Si tratta di uno specificatore d’accesso che di fatto rende il metodo somma
accessibile da altre classi. Precisamente i metodi di altre classi potranno,
dopo aver istanziato un oggetto della classe Aritmetica,
chiamare il metodo somma.
Anche per gli specificatori d’accesso approfondiremo il discorso più avanti.
Il tipo di ritorno è un int,
ovvero, un intero. Ciò significa che questo metodo avrà come ultima
istruzione, un comando (return)
che restituirà un numero intero.
Per quanto riguarda i parametri che verranno passati a questo metodo, sono
due interi che saranno sommati all’interno del blocco di codice, e la loro
somma restituita come risultato finale.
Concludendo, la dichiarazione di un metodo definisce quali azioni deve
compiere il metodo stesso quando sarà chiamato.
- Chiamata di un metodo:
Presentiamo un’altra classe "eseguibile" (ovvero contenente il
metodo main),
che istanzia la classe Aritmetica
e chiama il metodo somma:
1 class Uno
2 {
3 public static void main(String args[])
4
{
5 Aritmetica oggetto1 = new Aritmetica();
6 int risultato=oggetto1.somma(5,6);
7 }
8
}
In questo caso notiamo subito che l’accesso al metodo somma
è avvenuto sempre tramite l’operatore dot come nel caso dell’accesso alle
variabili. Quindi, tutti i membri (attributi e metodi) pubblici definiti all’interno
di una classe, saranno accessibili tramite un’istanza della classe stessa che
sfrutta l’operatore dot, proprio con questo tipo di sintassi:
nomeOggetto.nomeMetodo;
oppure
nomeOggetto.nomeAttributo;
L’accesso al metodo di un oggetto provoca quindi l’esecuzione del
relativo blocco di codice. In questo esempio quindi, abbiamo definito una
variabile intera risultato
che ha immagazzinato il risultato della somma. Se non avessimo fatto ciò, non
avrebbe avuto senso definire un metodo che restituisse un valore, dal momento
che non l’avremmo utilizzato in qualche modo! Da notare che avremmo anche
potuto sostituire la riga 6, con:
System.out.println(oggetto1.somma(5,6));
In questo modo, stampando a video il risultato, avremmo potuto verificare in
fase di runtime del programma la reale esecuzione della somma.
Esistono anche metodi che non hanno parametri in input per esempio un metodo
che somma sempre gli stessi numeri:
class AritmeticaFissa
{
public int somma()
{
return (5+6);
}
}
oppure metodi che non hanno tipo di ritorno, ovvero che dichiarano come tipo
di ritorno void
(vuoto) come il metodo main.
Infatti il metodo main,
è il punto di partenza del runtime di un’applicazione Java, quindi non deve
restituire niente non essendo chiamato esplicitamente da un altro metodo.
Esistono ovviamente anche metodi che non hanno né parametri in input né in
output (tipo di ritorno void),
come per esempio un ipotetico metodo stampa che visualizza a video sempre lo
stesso messaggio:
class Saluti
{
public void stampaSaluto()
{
System.out.println("Ciao");
}
}
|
Shopping
