Java Metot Parametreleri: Argümanlar, Değere Göre Geçiş ve Geri Dönüş

Parametreler Bir Metodun Girdi Almasını Sağlar

Her zaman aynı şeyi yapan bir metot sınırlıdır. Parametreler, aynı metodun her çağrıldığında farklı değerler üzerinde çalışabilmesi için metodun parantezleri içinde bildirdiğin girdilerdir.

Her parametreyi bir tip ve bir adla listelersin. Metot gövdesi içinde bir parametre, çağıranın geçirdiği değeri hâlihazırda tutan sıradan bir yerel değişken gibi davranır.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name parametredir. "Sam" ve "Alex" ise argümanlardır - çağrıda sağlanan somut değerler. Tek bir metot tanımı, iki farklı çıktı.

Parametreler ile Argümanlar

Bu iki kelime gevşek bir şekilde kullanılır, ama ayrımı net tutmaya değer:

• Bir parametre bildirimdeki yer tutucudur: String name.
• Bir argüman gerçekten geçirdiğin değerdir: "Sam".

Yani void greet(String name) bir parametre bildirir ve greet("Sam") bir argüman geçirir. Birisi "bu metot iki parametre alır" dediğinde bildirimi kasteder; "iki argüman geçirdim" dediğinde ise çağrıyı kasteder.

Çoklu Parametreler

Parametreleri virgülle ayır ve her birine kendi tipini ver - bir değişken bildiriminde yapabileceğin gibi iki parametre arasında bir tipi paylaştıramazsın:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Argümanlar parametrelere kesinlikle konuma göre eşlenir, ada göre değil. describe("Sam", 30, true) çalışır çünkü sıralama (String name, int age, boolean active) ile uyuşur. Uyumlu tiplere sahip iki argümanın yerini değiştirirsen derleme hatası değil, sessiz bir mantık hatası alırsın - bu yüzden sıralama önemlidir.

Yaygın bir hata int add(int a, b) yazmaktır. Her parametrenin kendi tipi olmalıdır: int add(int a, int b).

Bir Değer Döndürme

Parametreler verinin içeri aktığı yoldur; geri dönüş değeri ise bir sonucun dışarı aktığı yoldur. Metot adından önce dönüş tipini bildir ve çağırana bir değer geri vermek için return kullan:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 kayan noktalı bölmeyi zorlar
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Dönüş tipi (double) gerçekte return ettiğin şeyle uyuşmalıdır. void olarak bildirilen bir metot hiçbir şey döndürmez - yine de erken çıkmak için çıplak bir return; kullanabilir, ama bir değer döndüremez. return çalıştığı anda metot biter ve denetim çağrı yerine geri sıçrar.

Java Değere Göre Geçiş Yapar

Bu başta neredeyse herkesi yanıltır. Bir argüman geçirdiğinde Java değeri parametreye kopyalar. İlkel tipler için bu, metodun kendi kopyasını alması demektir - parametreyi değiştirmek çağıranın değişkenine asla dokunmaz:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // yalnızca bu yerel kopyayı değiştirir
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // hâlâ 5
    }
}

x değeri 5 olarak kalır. Metot sayının orijinalini değil, kendi kopyasını değiştirdi.

Nesneleri Geçirmek: Yine Değere Göre, Ama Referansa Dikkat

Nesneler bir istisna gibi görünür, ama değildir. Kopyalanan şey referanstır (nesneyi gösteren ok), nesnenin kendisi değil. Bu yüzden metot aynı nesneyi gösterir ve onu değiştirebilir:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // paylaşılan nesneyi değiştirir - çağıran tarafından görülür
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // yalnızca yerel kopyayı yeniden atar - GÖRÜNMEZ
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // hâlâ [a, b, new] - yeniden atama dışarı sızmadı
    }
}

İki farklı sonuç, tek bir kural. addItem referansı izler ve gerçek listeyi değiştirir, bu yüzden çağıran new öğesinin eklendiğini görür. replace, parametreyi tamamen yeni bir listeye yeniden atar - ama bu yalnızca referansın yerel kopyasını yeniden yönlendirir, bu yüzden çağıranın list değişkeni dokunulmamış kalır. Çıkarım: bir parametre aracılığıyla bir nesneyi değiştirebilirsin, ama çağıranın değişkenini asla yeni bir yere işaret ettiremezsin.

Sırada: Metot Aşırı Yükleme

Artık bir metoda ihtiyaç duyduğu girdileri tam olarak nasıl vereceğini biliyorsun. Peki ya tek bir metot adının farklı parametre kümelerini kabul etmesini istersen - örneğin print(int) ve print(String)? Bu metot aşırı yüklemedir ve sıradaki sayfanın konusudur.