Metodi Java

In questa guida, imparerai i metodi Java tramite esempi, come definire un metodo e come utilizzare i metodi in un programma Java.

Cos'è un metodo?

In matematica, abbiamo potuto studiare le funzioni. Ad esempio, f(x) = x²x è una funzione che restituisce il quadrato di un numero.

Se x = 2, allora f(2) = 4
Se x = 3, f(3) = 9
e così via.

Allo stesso modo, nel computer programming, una funzione è un blocco di codice che esegue un compito specifico.

Nel programmazione orientata agli oggetti, questo è un termine utilizzato per funzioni. Il metodo è associato alla classe e definisce il comportamento della classe.

Prima di imparare i metodi, assicurati di comprendereClassi e oggetti Java

Tipi di metodo Java

In Java ci sono due tipi di metodi: metodi definiti dall'utente e metodi disponibili nella libreria standard.

• Metodi di libreria standard

• Metodo definito dall'utente

Metodi di libreria standard

　I metodi di libreria standard sono metodi integrati in Java, che possono essere utilizzati in qualsiasi momento. Questi metodi di libreria standard compaiono insieme alla libreria di classi Java (JCL) nei file archivio Java (*.jar) del JVM e del JRE.

Ad esempio:

• print() - È un metodo di java.io.PrintStream. Il metodo print("...") stampa una stringa tra virgolette.

• sqrt() - È un metodo di matematica. Restituisce la radice quadrata di un numero.
  

Ecco un esempio funzionante:

public class Main {
　　　　public static void main(String[] args) {
　　　　
　　　　　　　　// Utilizzo del metodo sqrt()
　　　　　　　　System.out.print("La radice quadrata di 4 è: " + Math.sqrt(4));
　　　　}
}

Output:

La radice quadrata di 4 è: 2.0

Metodo definito dall'utente

Possiamo anche creare metodi scelti da noi per eseguire determinate attività. Questo tipo di metodo si chiama metodo definito dall'utente.

Come creare un metodo definito dall'utente?

Ecco come creiamo un metodo in Java:

public static void myMethod() {
　　　　System.out.println("La mia funzione");
}

In questo esempio, abbiamo creato un metodo chiamato myMethod(). Possiamo vedere che abbiamo usato public, static e void prima del nome del metodo.

• public - Modificatore di accesso. Questo significa che è possibile accedere al metodo da qualsiasi parte. Per ulteriori informazioni, visitareModificatori di accesso Java

• static - Questo significa che è possibile accedere al metodo senza alcun oggetto. Per ulteriori informazioni, visitareParola chiave statica Java

• void - Questo significa che il metodo non restituisce alcun valore. Ne parleremo in dettaglio nella parte posteriore di questa guida.

Questo è un esempio semplice di come creiamo un metodo. Tuttavia, la sintassi completa della definizione di un metodo in Java è:

modifier static returnType nameOfMethod (parameters) {
　　　　// corpo del metodo
}

Qui,

• modificatore - Definisce il metodo di accesso come pubblico, privato ecc.

• static - Se si utilizza la parola chiave static, è possibile accedervi senza creare un oggetto.
  Ad esempio, il metodo sqrt() della classe Math standard è statico. Pertanto, possiamo chiamare direttamente Math.sqrt() senza creare un'istanza della classe Math.

• returnType - Specifica il tipo di valore restituito dal metodo. Ad esempio, se il metodo ha un tipo di ritorno int, restituisce un valore intero.
  Un metodo può restituire un tipo di dati primitivo (int, float, double ecc.), un oggetto nativo (String, Map, List ecc.) o qualsiasi altro oggetto predefinito e definito dall'utente.
  Se il metodo non restituisce alcun valore, il suo tipo di ritorno è void.

• nameOfMethod - È unidentificatore, per riferirsi a un metodo specifico nel programma.
  Possiamo dare un nome a qualsiasi metodo. Ma è più comune chiamarlo secondo il compito che esegue. Ad esempio calculateArea(), display() ecc.

• parametri (argomenti) - Questi sono i valori passati al metodo. Possiamo passare qualsiasi numero di parametri al metodo.

• corpo del metodo - Include istruzioni di programmazione per eseguire alcuni compiti. Il corpo del metodo è incluso tra parentesi graffe { }.

Come chiamare un metodo Java?

Ora che sappiamo come definire un metodo, dobbiamo imparare a utilizzarlo. Per farlo, dobbiamo chiamare il metodo. Ecco come fare

myMethod();

Questa istruzione chiama il metodo myMethod() precedentemente dichiarato.

1. 　Durante l'esecuzione del codice del programma, incontra myFunction().

2. 　Poi esegue il ramo al metodo myFunction() e esegue il codice all'interno del corpo del metodo.

3. 　Dopo l'esecuzione del corpo del metodo, il programma torna allo stato originale e esegue la prossima istruzione dopo la chiamata al metodo.
   

Esempio: metodo Java

Vediamo come utilizzare i metodi in un programma Java.

class Main {
　　　　public static void main(String[] args) {
　　　　　　　　System.out.println("Stiamo per incontrare un metodo.");
　　　　　　　　//调用方法
　　　　　　　　myMethod();
　　　　　　　　System.out.println("Il metodo è stato eseguito con successo!");
　　　　}
　　　　// definizione del metodo
　　　　private static void myMethod(){
　　　　　　　　System.out.println("Stampa dall'interno di myMethod()!");
　　　　}
}

Output:

Stiamo per incontrare un metodo.
Stampa dall'interno di myMethod()!
Il metodo è stato eseguito con successo!

Nel programma menzionato sopra, abbiamo un metodo chiamato myMethod(). Questo metodo non accetta alcun parametro. Allo stesso modo, il tipo di ritorno del metodo è void (ciò significa che non restituisce alcun valore).

