...
← Blog Lecții programare java

Metode în Java: funcții, parametri, return și overloading

Sigla Java, ilustrație pentru lecția despre funcții și metode în Java

Metodele în Java (numite în alte limbaje funcții) sunt blocuri de cod cu un nume, care fac o singură sarcină și pot fi apelate de oricâte ori. O metodă primește date prin parametri, le prelucrează și poate întoarce un rezultat cu return, de exemplu static double medie(int[] note). În Java, orice funcție este o metodă, pentru că trăiește mereu într-o clasă.

În lecția asta vezi cum se scrie o metodă bucată cu bucată, diferența dintre void și metodele care întorc valori, ce sunt parametrii și argumentele, supraîncărcarea (overloading), ce se întâmplă cu variabilele trimise unei metode și cum împarți un program în metode mici.

Ce sunt metodele în Java?

O metodă este un bloc de cod cu nume care execută o sarcină anume, iar o funcție este același concept în limbajele unde codul poate exista și în afara claselor. În Java, cele două cuvinte se folosesc ca sinonime, dar termenul corect e „metodă”.

Ai folosit deja metode fără să le scrii: System.out.println(), scanner.nextInt(), Math.max(), Arrays.sort(). Le apelezi după nume, le dai datele în paranteze și nu te interesează cum funcționează pe dinăuntru. Exact asta vei face acum cu metodele tale.

Iată cea mai simplă metodă posibilă și apelul ei din main:

public class Main {

    static void afiseazaLinie() {
        System.out.println("------------------------");
    }

    public static void main(String[] args) {
        afiseazaLinie();
        System.out.println("Raport vânzări");
        afiseazaLinie();
    }
}

Metoda afiseazaLinie nu rulează singură. Codul ei se execută doar când e apelată, iar aici e apelată de două ori. Dacă mâine vrei linia din egaluri în loc de liniuțe, schimbi un singur loc.

De ce ai nevoie de metode?

Metodele îți permit să scrii o logică o singură dată și s-o folosești peste tot, să dai nume pașilor unui program și să testezi fiecare bucată separat. Fără ele, orice program trece repede de câteva sute de rânduri în main.

Gândește-te la o aplicație de catalog care, pentru fiecare elev, calculează media, stabilește calificativul și afișează situația. Fără metode, calculul mediei e copiat de 30 de ori. Dacă găsești o greșeală în el, o repari în 30 de locuri și sigur uiți unul. Cu o metodă medie(note), repari o dată.

Din ce e formată o metodă?

Orice metodă are un antet (semnătura) și un corp între acolade. Antetul spune cine poate apela metoda, ce întoarce, cum se numește și ce primește.

static double pretCuReducere(double pret, int procent) {
    return pret - pret * procent / 100;
}
ParteÎn exempluCe înseamnă
Modificatoristatic (uneori și public)cum poate fi apelată metoda; static o leagă de clasă
Tipul returnatdoublece fel de valoare întoarce; void dacă nu întoarce nimic
NumelepretCuReducereun verb sau o acțiune, în camelCase
Parametrii(double pret, int procent)datele de intrare, fiecare cu tip și nume
Corpul{ return ...; }instrucțiunile care se execută la apel

Apelul pretCuReducere(250, 20) întoarce 200.0: un produs de 250 de lei, cu 20% reducere. Deocamdată scrie static la toate metodele pe care le apelezi din main. De ce e nevoie de el afli la lecția despre static vs non-static în Java; pe scurt, main e statică și poate apela direct doar alte metode statice.

Care e diferența dintre void și o metodă care întoarce o valoare?

O metodă void face ceva (afișează, salvează, modifică) și nu întoarce nimic. O metodă cu tip returnat calculează ceva și îți dă rezultatul înapoi prin return, ca să-l folosești mai departe.

static boolean estePar(int numar) {
    return numar % 2 == 0;
}

static double medie(int[] note) {
    int suma = 0;
    for (int nota : note) {
        suma += nota;
    }
    return (double) suma / note.length;
}

Rezultatul unei metode cu return se poate pune într-o variabilă (double m = medie(note);), într-o condiție (if (estePar(x))) sau direct ca argument pentru altă metodă. Instrucțiunea return are două efecte: întoarce valoarea și oprește imediat metoda. Tot ce scrii după ea, pe aceeași ramură, nu se mai execută.

