IL metodo in Java o Metodi di Java è una raccolta di istruzioni che eseguono alcune attività specifiche e restituiscono il risultato al chiamante. Un metodo Java può eseguire alcune attività specifiche senza restituire nulla. I metodi Java ci consentono di farlo riutilizzo il codice senza ridigitarlo. In Java, ogni metodo deve far parte di una classe diversa da linguaggi come C, C++ e Python.

• Un metodo è come una funzione, ovvero utilizzato per esporre il comportamento di un oggetto.
• È un insieme di codici che eseguono un compito particolare.

Sintassi del metodo

 ( list_of_parameters) { //body }>

Vantaggio del metodo

• Riutilizzabilità del codice
• Ottimizzazione del codice

Nota: I metodi fanno risparmiare tempo e ci aiutano a riutilizzare il codice senza ridigitarlo.

Dichiarazione del metodo

In generale, le dichiarazioni di metodo hanno 6 componenti:

1. Modificatore: Definisce il tipo di accesso del metodo, ovvero da dove è possibile accedervi nella tua applicazione. In Java esistono 4 tipi di specificatori di accesso.

• pubblico: È accessibile in tutte le classi dell'applicazione.
• protetto: È accessibile all'interno della classe in cui è definito e nelle sue sottoclassi.
• privato: È accessibile solo all'interno della classe in cui è definito.
• predefinito: Viene dichiarato/definito senza utilizzare alcun modificatore. È accessibile all'interno della stessa classe e pacchetto all'interno del quale è definita la sua classe.

Nota: È Opzionale nella sintassi.

2. Il tipo di reso: Il tipo di dati del valore restituito dal metodo o void se non restituisce un valore. È Obbligatorio nella sintassi.

3. Nome del metodo: le regole per i nomi dei campi si applicano anche ai nomi dei metodi, ma la convenzione è leggermente diversa. È Obbligatorio nella sintassi.

4. Elenco dei parametri: L'elenco separato da virgole dei parametri di input è definito, preceduto dal tipo di dati, all'interno della parentesi racchiusa. Se non sono presenti parametri, è necessario utilizzare parentesi vuote (). È Opzionale nella sintassi.

5. Elenco delle eccezioni: Le eccezioni previste dal metodo possono generare; è possibile specificare queste eccezioni. È Opzionale nella sintassi.

6. Corpo del metodo: è racchiuso tra parentesi graffe. Il codice che devi eseguire per eseguire le operazioni previste. È Opzionale nella sintassi.

Tipi di metodi in Java

In Java esistono due tipi di metodi:

1. Metodo predefinito

In Java, i metodi predefiniti sono il metodo già definito nelle librerie di classi Java, noti come metodi predefiniti. È noto anche come metodo della libreria standard o metodo integrato. Possiamo utilizzare direttamente questi metodi semplicemente richiamandoli nel programma in qualsiasi momento.

2. Metodo definito dall'utente

Il metodo scritto dall'utente o dal programmatore è noto come metodo definito dall'utente. Questi metodi vengono modificati in base alle esigenze.

Modi per creare un metodo in Java

Esistono due modi per creare un metodo in Java:

decodifica javascript base64

1. Metodo dell'istanza: Accedi ai dati dell'istanza utilizzando il nome dell'oggetto. Dichiarato all'interno di una classe.

Sintassi:

// Instance Method void method_name(){ body // instance area }>

2. Metodo statico: Accedi ai dati statici utilizzando il nome della classe. Dichiarato in classe con statico parola chiave.

Sintassi:

//Static Method static void method_name(){ body // static area }>

Firma del metodo:

È costituito dal nome del metodo e da un elenco di parametri (numero di parametri, tipo di parametri e ordine dei parametri). Il tipo di reso e le eccezioni non sono considerati come parte di esso.

Metodo Firma della funzione di cui sopra:

 max(int x, int y) Number of parameters is 2, Type of parameter is int.>

Denominare un metodo

Il nome di un metodo è in genere una singola parola che dovrebbe essere a verbo in minuscolo o multiparola, che inizia con a verbo in minuscolo seguito da un aggettivo sostantivo. Dopo la prima parola, la prima lettera di ogni parola dovrebbe essere in maiuscolo.

Regole per nominare un metodo:

• Mentre definisci un metodo, ricorda che il nome del metodo deve essere a verbo e inizia con a minuscolo lettera.
• Se il nome del metodo contiene più di due parole, il primo nome deve essere un verbo seguito da un aggettivo o un sostantivo.
• Nel nome del metodo composto da più parole, deve essere presente la prima lettera di ciascuna parola maiuscolo tranne la prima parola. Ad esempio, findSum, computeMax, setX e getX.

Generalmente, un metodo ha un nome univoco all'interno della classe in cui è definito, ma a volte un metodo potrebbe avere lo stesso nome di altri nomi di metodo all'interno della stessa classe di l'overload del metodo è consentito in Java .

data dell'utilità Java

Metodo di chiamata

Il metodo deve essere chiamato per utilizzare la sua funzionalità. Ci possono essere tre situazioni in cui viene chiamato un metodo:
Un metodo ritorna al codice che lo ha invocato quando:

• Completa tutte le istruzioni del metodo.
• Raggiunge una dichiarazione di ritorno.
• Genera un'eccezione.

Esempio:

// Java Program to Illustrate Methods // Importing required classes import java.io.*; // Class 1 // Helper class class Addition {  // Initially taking sum as 0  // as we have not started computation  int sum = 0;  // Method  // To add two numbers  public int addTwoInt(int a, int b)  {  // Adding two integer value  sum = a + b;  // Returning summation of two values  return sum;  } } // Class 2 // Helper class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating object of class 1 inside main() method  Addition add = new Addition();  // Calling method of above class  // to add two integer  // using instance created  int s = add.addTwoInt(1, 2);  // Printing the sum of two numbers  System.out.println('Sum of two integer values :'  + s);  } }>

Sum of two integer values :3>

Esempio 2:

// Java Program to Illustrate Method Calling // Via Different Ways of Calling a Method // Importing required classes import java.io.*; // Class 1 // Helper class class Test {  public static int i = 0;  // Constructor of class  Test()  {  // Counts the number of the objects of the class  i++;  }  // Method 1  // To access static members of the class and  // and for getting total no of objects  // of the same class created so far  public static int get()  {  // statements to be executed....  return i;  }  // Method 2  // Instance method calling object directly  // that is created inside another class 'GFG'.  // Can also be called by object directly created in the  // same class and from another method defined in the  // same class and return integer value as return type is  // int.  public int m1()  {  // Display message only  System.out.println(  'Inside the method m1 by object of GFG class');  // Calling m2() method within the same class.  this.m2();  // Statements to be executed if any  return 1;  }  // Method 3  // Returns nothing  public void m2()  {  // Print statement  System.out.println(  'In method m2 came from method m1');  } } // Class 2 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating object of above class inside the class  Test obj = new Test();  // Calling method 2 inside main() method  int i = obj.m1();  // Display message only  System.out.println(  'Control returned after method m1 :' + i);  // Call m2() method  // obj.m2();  int no_of_objects = Test.get();  // Print statement  System.out.print(  'No of instances created till now : ');  System.out.println(no_of_objects);  } }>

Inside the method m1 by object of GFG class In method m2 came from method m1 Control returned after method m1 :1 No of instances created till now : 1>

Il flusso di controllo del programma sopra è il seguente:

Passaggio di parametri a un metodo

Ci sono alcuni casi in cui non conosciamo il numero di parametri da passare o si verifica un caso imprevisto in cui si utilizzano più parametri rispetto al numero di parametri dichiarato. In questi casi possiamo usare

• Passaggio di array come argomento
• Passaggio di argomenti variabili come argomento
• Sovraccarico del metodo.

Allocazione della memoria per le chiamate ai metodi

Le chiamate ai metodi vengono implementate tramite uno stack. Ogni volta che un metodo viene chiamato, viene creato uno stack frame all'interno dell'area dello stack e successivamente gli argomenti passati, le variabili locali e il valore da restituire da questo metodo chiamato vengono archiviati in questo stack frame e al termine dell'esecuzione del metodo chiamato , lo stack frame allocato verrebbe eliminato. C'è un registro del puntatore dello stack che traccia la parte superiore dello stack che viene regolato di conseguenza.

Esempio: pseudo-codice per l'implementazione dei metodi

// Define a class public class Example {  // Define instance variables  private int number;  private String name;  // Define accessor (getter) methods  public int getNumber() {  return number;   }  public String getName() {  return name;   }  // Define mutator (setter) methods  public void setNumber(int number)  {  this.number = number;  }  public void setName(String name) { this.name = name; }  // Define other methods  public void printDetails()  {  System.out.println('Number: ' + number);  System.out.println('Name: ' + name);  } } // Use the methods in another part of the code Example example = new Example(); example.setNumber(123); example.setName('GFG Write'); example.printDetails();>

Ci sono diversi vantaggi nell'usare i metodi in Java, tra cui:

• Riutilizzabilità : i metodi ti consentono di scrivere il codice una volta e di utilizzarlo più volte, rendendo il codice più modulare e più facile da mantenere.
• Astrazione : I metodi consentono di astrarre la logica complessa e fornire un'interfaccia semplice che altri possono utilizzare. Ciò rende il tuo codice più leggibile e più facile da capire.
• Leggibilità migliorata : suddividendo il codice in metodi più piccoli e ben denominati, puoi renderlo più leggibile e più facile da comprendere.
• Incapsulamento : i metodi consentono di incapsulare logica e dati complessi, semplificandone la gestione e la manutenzione.
• Separazione delle preoccupazioni s: Utilizzando i metodi, puoi separare diverse parti del tuo codice e assegnare diverse responsabilità a diversi metodi, migliorando la struttura e l'organizzazione del tuo codice.
• Modularità migliorata : I metodi ti consentono di suddividere il codice in unità più piccole e più gestibili, migliorando la modularità del codice.
• Testabilità migliorata : suddividendo il codice in unità più piccole e più gestibili, puoi semplificare il test e il debug del codice.
• Prestazione migliorata: Organizzando il codice in metodi ben strutturati, puoi migliorare le prestazioni riducendo la quantità di codice da eseguire e semplificando la memorizzazione nella cache e l'ottimizzazione del codice.

Domande frequenti in Metodi in Java

D. Cos'è un metodo nella programmazione Java?

Il metodo Java è una raccolta di istruzioni che eseguono alcune attività specifiche e restituiscono il risultato al chiamante.

D. Quali sono le parti del metodo in Java?

Le 5 parti dei metodi in Java sono menzionate di seguito:

1. Modificatori
2. Tipo di reso
3. Nome del metodo
4. Parametri
5. Corpo del metodo

Articoli Correlati:

• Java è rigorosamente superato per valore
• Sovraccarico del metodo ed errore nullo in Java
• Possiamo sovraccaricare o sovrascrivere metodi statici in Java?
• Quiz Java