In questo caso, il metodo è statico. Pertanto, abbiamo chiamato il metodo senza creare un oggetto della classe.

Guardiamo un altro esempio

class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//creazione dell'oggetto della classe Output
　　　　　　　　Output obj = new Output();
　　　　　　　　System.out.println("Stiamo per incontrare un metodo.");
　　　　　　　　//chiamata al metodo myMethod della classe Output
　　　　　　　　obj.myMethod();
　　　　　　　　System.out.println("Il metodo è stato eseguito con successo!");
　　　　}
}
class Output {
　　
　　　　//public: questo metodo può essere chiamato dall'esterno della classe
　　　　public void myMethod() {
　　　　　　　　System.out.println("Stiamo stampando dall'interno di myMethod().");
　　　　}
}

Output:

Stiamo per incontrare un metodo.
Stiamo stampando dall'interno di myMethod().
Il metodo è stato eseguito con successo!

Nell'esempio sopra, abbiamo creato un metodo chiamato myMethod(). Questo metodo si trova nella classe chiamata Output.

Poiché il metodo non è statico, viene chiamato utilizzando l'oggetto della classe obj.

obj.myMethod();

Parametri e valore di ritorno del metodo

Come precedentemente menzionato, i metodi Java possono avere zero o più parametri. E possono anche restituire alcuni valori.

Esempio: valore di ritorno del metodo

Prendiamo ad esempio un metodo con valore di ritorno.

class SquareMain {
　　　　public static void main(String[] args) {
　　　　　　　　int result;
　　　　　　　　//chiamata al metodo e memorizzazione del valore di ritorno
　　　　　　　　result = square();　
　　　　　　　　System.out.println("Il quadrato di 10 è: " + result);
　　　　}
　　　　public static int square() {
　　　　　　　　//istruzione return
　　　　　　　　return 10 * 10;
　　　　}
}

Output:

Il quadrato di 10 è: 100

Nel programma sopra, abbiamo creato un metodo chiamato square(). Questo metodo non accetta alcun parametro e restituisce un valore di 10 * 10.

In questo esempio, il tipo di ritorno del metodo menzionato è int. Pertanto, il metodo dovrebbe sempre restituire un valore intero.

Come possiamo vedere, l'intervallo di questo metodo è limitato, poiché sempre restituisce lo stesso valore. Ora, modifichiamo il frammento di codice sopra per far sì che restituisca sempre il quadrato di qualsiasi numero intero passato al metodo, non sempre il quadrato di 10.

Esempio: il metodo accetta parametri e restituisce un valore

public class Main {
　　　
　　　　public static void main(String[] args) {
　　　　　　　　int result, n;
　　　　　　　　
　　　　　　　　n = 3;
　　　　　　　　result = square(n);
　　　　　　　　System.out.println("Il quadrato di 3 è: " + result);
　　　　　　　　
　　　　　　　　n = 4;
　　　　　　　　result = square(n);　
　　　　　　　　System.out.println("4的平方是: " + result);
　　　　}
　　　　// 方法
　　　　static int square(int i) {
　　　　　　　　return i * i;
　　　　}
}

Output:

3的平方是: 9
4的平方是: 16

在此，square(）方法接受一个参数i并返回i的平方。返回的值存储在变量result中。

如果我们传递任何其他数据类型，而不是int类型的值，则编译器将引发错误。这是因为Java是一种强类型语言。

　在方法调用期间传递给getSquare()方法的参数n称为实际参数。

result = getSquare(n);

　方法定义接受的参数称为形式参数。形式参数的类型必须显式类型化。

public static int square(int i) {...}

我们还可以使用逗号将多个参数传递给Java方法。例如，

public class Main {
　　　　//方法定义
　　　　public static int getIntegerSum (int i, int j) {
　　　　　　　　return i + j;
　　　　}
　　　　// 方法定义
　　　　public static int multiplyInteger (int x, int y) {
　　　　　　　　return x * y;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//调用方法
　　　　　　　　System.out.println("10 + 20 = " + getIntegerSum(10, 20));
　　　　　　　　System.out.println("20 x 40 = " + multiplyInteger(20, 40));
　　　　}
}

Output:

10 + 20 = 30
20 x 40 = 800

注意： 实际参数和形式参数的数据类型应匹配，即第一个实际参数的数据类型应与第一个形式参数的数据类型相匹配。同样，第二个实际参数的类型必须与第二个形式参数的类型相匹配，以此类推。

使用方法的优点是什么？

1.主要优点是代码可重用性。我们可以编写一次方法，并多次使用它。我们不必每次都重写整个代码。可以将其视为“一次编写，多次重用。例如，

public class Main {
　　　　//方法定义
　　　　private static int getSquare(int x){
　　　　　　　　return x * x;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　for (int i = 1; i <= 5; i++) {
　　　　　　　　　　　　//Chiamata del metodo
　　　　　　　　　　　　int result = getSquare(i);
　　　　　　　　　　　　System.out.println("" + i + " del quadrato è: " + result);
　　　　　　　　}
　　　　}
}

Output:

Il quadrato di 1 è: 1
Il quadrato di 2 è: 4
Il quadrato di 3 è: 9
Il quadrato di 4 è: 16
Il quadrato di 5 è: 25

　Nel programma sopra, abbiamo creato un metodo chiamato getSquare() per calcolare il quadrato di un numero. Qui, calcoliamo il quadrato di numeri inferiori a 6 con lo stesso metodo.

　Dunque, usiamo ripetutamente lo stesso metodo

Il metodo 2 rende il codicePiù leggibile,Più facile da debuggareAd esempio, il metodo getSquare() è molto leggibile, quindi possiamo sapere che questo metodo calcolerà il quadrato di un numero.