O metodă poate avea mai multe return-uri, câte unul pe fiecare ramură:

static String calificativ(double media) {
    if (media >= 9) {
        return "Foarte bine";
    }
    if (media >= 7) {
        return "Bine";
    }
    if (media >= 5) {
        return "Suficient";
    }
    return "Insuficient";
}

Ultimul return e obligatoriu. Dacă există vreo cale prin metodă care nu ajunge la un return, compilatorul se oprește cu „missing return statement”.

Ce sunt parametrii și argumentele?

Un parametru este variabila declarată în antetul metodei, iar argumentul este valoarea concretă pe care o trimiți la apel. În pretCuReducere(double pret, int procent), pret și procent sunt parametri; în apelul pretCuReducere(250, 20), 250 și 20 sunt argumente.

Argumentele trebuie să se potrivească cu parametrii ca număr, ordine și tip. pretCuReducere("250", 20) nu compilează, pentru că un text nu poate deveni double. Ordinea contează și ea: pretCuReducere(20, 250) compilează, dar calculează o reducere de 250% la un produs de 20 de lei. Compilatorul nu poate ghici ce ai vrut; de aceea parametrii cu nume clare sunt atât de importanți.

Ce este supraîncărcarea metodelor (overloading)?

Supraîncărcarea înseamnă să ai mai multe metode cu același nume, dar cu parametri diferiți ca număr sau tip. Java alege singur varianta potrivită după argumentele de la apel.

static int arie(int latura) {
    return latura * latura;               // pătrat
}

static int arie(int lungime, int latime) {
    return lungime * latime;              // dreptunghi
}

static double arie(double raza) {
    return Math.PI * raza * raza;         // cerc
}

arie(5) dă 25, arie(4, 6) dă 24, iar arie(1.0) dă 3.141592653589793. Ai folosit supraîncărcarea fără să știi: System.out.println are câte o variantă pentru int, double, String și celelalte tipuri. Atenție, doar tipul returnat diferit nu ajunge; două metode arie(int) care diferă doar prin ce întorc nu compilează. Diferența față de suprascriere (overriding) e explicată în lecția despre overloading vs overriding.

Ce se întâmplă cu variabilele trimise unei metode?

Java trimite mereu o copie a valorii (pass by value). Pentru tipurile primitive, metoda primește o copie a numărului, deci originalul nu se schimbă. Pentru array-uri și obiecte, copia e a referinței, deci metoda poate modifica conținutul obiectului original.

static void dubleaza(int numar) {
    numar = numar * 2;
}

static void dubleazaToate(int[] valori) {
    for (int i = 0; i < valori.length; i++) {
        valori[i] *= 2;
    }
}

// în main:
int x = 10;
dubleaza(x);
System.out.println(x);                        // 10, neschimbat

int[] v = {1, 2, 3};
dubleazaToate(v);
System.out.println(Arrays.toString(v));       // [2, 4, 6], modificat

Dacă vrei ca o metodă să schimbe un număr, n-o face să-l modifice pe loc; fă-o să întoarcă valoarea nouă și atribuie-o: x = dubleaza(x);, cu metoda schimbată să întoarcă int. Parametrii și variabilele declarate în metodă sunt locale: există doar cât rulează metoda și nu se văd din main.

Cum împarți un program în metode?

Fiecare metodă face un singur lucru, are un nume care spune ce face, iar main doar le apelează în ordine. Un main bine scris se citește ca un rezumat al programului.

public static void main(String[] args) {
    int[] note = {9, 8, 10, 7};

    double m = medie(note);
    afiseazaLinie();
    System.out.println("Media: " + m + " (" + calificativ(m) + ")");
    afiseazaLinie();
}
// Media: 8.5 (Bine)

Câteva reguli care te ajută să alegi bine:

  1. Numește metoda după ce face, cu un verb: calculeazaTotal, afiseazaMeniu, esteEmailValid.
  2. Când nu poți descrie metoda într-o propoziție fără „și”, probabil face prea multe și trebuie împărțită.
  3. Separă calculele de afișare: medie întoarce un număr, iar cine o apelează decide ce face cu el. Așa o poți refolosi și într-o aplicație web, unde nu există consolă.
  4. Ține metodele scurte. Dacă una nu încape pe ecran, caută în ea o bucată care merită propriul nume.

