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.")
        }
    }
}

Variables primitives i de referència

Les variables en Java es classifiquen en "primitives" i "de referència".

Les variables primitives són aquelles de tipus int, float, boolean, char, ... Per exemple:

int unNumero;
float unAltreNumero;

// les variables 'unNumero' i 'unAltreNumero' són variables primitives.

Les variables de referència són aquelles les quals el seu tipus és un array o una classe. Per exemple:

int[] unArrayDeNumeros;
Alumne alumne;
Alumne[] alumnes;

// les variables 'unArrayDeNumeros', 'alumne' i 'alumnes' són variables de referència.

Les variables prmitives emmagatzemen el valor que se les assigna, mentre que les variables de referència emmgatzemen una referència a l'objecte o array que se les assigna.

int unNumero = 99;

int[] tresNumeros = new int[3];

class Alumne {
    int edat;
    float nota;
}

Alumne alumne = new Alumne();

La diferència entre emmagatzemar el valor o la referència s'observa quan assignem el valor d'una variable a un altra, de forma directa amb =, o quan fem el pas de paràmetres a mètodes.

Vejem què passa quan assignem una variable primitiva a una altra:

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

int numA = 98 + 1;

int numB = numA;

numB = 55;

System.out.println(numA);       // 99
System.out.println(numB);       // 55

Vejem què passa quan assignem una variable de referència a una altra:

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

class Alumne {
    float nota;
}

Alumne aluA = new Alumne();
aluA.nota = 10;

Alumne aluB = aluA;
aluB.nota = 5;

System.out.println(aluA.nota);
System.out.println(aluB.nota);

Vejem què passa quan passem per paràmetre una variable primitiva:

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

class Professor {
    void aprovar(float parametreNota) {
        parametreNota = 5;
    }
}

float nota = 0;
Professor unProfessor = new Professor();

unProfessor.aprovar(nota);

System.out.println(nota);  // 0

Vejem què passa quan passem per paràmetre una variable de referència:

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5

class Alumne {
    float nota;
}

class Professor {
    void aprovar(Alumne parametreAlumne) {
        parametreAlumne.nota = 5;
    }
}

Alumne unAlumne = new Alumne();
Professor unProfessor = new Professor();

unProfessor.aprovar(unAlumne);

System.out.println(unAlumne.nota);  // 5