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.