Documentația oficială despre definirea metodelor e în tutorialul Oracle despre metode.

Ce greșeli fac începătorii cu metodele?

Erorile cu metode sunt de obicei prinse de compilator, dar mesajele lui nu sunt întotdeauna evidente. Iată-le pe cele mai frecvente, cu mesajul exact.

„non-static method cannot be referenced from a static context”

Ai scris o metodă fără static și o apelezi din main. Pentru moment, adaugă static în antet. Explicația completă vine odată cu clasele și obiectele.

„missing return statement”

Metoda declară un tip returnat, dar există o cale prin cod fără return, de obicei un if fără else. Asigură-te că fiecare ramură întoarce ceva, sau pune un return la final.

Rezultatul ignorat

medie(note); pe un rând separat compilează, dar rezultatul se pierde. O metodă care întoarce o valoare trebuie folosită: double m = medie(note);. E o greșeală care nu dă nicio eroare și te face să crezi că metoda nu funcționează.

Tot programul în main

Nu e o eroare de compilare, dar e cea mai răspândită problemă de stil la început. Dacă vezi același bloc de cod copiat de două ori, e momentul să faci din el o metodă.

Exercițiu: calculatorul de factură

Scrie trei metode: subtotal(double[] preturi, int[] cantitati), care întoarce suma produselor înmulțite cu cantitățile; aplicaReducere(double suma, int procent); și afiseazaFactura(double subtotal, double total), de tip void, care afișează frumos cele două sume. Din main doar le apelezi, în ordine.

Apoi adaugă o variantă supraîncărcată, aplicaReducere(double suma), fără procent, care aplică o reducere implicită de 5%. Verifică că ambele variante pot fi apelate din același program.

Întrebări frecvente

Care e diferența dintre funcție și metodă în Java?

În Java, practic nu există diferență: orice funcție e o metodă, pentru că trebuie să fie definită într-o clasă. Termenul „funcție” vine din alte limbaje, precum C sau Python, unde codul poate exista și în afara claselor.

Poate o metodă să întoarcă mai multe valori?

Nu direct; return întoarce o singură valoare. Poți însă întoarce un array, o listă sau un obiect care grupează mai multe valori, de exemplu un obiect cu suma, media și maximul.

Este obligatoriu ca o metodă să aibă parametri?

Nu. O metodă fără parametri are parantezele goale, ca afiseazaLinie(). Parantezele rămân obligatorii atât la declarare, cât și la apel.

Ce înseamnă void?

void înseamnă că metoda nu întoarce nicio valoare. Poți folosi totuși return; fără valoare, ca să ieși mai devreme din ea.

Poate o metodă să se apeleze pe ea însăși?

Da, iar asta se numește recursivitate. E utilă pentru probleme care se împart în versiuni mai mici ale aceleiași probleme, cum e factorialul, și are nevoie obligatoriu de un caz de oprire. E subiectul lecției următoare.

Primul pas: scoate o metodă din main

Deschide un program scris la lecțiile anterioare, de exemplu cel cu vânzările săptămânii, și mută fiecare calcul (total, medie, maxim) într-o metodă separată. La final, main ar trebui să aibă doar câteva rânduri care se citesc ca o listă de pași. E exercițiul care te pregătește cel mai bine pentru clase și obiecte.

Metodele, tablourile și algoritmii de căutare și sortare sunt în modulul intermediar din cursul de Java; primele 15 lecții, cu fundamentele limbajului, sunt gratuite. Scrii codul în browser, exercițiile se verifică automat, iar Profu’, tutorele AI din lecții, îți dă indicii când compilatorul nu e de acord cu tine. Dacă vrei să vezi drumul complet, de la primele metode până la un job, uită-te la traseul de Java Developer.

Lecția anterioară: ArrayList în Java. Lecția următoare: recursivitatea în Java.

Logo Curs Java Interactiv · 15 lecții gratuite

Curs Java

Programare Java pentru începători: de la sintaxă la OOP și colecții

Începe gratuit

Citește și

Primul tău program e la 5 minute distanță.

Creează-ți contul gratuit și începe primele 15 lecții. Fără card, fără instalări.

Începe gratuit