In questo articolo, vi mostreremo come chiamare un metodo in Java. Un metodo in Java è un insieme di istruzioni che sono raggruppate insieme per eseguire un’operazione. È possibile passare dati, noti come parametri, in un metodo. I metodi sono anche conosciuti come funzioni.
Ogni metodo ha il suo nome. Quando quel nome viene incontrato in un programma, l’esecuzione del programma si dirama verso il corpo di quel metodo. Quando il metodo è finito, l’esecuzione ritorna all’area del codice del programma da cui è stato chiamato, e il programma continua alla prossima linea di codice.
Quando si chiama il metodo System.out.println(), per esempio, il sistema esegue in realtà diverse istruzioni in background che sono già memorizzate nella libreria, per visualizzare un messaggio sulla console.
Perché usare i metodi? Per riutilizzare il codice: definire il codice una volta, e usarlo molte volte. In realtà il modo modulare permette a diversi programmatori di lavorare indipendentemente su concetti separati che possono essere assemblati in seguito per creare l’intero progetto. L’uso dei metodi sarà il nostro primo passo nella direzione della programmazione modulare.
Ora imparerete come creare i vostri metodi con o senza valori return, invocare un metodo con o senza parametri, e applicare l’astrazione dei metodi nel design del programma.
Creare un metodo
Un metodo deve essere dichiarato all’interno di una classe. Viene definito con il nome del metodo, seguito da parentesi ().
La definizione del metodo consiste in un’intestazione e un corpo del metodo.
Esempio:
public class MyClass { public static void myMethod() { // code to be executed }}
Spiegazione del codice:
-
public static: modificatore, definisce il tipo di accesso del metodo -
myMethod(): nome del metodo -
static: significa che il metodo appartiene alla classe MyClass e non ad un oggetto della classe MyClass. -
void: significa che questo metodo non ha un valore di ritorno.
Nota: La parola public prima del nome del metodo significa che il metodo stesso può essere chiamato da qualsiasi luogo che include altre classi, anche da diversi pacchetti (file) purché si importi la classe. Ci sono altre tre parole che possono sostituire public. Sono protected e private. Se un metodo è protected, allora solo questa classe e le sottoclassi (classi che usano questa come base per costruire) possono chiamare il metodo. Se un metodo è private, allora il metodo può essere chiamato solo all’interno della classe. L’ultima parola chiave in realtà non è nemmeno una parola. Questo è se non avete nulla al posto di publicprotected, o private. Questo è chiamato il default, o pacchetto-privato. Ciò significa che solo le classi dello stesso pacchetto possono chiamare il metodo. Se siete interessati a vedere altri esempi potete leggere questo articolo.
Come chiamare un metodo in Java
Per chiamare un metodo in Java, scrivete il nome del metodo seguito da due parentesi () e un punto e virgola;
Il processo di chiamata del metodo è semplice. Quando un programma invoca un metodo, il controllo del programma viene trasferito al metodo chiamato.
Nell’esempio seguente, myMethod() è usato per stampare un testo (l’azione), quando viene chiamato:
MyClass.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); }}
Output:
You have called me! My name is: myMethod!
Nell’esempio precedente se si rimuove la parola chiave static, java si lamenta che non è possibile chiamare un metodo da una funzione statica:
Se non vuoi usare static, puoi solo chiamare il metodo di istanza:
public class MyClass { void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { new MyClass().myMethod(); }}
Un metodo può anche essere chiamato più volte:
MyClass.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); myMethod(); myMethod(); }}
Output:
You have called me! My name is: myMethod!You have called me! My name is: myMethod!You have called me! My name is: myMethod!
Parametri dei metodi Java
3.1 Parametri e argomenti
Le informazioni possono essere passate ai metodi come parametri. I parametri agiscono come variabili all’interno del metodo.
I parametri sono specificati dopo il nome del metodo, dentro le parentesi. Potete aggiungere tutti i parametri che volete, basta separarli con una virgola.
L’esempio seguente ha un metodo che prende un int chiamato num come parametro. Quando il metodo viene chiamato, passiamo un numero, che viene usato all’interno del metodo per essere moltiplicato per 2:
Esempio03
public class Math { static int multiplyBytwo(int number) { return number * 2; } public static void main(String args) { int result = multiplyBytwo(2); System.out.println("The output is: " + result); }}
Output:
The result of multiplication is: 4
3.2 Parametri multipli
Puoi avere tutti i parametri che vuoi. Vedi il seguente esempio:
Esempio04
public class Math { static int sum(int num1, int num2) { return num1 + num2; } public static void main(String args) { int result = sum(2,3); System.out.println("Sum of numbers is: " + result); }}
Output:
Sum of numbers is: 5
Nota: quando si lavora con parametri multipli, la chiamata al metodo deve avere lo stesso numero di argomenti di quanti sono i parametri, e gli argomenti devono essere passati nello stesso ordine.
Negli esempi 03 e 04 abbiamo passato parametri per valore. Infatti i valori degli argomenti rimangono gli stessi anche dopo l’invocazione del metodo. Vediamo un altro esempio, esempio05:
Swapp.java
public class Swapp { public static void swapFunction(int a, int b) { System.out.println("In swapFunction at the begining: a = " + a + " , b = " + b); // Swap n1 with n2 int c = a; a = b; b = c; System.out.println("In swapFunction at the end: a = " + a + " , b = " + b); } public static void main(String args) { int a = 10; int b = 20; System.out.println("Before swapping: a = " + a + " , b = " + b); // Invoke the swap method swapFunction(a, b); System.out.println("\n**Now, Before and After swapping values will be same here**:"); System.out.println("After swapping: a = " + a + " , b = " + b); }}
Output:
Before swapping: a = 10 , b = 20In swapFunction at the begining: a = 10 , b = 20In swapFunction at the end: a = 20 , b = 10**Now, Before and After swapping values will be same here**:After swapping: a = 10 , b = 20
Ora se passiamo un oggetto e cambiamo uno dei suoi campi, anche i valori saranno cambiati, esempio06:
Student.java
public class Student { String firstName; String familyName; int age; public Student(){ } public Student(String firstName, String familyName){ this.firstName = firstName; this.familyName = familyName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getFamilyName() { return familyName; } public void setFamilyName(String familyName) { this.familyName = familyName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}
Ora creiamo un’istanza della classe Student e inizializziamo i suoi campi tramite il suo costruttore, dopo di che cambieremo il valore del campo tramite il suo metodo:
public class Main { public static void main(String args) { Student student = new Student("Jack", "Smith"); System.out.println("Student's name is set (Constructor): " + student.getFirstName()); student.setFirstName("John"); System.out.println("Student's name is set (Main): " + student.getFirstName()); }}
Output:
Student's name is set (Constructor): JackStudent's name is set (Main): John
Method Overloading
Quando una classe ha due o più metodi con lo stesso nome ma parametri diversi, si parla di overloading del metodo. È diverso dall’override. Nell’overriding, un metodo ha lo stesso nome, tipo, numero di parametri, ecc. Considerate il seguente esempio, che ha un metodo che aggiunge numeri di tipo diverso, esempio07:
Sum.java
public class Sum { static int sum(int x, int y) { return x + y; } static double sum(double x, double y) { return x + y; } public static void main(String args) { int int_sum = sum(10, 20); double double_sum = sum(10.5, 23.67); System.out.println("int: " + int_sum); System.out.println("double: " + double_sum); }}
Output:
int: 30double: 34.17
Nota: Più metodi possono avere lo stesso nome purché il numero e/o il tipo di parametri siano diversi.
Method Overriding
Overriding è una caratteristica che permette ad una sottoclasse o classe figlia di fornire una specifica implementazione di un metodo che è già fornito da una delle sue superclassi o classi madri. Quando un metodo in una sottoclasse ha lo stesso nome, gli stessi parametri o firma e lo stesso tipo di ritorno (o sottotipo) di un metodo nella sua superclasse, allora si dice che il metodo nella sottoclasse sovrascrive il metodo nella superclasse.
Se un oggetto di una classe padre viene usato per invocare il metodo, allora verrà eseguita la versione nella classe padre, ma se un oggetto della sottoclasse viene usato per invocare il metodo, allora verrà eseguita la versione nella classe figlia. In altre parole, è il tipo dell’oggetto a cui si fa riferimento (non il tipo della variabile di riferimento) che determina quale versione di un metodo sovrascritto sarà eseguita.
5.1 Regole per la sovrascrittura dei metodi Java
- Il metodo deve avere lo stesso nome della classe padre
- Il metodo deve avere lo stesso parametro della classe padre.
- Ci deve essere una relazione IS-A (ereditarietà).
Vediamo un esempio, esempio08:
Human.java
public class Human { //Overridden method public void walk() { System.out.println("Human is walking"); }}
Ora estendiamo la classe Human e creiamo una sottoclasse da essa:
HumanChild.java
public class HumanChild extends Human{ //Overriding method public void walk(){ System.out.println("Child is walking"); } public static void main( String args) { HumanChild obj = new HumanChild(); obj.walk(); }}
Come vedete, obj.walk(); chiamerà la versione della classe figlio di walk():
Output:
Child is walking