JAVA - Metodi - Developer MapoDesign

Cosa sono i metodi?

All’interno della programmazione, in questo caso JAVA, utilizziamo gruppi di istruzioni per poterli richiamare più volte all’interno del codice e mantenere una buona visibilità e ordine. In questo modo non abbiamo bisogno di riscriverlo più volte all’interno del programma, evitando così in caso di modifiche, di andare a modificare tutte le volte in cui è stato inserito lo stesso codice.

A seconda del linguaggio di programmazione, questi blocchi prendono nomi diversi, in JAVA vengono chiamati metodi.

Sintassi di un metodo

[public|protected|private] [static] [final] Tipo
	identificatore([Tipo1 parametro1, Tipo2 parametro2, ..., TipoN parametroN])
	[throws Eccezione1, Eccezzione2, ...] {
		// blocco di codice appartenente al metodo
	return varTipo;
}

Come da consuetudine, tutto quello che trovi inserito nelle parentesi quadre è opzionale. Un metodo può essere di vari tipi di visibilità. Successivamente si definisce se è static e/o final.

Il tipo (void, double, int, String ecc.), l’identificatore è il nome del metodo, da inserire con nomi minuscoli e nel caso di nomi con più parole, le successive in maiuscolo come per le variabili (camelcase).

Poi se ci fossero parametri in ingresso, all’interno delle parentesi tonde se ne definisce il tipo (double, int, String ecc.) ed il nome della variabile che sarà richiamato nel metodo.

Dopo le parentesi potrebbero essere definite delle eccezioni.

All’interno delle parentesi graffe si inserisce il gruppo di istruzioni da eseguire, poi alla fine se il metodo non è di tipo void (vuoto), si inserisce la variabile di ritorno.

public double areaParallelogramma(double base, double altezza) {
	double a = base * altezza;
	return a;
}

In questo caso per creare l’area avremo bisogno di due parametri in entrata: base e altezza, mentre il valore di ritorno sarà ‘a’ per l’area.

Come richiamo un metodo in JAVA?

double areaCalcolata;
areaCalcolata = areaParallelogramma(7.0, 6.0);

Per continuare l’esempio di prima, avremo bisogno di richiamare all’interno del codice il metodo. Prima in questo caso creiamo una variabile che riceverà il valore restituito dal metodo, successivamente richiamiamo il metodo passandogli i due parametri di base e altezza, all’interno della parentesi e divisi da virgola.

Return

public double areaParallelogramma(double base, double altezza) {
	if(base == 0.0 || altezza == 0.0)
		return 0.0; // questo return causa l'uscita dal metodo
	double a = base * altezza;
	return a;
}

Da notare una particolarità del return che si comporta in questo caso come il break, uscendo dal metodo nel caso il valore di uno dei due parametri sia 0.

Le eccezioni

In questo caso le eccezioni attraverso il throws vengono gestite richiamando i metodi specificati subito dopo per gestire eventuali errori. Un esempio potrebbe essere quello nel caso in cui un parametro sia inserito al negativo.

public double areaParallelogramma(double base, double altezza)
		throws IllegalArgumentException {
	if(base < 0)
		throw new IllegalArgumentException("base negativa");
	if(altezza < 0)
		throw new IllegalArgumentException("altezza negativa");
	if(base == 0.0 || altezza == 0.0)
		return 0.0;
	double a = base * altezza;
	return a;
}

Overloading dei metodi

É possibile in certi casi avere un diverso numero di parametri in ingresso, ad esempio se per un metodo ci servissero tre parametri o due.

public double areaParallelogramma(double c1, double c2, double alfa)
		throws IllegalArgumentException {
	if(c1 < 0)
		throw new IllegalArgumentException("c1 negativa");
	if(c2 < 0)
		throw new IllegalArgumentException("c2 negativa");
	if(c1 == 0.0 || c2 == 0.0)
		return 0.0;
	double a = c1 * c2 * Math.sin(alpha);
	return a;
}

Sarà il compilatore a decidere quale metodo utilizzare, in base alla chiamata che riceve.

// chiama il primo
areaParallelogramma(5.0, 4.0);
// chiama il secondo
areaParallelogramma(5.0, 4.0, 0.5);
// errore in fase di compilazione:
// non esiste un metodo che prende solo un argomento
areaParallelogramma(5.0);

Varargs

Ci sono però casi in cui l’utilizzo dell’Overloading può essere semplificato attraverso il meccanismo di varargs che ci consente di prendere in ingresso da 0 a N parametri. L’esempio potrebbe essere quello di un prodotto che può avere più di una descrizione.

Utilizzando i tre puntini sospensivi o ellipsis informiamo il compilatore che potrà trovare un numero variabile di parametri, che inserirà in list, come fosse un array.

public class VarargsTest {
	public void testVarargs(String... list) {
		System.out.println("Metodo 1");
		for (String tmp:list)
		{
			System.out.println("#" + tmp);
		}
	}
	public static void main(String[] args)
	{
		System.out.println("Test varargs");
		VarargsTest va=new VarargsTest();
		va.testVarargs("do","re","mi","fa","sol","la","si");
		va.testVarargs("1","2","3","4");
	}
}

Test varargs
#do
#re
#mi
#fa
#sol
#la
#si
#1
#2
#3
#4

JAVA – Metodi