|
== Metodi ==
Un metodo è un costrutto che definisce una determinata sequenza di istruzioni, perché possa essere eseguita su richiesta.
Possiamo pensare ai metodi come a dei sotto-programmi (''subroutine'') che raggruppano istruzioni ed espressioni per una elaborazione semplice dei dati al loro interno.
<br/>Essi, che in altri linguaggi di programmazione sono chiamati “funzioni”, sono in pratica come dei moduli intelaiati all'interno di un raccoglitore, la classe, che normalmente ne comprende numerosi concorrendo a costituire un programma organico. Concettualmente il metodo è anche paragonabile ad una azione che l'oggetto (una istanza della classe) può compiere.
<source lang="Java>
I metodi concettualmente servono a fare una stessa serie di operazioni in più punti del programma senza riscriverle, quindi snelliscono il programma. Servono anche a suddividere un programma complesso in piccole parti migliorandone la gestione e la leggibilità.
public class Prova {
Le classi API hanno molti metodi usabili e riusabili ma è soprattuto possibile creare i propri metodi personalizzati per integrarli e adattarli meglio agli scopi del nostro programma.
public static void main(String[] args) {
scrivi();
I metodi vanno implementati e codificati all'interno della classe e fuori da qualsiasi altro metodo, anche il "main()" che è un metodo speciale segue questa regola; un metodo non può essere codificato e costruito all'interno di altro metodo, invece è possibile richiamare (o usare) i metodi in maniera annidata, o addirittura chiamando loro stessi.
}
I metodi si scrivono, o si implementano, in un modo e si usano, o chiamano, in un altro.
void scrivi() {
System.out.println("prova");
I metodi possono essere istanziati o di classe.
}
La sintassi per la implementazione (scrittura di codice) di un metodo è la seguente:
<source lang=java>
modificatori tipo nomedelmetodo (parametri eventuali){
corpo del metodo;
}
</source>
In questo esempio, la JVM invoca il metodo main(), e questo metodo invoca il metodo scrivi(), il quale scrive una determinata stringa sulla console.
Per richiamare un metodo usiamo la sintassi:
<source lang=java>
nomedelmetodo (parametri eventuali);
</source>
Un metodo è definito da
Cioè per eseguire ed usare le istruzioni di “nomedelmetodo” devo scrivere
*eventuali modificatori
<source lang=java>
*tipo di ritorno
nomedelmetodo (parametri eventuali);
*nome del metodo
</source>
*lista di argomenti
*eventuale [[Java/Gestione delle eccezioni|clausola ''throws'']]
I metodi sono utili perché permettono di definire dei "pacchetti" di istruzioni che vengono eseguiti da un certo oggetto su richiesta:
Di seguito è mostrato ad esempio un esempio funzionante di implementazione di un metodo senza i parametri:
<source lang=java"Java">
public class Cane Frase{
public void abbaia() { System.out.println("Bau bau"); }
public void dormi() { System.out.println("zzz"); }
}
public class Prova {
String soggetto= "egli ";
public static void main(String[] args) {
String verbo= "fa ";
final Cane c = new Cane();
String complemento= "qualcosa";
c.dormi();
c.abbaia();
// inizio del metodo
c.dormi();
public void faifrase(){
System.out.println(soggetto + verbo + complemento);
}
}
// fine del metodo
}
</source>
I metodi offrono numerosi vantaggi:
Proviamo ora ad usare il metodo richiamandolo da un'altra classe, definita nel modo seguente:
*servono a fare una stessa serie di operazioni in più punti del programma senza riscriverle, quindi snelliscono il programma;
<source lang=java>
*sono utili per suddividere un programma complesso in piccole parti, migliorandone la gestione e la leggibilità.
public class Provametodo{
=== Il ''main()'' ===
public static void main(String [] Args){
Lo stesso "main()" è un normale metodo Java, esattamente al pari degli altri. La differenza rispetto agli altri è che, da qualche parte, è stato codificato che una macchina virtuale può chiamare un metodo che ha tale nome, se soddisfa determinati requisiti (deve essere <code>static</code> e <code>public</code>, avere tipo di ritorno <code>void</code>, e un solo argomento di tipo <code>String[]</code>).
Frase B= new Frase();
B.faifrase();
}
</source>
In questo codice richiamo il metodo <code>faifrase()</code> dopo aver istanziato un oggetto di classe Frase (chiamandolo "B"). Ciò è necessario per essere usato nel “main()", un altro metodo ma particolare di cui si parlerà sotto, e da un'altra classe: “Provametodo”.
“Faifrase()” è un metodo istanziato appunto perché chiamato su istanza di classe.
Il codice sorgente finale diventa quindi questo:
=== Come definire un metodo ===
La sintassi per la implementazione (scrittura di codice) di un metodo è la seguente:
<source lang=java>
modificatori tipo nomedelmetodo (parametri eventuali){
class Frase{
corpo del metodo;
String soggetto= "egli ";
String verbo= "fa ";
String complemento= "qualcosa";
public void faifrase(){
System.out.println(soggetto + verbo + complemento);
}
}
public class Provametodo{
public static void main(String [] Args){
Frase B= new Frase();
B.faifrase();
}
}
</source>
Salvare questo codice con nome Provametodo.java, compilare ed eseguire.
I parametri possono esserci oppure no.
I metodi possono restituire un valore particolare al chiamante oppure no. Quando si vuole restituire un valore il chiamante diverrà tale valore. La restituzione di un valore si ha con l'enunciato "'''return'''" ed il '''tipo del valore restituito indicato''' prima del nome del metodo. Se non si vuole restituire un valore o un dato particolare allora non occorre return e prima del nome del metodo c'è bisogno dell'enunciato "'''void'''". Quindi, prima del nome del metodo, ci deve essere <u> o il "void" o il tipo del valore ( con all'interno del corpo la clausola "return")</u>.
Il metodo faifrase che abbiamo su non restituisce un valore particolare questo invece si:
<source lang=java>
public int dividinumeri(int dividendo, int divisore){
int prodotto= dividendo/divisore;
return prodotto;
}
</source>
In questo caso il metodo chiamante "dividinumeri(10,2)" diventa un intero (precisamente l'intero che è stato prodotto dalla divisione), e si potrebbe usare anche come tale, ovvero come un "5".
== Overloading ==
| 