Mètodes
A més a més de variables, els objectes també poden tenir mètodes.
Els mètodes, també anomenats funcions, són blocs de codi als quals els hi posem un nom.
Ens permeten executar aquest codi des d'altres parts del programa, invocant-los pel seu nom.
Quan s'invoca un mètode, el programa salta al bloc de codi d'aquest mètode, i després retorna al lloc on
s'havia invocat. Veiem un exemple:
class Alumne {
String nom;
void saludar(){
System.out.println("Hola");
System.out.println("Que tal?");
}
}
public class Main {
public static void main(String[] args) {
Alumne unAlumne = new Alumne();
System.out.println("Ara farem una salutacio");
unAlumne.saludar();
System.out.println("Adeeeu");
}
}
El següent programa imprimirà:
Ara farem una salutacio
Hola
Que tal?
Adeeeu
Quan hem invocat al mètode saludar() de l'objecte unAlumne, el fluxe d'execució ha saltat al bloc de codi
d'aquest mètode, i en finalitzar a tornat al lloc des d'on s'havia invocat:
Accés als camps de l'objecte
Els mètodes d'un objecte poden accedir als camps d'aquest objecte:
class Alumne {
String nom;
void saludar(){
System.out.println("Hola, em dic " + nom);
}
}
public class Main {
public static void main(String[] args) {
Alumne unAlumne = new Alumne();
unAlumne.nom = "Joan";
unAlumne.saludar();
Alumne unAltreAlumne = new Alumne();
unAltreAlumne.nom = "Anna";
unAltreAlumne.saludar();
}
}
Hola, em dic Joan
Hola, em dic Anna
Paràmetres i valor de retorn
Quan s'invoca un mètode es possible passar-li dades. El mètode ha de definir quins tipus de dades ha de rebre,
i quan s'invoca el mètode se li han de passar obligatòriament dades d'aquests tipus.
Un mètode també pot retornar dades al punt des d'on s'ha invocat. Les dades
que a un mètode s'anomenen paràmetres, i
les que retorna s'anomenen valor de retorn.
Quan definim un mètode és necessari, doncs, especificar els seus paràmetres. És a dir,
els tipus de les dades que ha de rebre i donar un identificador a cadascuna d'aquestes dades.
De la mateixa forma caldrà especificar el tipus de dada que retorna el mètode.
Quan definim un mètode hem d'indicar en primer lloc el tipus de dada que retorna. A continuació el nom del mètode, i
després la llista de paràmetres entre parèntesis (). Després ja ve el bloc d'instruccions del mètode entre claus {}
TipusDelValorDeRetorn nomDelMetode(TipusDelParametre1 identificadorDelParametre1, ...) {
// bloc d'instruccions
}
Per exemple anem a definir un mètode al qual li passem un número i un total, i ens retorna el percentatge que
representa aquest número del total:
class Calculadora {
float calculaPercentatge(int unitats, int total) {
return unitats*100f/total;
}
}
La definició d'aquest mètode indica que quan s'invoqui, se li han de passar dos números int.
Les dues variables (unitats i total) que hem definit entre els parèntesis, tindràn el
valor que se li passi quan s'invoqui el mètode. També s'indica que el mètode retornarà un valor de tipus float.
Podem invocar aquest mètode de la següent manera:
class Calculadora {
float calculaPercentatge(int unitats, int total) {
return unitats*100f/total;
}
}
public class Main {
public static void main(String[] args){
Calculadora calculadora = new Calculadora();
System.out.println( calculadora.calculaPercentatge(10, 20) );
System.out.println( calculadora.calculaPercentatge(15, 20) );
}
}
A la primera invocació del mètode el paràmetre unitats rep el valor 10, i el paràmetre total
rep el valor 20. El mètode retorna el valor 50.0, i aquest valor és el que es passa al mètode println
per que l'imprimeixi.
A la segona invocació del mètode el paràmetre unitats rep el valor 15, i el paràmetre total
rep el valor 20. El mètode retorna el valor 75.0, i aquest valor és el que es passa al mètode println
per que l'imprimeixi.
En aquest codi hem passat el valor retornat pel mètode calculaPercentatge() directament al mètode println().
També es pot emmagatzemar el valor retornat per un mètode en una variable, per a ser utilitzat més endavant.
class Calculadora {
float calculaPercentatge(int unitats, int total) {
return unitats*100f/total;
}
}
public class Main {
public static void main(String[] args){
Calculadora calculadora = new Calculadora();
float percentatge = calculadora.calculaPercentatge(10, 20);
if (percentatge > 50) {
System.out.println("El percentatge " + percentatge + " es majoria.")
}
}
}
Es a dir, quan finalitzi un mètode, el seu valor de retorn serà utilitzat allà on s'ha invocat el mètode:
class Calculadora {
float calculaPercentatge(int unitats, int total) {
return unitats*100f/total;
}
}
public class Main {
public static void main(String[] args){
Calculadora calculadora = new Calculadora();
if (calculadora.calculaPercentatge(10, 20) < 10) {
System.out.println("El percentatge es molt baix.")
}
}
}
void
També es possible que un mètode no retorni cap valor, aleshores especificarem void com a tipus de retorn a la seva
declaració:
class Calculadora {
float resultat;
void calculaPercentatge(int unitats, int total){
resultat = unitats*100f/total;
}
}
public class Main {
public static void main(String[] args){
Calculadora calculadora = new Calculadora();
calculadora.calculaPercentatge(10, 20);
if (calculadora.resultat < 10) {
System.out.println("El percentatge es molt baix.")
}
}
}