4 - Unità didattica 2.3)
- 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.
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:
Ultime novità nel portale del tutto gratis e on line