Java - Metodi
Un metodo Java è una raccolta di istruzioni raggruppate per eseguire un'operazione. Quando chiami System.out.println() metodo, ad esempio, il sistema esegue effettivamente diverse istruzioni per visualizzare un messaggio sulla console.
Ora imparerai come creare i tuoi metodi con o senza valori di ritorno, invocare un metodo con o senza parametri e applicare l'astrazione del metodo nella progettazione del programma.
Metodo di creazione
Considerando il seguente esempio per spiegare la sintassi di un metodo:
Syntax
public static int methodName(int a, int b) {
// body
}
Qui,
public static - modificatore
int - tipo restituito
methodName - nome del metodo
a, b - parametri formali
int a, int b - elenco dei parametri
La definizione del metodo consiste in un'intestazione del metodo e un corpo del metodo. Lo stesso è mostrato nella seguente sintassi:
Syntax
modifier returnType nameOfMethod (Parameter List) {
// method body
}
La sintassi mostrata sopra include:
modifier - Definisce il tipo di accesso del metodo ed è facoltativo da utilizzare.
returnType - Il metodo può restituire un valore.
nameOfMethod- Questo è il nome del metodo. La firma del metodo è costituita dal nome del metodo e dall'elenco dei parametri.
Parameter List- L'elenco dei parametri, è il tipo, l'ordine e il numero di parametri di un metodo. Questi sono opzionali, il metodo può contenere zero parametri.
method body - Il corpo del metodo definisce cosa fa il metodo con le istruzioni.
Example
Ecco il codice sorgente del metodo sopra definito chiamato min(). Questo metodo accetta due parametri num1 e num2 e restituisce il massimo tra i due -
/** the snippet returns the minimum between two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
Metodo di chiamata
Per utilizzare un metodo, dovrebbe essere chiamato. Ci sono due modi in cui un metodo viene chiamato, cioè il metodo restituisce un valore o non restituisce nulla (nessun valore di ritorno).
Il processo di chiamata del metodo è semplice. Quando un programma richiama un metodo, il controllo del programma viene trasferito al metodo chiamato. Questo metodo chiamato restituisce quindi il controllo al chiamante in due condizioni, quando:
- viene eseguita l'istruzione return.
- raggiunge il metodo terminando la parentesi graffa.
I metodi che restituiscono void sono considerati come chiamate a un'istruzione. Consideriamo un esempio:
System.out.println("This is tutorialspoint.com!");
Il metodo che restituisce il valore può essere compreso dal seguente esempio:
int result = sum(6, 9);
Di seguito è riportato l'esempio per dimostrare come definire un metodo e come chiamarlo -
Example
public class ExampleMinNumber {
public static void main(String[] args) {
int a = 11;
int b = 6;
int c = minFunction(a, b);
System.out.println("Minimum Value = " + c);
}
/** returns the minimum of two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
Questo produrrà il seguente risultato:
Output
Minimum value = 6
La parola chiave vuota
La parola chiave void ci permette di creare metodi che non restituiscono un valore. Qui, nel seguente esempio stiamo considerando un metodo di metodo voidRankPoints . Questo metodo è un metodo void, che non restituisce alcun valore. La chiamata a un metodo void deve essere un'istruzione, ad esempio methodRankPoints (255.7); . È un'istruzione Java che termina con un punto e virgola come mostrato nell'esempio seguente.
Example
public class ExampleVoid {
public static void main(String[] args) {
methodRankPoints(255.7);
}
public static void methodRankPoints(double points) {
if (points >= 202.5) {
System.out.println("Rank:A1");
}else if (points >= 122.4) {
System.out.println("Rank:A2");
}else {
System.out.println("Rank:A3");
}
}
}
Questo produrrà il seguente risultato:
Output
Rank:A1
Passaggio di parametri per valore
Mentre si lavora sotto il processo di chiamata, gli argomenti devono essere passati. Questi dovrebbero essere nello stesso ordine dei rispettivi parametri nella specifica del metodo. I parametri possono essere passati per valore o per riferimento.
Passare parametri per valore significa chiamare un metodo con un parametro. In questo modo, il valore dell'argomento viene passato al parametro.
Example
Il seguente programma mostra un esempio di passaggio di parametri per valore. I valori degli argomenti rimangono gli stessi anche dopo l'invocazione del metodo.
public class swappingExample {
public static void main(String[] args) {
int a = 30;
int b = 45;
System.out.println("Before swapping, a = " + a + " and 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 + " and b is " + b);
}
public static void swapFunction(int a, int b) {
System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = " + a + " b = " + b);
}
}
Questo produrrà il seguente risultato:
Output
Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30
**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45
Metodo di sovraccarico
Quando una classe ha due o più metodi con lo stesso nome ma parametri diversi, è noto come sovraccarico del metodo. È diverso dall'override. Nell'override, un metodo ha lo stesso nome, tipo, numero di parametri e così via.
Consideriamo l'esempio discusso in precedenza per trovare i numeri minimi di tipo intero. Se, diciamo, vogliamo trovare il numero minimo di double type. Quindi verrà introdotto il concetto di sovraccarico per creare due o più metodi con lo stesso nome ma parametri differenti.
L'esempio seguente spiega lo stesso:
Example
public class ExampleOverloading {
public static void main(String[] args) {
int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
int result1 = minFunction(a, b);
// same function name with different parameters
double result2 = minFunction(c, d);
System.out.println("Minimum Value = " + result1);
System.out.println("Minimum Value = " + result2);
}
// for integer
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
// for double
public static double minFunction(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
Questo produrrà il seguente risultato:
Output
Minimum Value = 6
Minimum Value = 7.3
I metodi di sovraccarico rendono il programma leggibile. Qui, due metodi sono dati con lo stesso nome ma con parametri diversi. Il numero minimo di numeri interi e doppi è il risultato.
Utilizzo degli argomenti della riga di comando
A volte potresti voler passare alcune informazioni a un programma quando lo esegui. Ciò si ottiene passando gli argomenti della riga di comando a main ().
Un argomento della riga di comando è l'informazione che segue direttamente il nome del programma sulla riga di comando quando viene eseguito. Per accedere agli argomenti della riga di comando all'interno di un programma Java è abbastanza semplice. Sono archiviati come stringhe nell'array String passato a main ().
Example
Il seguente programma mostra tutti gli argomenti della riga di comando con cui viene chiamato:
public class CommandLine {
public static void main(String args[]) {
for(int i = 0; i<args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
Prova a eseguire questo programma come mostrato qui -
$java CommandLine this is a command line 200 -100
Questo produrrà il seguente risultato:
Output
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100
La parola chiave this
thisè una parola chiave in Java che viene utilizzata come riferimento all'oggetto della classe corrente, con in un metodo di istanza o un costruttore. Usando questo puoi fare riferimento ai membri di una classe come costruttori, variabili e metodi.
Note- La parola chiave this viene utilizzata solo all'interno di metodi o costruttori di istanze
In generale, la parola chiave this viene utilizzata per:
Differenziare le variabili di istanza dalle variabili locali se hanno lo stesso nome, all'interno di un costruttore o di un metodo.
class Student {
int age;
Student(int age) {
this.age = age;
}
}
Chiama un tipo di costruttore (costruttore parametrizzato o predefinito) da un altro in una classe. È noto come invocazione esplicita del costruttore.
class Student {
int age
Student() {
this(20);
}
Student(int age) {
this.age = age;
}
}
Example
Ecco un esempio che utilizza questa parola chiave per accedere ai membri di una classe. Copia e incolla il seguente programma in un file con il nome,This_Example.java.
public class This_Example {
// Instance variable num
int num = 10;
This_Example() {
System.out.println("This is an example program on keyword this");
}
This_Example(int num) {
// Invoking the default constructor
this();
// Assigning the local variable num to the instance variable num
this.num = num;
}
public void greet() {
System.out.println("Hi Welcome to Tutorialspoint");
}
public void print() {
// Local variable num
int num = 20;
// Printing the local variable
System.out.println("value of local variable num is : "+num);
// Printing the instance variable
System.out.println("value of instance variable num is : "+this.num);
// Invoking the greet method of a class
this.greet();
}
public static void main(String[] args) {
// Instantiating the class
This_Example obj1 = new This_Example();
// Invoking the print method
obj1.print();
// Passing a new value to the num variable through parametrized constructor
This_Example obj2 = new This_Example(30);
// Invoking the print method again
obj2.print();
}
}
Questo produrrà il seguente risultato:
Output
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint
Argomenti variabili (var-args)
JDK 1.5 consente di passare un numero variabile di argomenti dello stesso tipo a un metodo. Il parametro nel metodo è dichiarato come segue:
typeName... parameterName
Nella dichiarazione del metodo si specifica il tipo seguito da puntini di sospensione (...). Un solo parametro di lunghezza variabile può essere specificato in un metodo e questo parametro deve essere l'ultimo parametro. Tutti i parametri regolari devono precederlo.
Example
public class VarargsDemo {
public static void main(String args[]) {
// Call method with variable args
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}
Questo produrrà il seguente risultato:
Output
The max value is 56.5
The max value is 3.0
Il metodo finalize ()
È possibile definire un metodo che verrà chiamato appena prima della distruzione finale di un oggetto da parte del garbage collector. Questo metodo è chiamatofinalize( )e può essere utilizzato per garantire che un oggetto termini in modo pulito.
Ad esempio, potresti usare finalize () per assicurarti che un file aperto di proprietà di quell'oggetto sia chiuso.
Per aggiungere un finalizzatore a una classe, devi semplicemente definire il metodo finalize (). Il runtime Java chiama quel metodo ogni volta che sta per riciclare un oggetto di quella classe.
All'interno del metodo finalize (), specificherai le azioni che devono essere eseguite prima che un oggetto venga distrutto.
Il metodo finalize () ha questa forma generale:
protected void finalize( ) {
// finalization code here
}
Qui, la parola chiave protected è uno specificatore che impedisce l'accesso a finalize () dal codice definito al di fuori della sua classe.
Ciò significa che non puoi sapere quando o anche se finalize () verrà eseguito. Ad esempio, se il programma termina prima che si verifichi la garbage collection, finalize () non verrà eseguito.