Metode în Java

modificatori TipReturnat nume(Tip1 p1, Tip2 p2) {
    // corp
    return valoare;
}

static int suma(int a, int b) { return a + b; }
static double medie(double... valori) { ... }

Ce face Metode

O metodă este o funcție definită într-o clasă. Antetul conține modificatorii (public, static…), tipul returnat (sau void), numele și lista de parametri cu tipurile lor. Metodele static se apelează pe clasă (Main.suma(2, 3) sau doar suma(2, 3) din aceeași clasă), cele de instanță pe un obiect (elev.medie()).

Java transmite argumentele mereu prin valoare: metoda primește o copie. Pentru primitive, modificarea parametrului nu afectează variabila apelantului. Pentru obiecte se copiază referința, deci metoda poate modifica obiectul, dar nu poate înlocui variabila apelantului cu alt obiect.

Mai multe metode pot avea același nume dacă diferă lista de parametri (supraîncărcare, „overloading”). Ultimul parametru poate fi variabil (varargs): double... valori primește oricâte valori, văzute în metodă ca array.

Parametri

Parametru	Descriere
TipReturnat	Tipul valorii returnate cu return, sau void dacă metoda nu returnează nimic.
parametri	Zero sau mai mulți, fiecare cu tip și nume. Ultimul poate fi varargs (Tip... nume).

Exemple

Exemplul 1: Metode cu parametri și valoare returnată

Metodele mici, cu nume clar, fac main ușor de citit.

public class Main {
    static double aplicaReducere(double pret, int procent) {
        return pret - pret * procent / 100;
    }

    static boolean esteWeekend(int zi) {
        return zi == 6 || zi == 7;
    }

    static void afiseazaPret(String produs, double pret) {
        System.out.printf("%-10s %8.2f lei%n", produs, pret);
    }

    public static void main(String[] args) {
        afiseazaPret("bicicletă", aplicaReducere(1200, 15));
        afiseazaPret("cască", aplicaReducere(180, 0));
        System.out.println("sâmbătă e weekend? " + esteWeekend(6));
    }
}

Rezultat

bicicletă   1020.00 lei
cască        180.00 lei
sâmbătă e weekend? true

Exemplul 2: Supraîncărcare și varargs

Compilatorul alege metoda după tipurile argumentelor. Metoda cu varargs primește oricâte numere, inclusiv zero.

public class Main {
    static String descrie(int n) {
        return "întreg " + n;
    }

    static String descrie(double d) {
        return "real " + d;
    }

    static String descrie(String s) {
        return "text \"" + s + "\"";
    }

    static double medie(double... note) {
        if (note.length == 0) {
            return 0;
        }
        double suma = 0;
        for (double n : note) {
            suma += n;
        }
        return suma / note.length;
    }

    public static void main(String[] args) {
        System.out.println(descrie(7));
        System.out.println(descrie(7.5));
        System.out.println(descrie("șapte"));
        System.out.println(medie(9, 10, 8));
        System.out.println(medie(7.5));
        System.out.println(medie());
    }
}

Rezultat

întreg 7
real 7.5
text "șapte"
9.0
7.5
0.0

Exemplul 3: Transmiterea prin valoare

dubleaza modifică doar copia lui n. adaugaBonus primește o copie a referinței către același array, deci modificarea se vede. inlocuieste schimbă doar copia locală a referinței.

import java.util.Arrays;

public class Main {
    static void dubleaza(int n) {
        n = n * 2;
    }

    static void adaugaBonus(int[] note) {
        for (int i = 0; i < note.length; i++) {
            note[i] = Math.min(10, note[i] + 1);
        }
    }

    static void inlocuieste(int[] note) {
        note = new int[] {0, 0, 0};
    }

    public static void main(String[] args) {
        int x = 5;
        dubleaza(x);
        System.out.println("x = " + x);

        int[] note = {7, 9, 10};
        adaugaBonus(note);
        System.out.println("după bonus: " + Arrays.toString(note));
        inlocuieste(note);
        System.out.println("după înlocuire: " + Arrays.toString(note));
    }
}

Rezultat

x = 5
după bonus: [8, 10, 10]
după înlocuire: [8, 10, 10]

Greșeli frecvente

• Apelarea unei metode de instanță din main (care e static) fără obiect: non-static method ... cannot be referenced from a static context.
• O metodă cu tip returnat care nu are return pe toate ramurile: missing return statement.
• Supraîncărcare doar după tipul returnat (int f() și double f()): nu este permisă.

Comenzi înrudite

• return și void: return încheie metoda și trimite înapoi o valoare; void marchează o metodă care nu returnează nimic.
• static: static leagă un câmp sau o metodă de clasă, nu de un obiect: există o singură copie, accesată prin numele clasei.
• main și structura unui program: Orice program Java pornește din metoda main a unei clase: public static void main(String[] args).
• Clase și obiecte (class): O clasă (cuvântul cheie class) descrie un tip nou: câmpuri pentru date și metode pentru comportament; obiectele sunt instanțele ei.
• Expresii lambda: O lambda este o funcție scurtă, fără nume, scrisă ca parametri -> corp, folosită oriunde se așteaptă o interfață funcțională.