Metotlar: parametre, return, scope, overloading, Math ve Random

Metot (method), bir işi yapan ve ismi olan bir kod bloğudur. Aynı işi on yerde yazmak yerine bir kez yazar, istediğin yerden çağırırsın. Vizede iki taraftan gelir: “bu çağrılar ne basar?” (içten dışa izleme, pass-by-value) ve “şu işi yapan bir metot yaz” (isPrime, sumDigits, max). İkincisinde başlığı doğru yazmak tek başına puan getirir.

Altın kurallar:

1. Başlık şablonu: public static <dönüş tipi> <ad>(<parametreler>).
2. void değilse her yolda return olmalı ve dönen değer tipe uymalı.
3. return metodu anında bitirir.
4. Pass-by-value: metot, çağıranın değişkenini değiştiremez.
5. Overloading = aynı ad, farklı parametre listesi. Dönüş tipi tek başına yetmez.

Metot anatomisi

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

Parametre (parameter) başlıktaki değişkendir: a, b. Argüman (argument) çağrı sırasında verilen gerçek değerdir: average(3, 4) çağrısında 3 ve 4. Argümanların sayısı, sırası ve tipi parametrelerle uyuşmalı.

Bu derste metotlar main ile aynı sınıfa yazılır ve main’den çağrıldığı için static olur. Bir metodu tanımlamak onu çalıştırmaz; sadece çağrıldığında (call) çalışır.

return ve void

public static int twice(int n) { return n * 2; }
public static void greet(String name) { System.out.println("Hi " + name); }
public static int max(int a, int b) {
    if (a > b) return a;
    return b;
}
public static void line(int n, char c) {
    for (int i = 0; i < n; i++) System.out.print(c);
    System.out.println();
}
// main içinde:
System.out.println(twice(4));
greet("Deniz");
int t = twice(twice(3));     // içten dışa: twice(3) = 6, twice(6) = 12
System.out.println(t);
System.out.println(average(3, 4));
System.out.println(max(8, 11) + " " + max(5, 5));
line(5, '=');

8
Hi Deniz
12
3.5
11 5
=====

• Değer döndüren metot bir ifadenin içinde kullanılır: yazdırılır, bir değişkene atanır ya da başka bir çağrıya argüman olur.
• void metot bir iş yapar (yazdırmak gibi) ve hiçbir şey döndürmez. System.out.println(greet("x")) derlenmez.

Derleyicinin yakaladığı return hataları

static int f(int a) { return 2.5; }              // double, int'e sığmaz
static void g() { return 5; }                    // void değer döndüremez
static int h(int a) { if (a > 0) return 1; }     // a <= 0 iken return yok

Ret.java:2: error: incompatible types: possible lossy conversion from double to int
Ret.java:3: error: incompatible types: unexpected return value
Miss.java:2: error: missing return statement

missing return statement hatası şunu söyler: derleyici, koşul false olduğunda metodun ne döndüreceğini bilemiyor. Her olası yolun sonunda bir return olmalı.

Çağrı izleme ve pass-by-value

Bir metot çağrıldığında Java:

1. Argümanları hesaplar.
2. Değerlerini parametrelere kopyalar.
3. Metodun gövdesini çalıştırır.
4. return görünce değeri çağrının yapıldığı yere geri götürür.

public static void change(int x) {
    x = 100;
    System.out.println("inside: " + x);
}
// main içinde:
int a = 3;
change(a);
System.out.println("outside: " + a);

inside: 100
outside: 3

change’e a’nın kendisi değil, değeri (3) gitti. x = 100 sadece metodun kendi kopyasını değiştirdi. Buna pass-by-value denir ve Java’da her şey böyle geçer. (Dizilerde ve nesnelerde bu kuralın ilginç bir sonucu var; 6. ve 13. haftalarda göreceksin.)

Kapsam (scope)

Bir değişken sadece tanımlandığı blok { } içinde yaşar.

• Metodun içinde tanımlanan değişken (local variable) başka metotta görünmez.
• Parametreler de yereldir; metot bitince yok olur.
• for başlığında tanımlanan sayaç döngüden sonra yoktur.

static void a() { int secret = 5; }
static void b() { System.out.println(secret); }

LocalScope.java:3: error: cannot find symbol

Farklı metotlarda aynı isimli değişkenler olabilir (main’de n, counter’da n); birbirleriyle ilgisizdirler.

Method overloading (aşırı yükleme)

Aynı sınıfta aynı isimde birden çok metot olabilir, yeter ki parametre listeleri (sayı, tip ya da sıra) farklı olsun. Metot adı ile parametre tiplerinin birleşimine imza (signature) denir.

static int add(int a, int b) { return a + b; }
static double add(double a, double b) { return a + b; }
static int add(int a, int b, int c) { return a + b + c; }
// main içinde:
System.out.println(add(2, 3));       // int, int
System.out.println(add(2.0, 3));     // double, int → 3 genişler → add(double, double)
System.out.println(add(1, 2, 3));    // üç argüman

5
5.0
6

Seçim kuralı: önce tam eşleşme aranır. Yoksa Java argümanı genişletebileceği en yakın tipe gider (int → long → float → double). Daraltma asla otomatik yapılmaz.

TUZAK · sadece dönüş tipi farklı. static int k(int a) ve static double k(int b) birlikte derlenmez: method k(int) is already defined. Parametre adı ve dönüş tipi imzaya dahil değildir.

Math sınıfı

Math’in metotları static’tir: Math.ad(...) diye çağrılır, import gerekmez.

System.out.println(Math.pow(3, 2));
System.out.println(Math.sqrt(16));
System.out.println(Math.max(4, 9) + " " + Math.min(4, 9));
System.out.println(Math.max(4, 9.0));
System.out.println(Math.abs(-3.5) + " " + Math.abs(-7));
System.out.println(Math.round(3.49) + " " + Math.round(3.5) + " " + Math.round(-2.5));
System.out.println(Math.ceil(2.1) + " " + Math.floor(2.9) + " " + Math.ceil(-2.1));
System.out.println(Math.PI);

9.0
4.0
9 4
9.0
3.5 7
3 4 -2
3.0 2.0 -2.0
3.141592653589793

TUZAK · Math.pow(2, 3) = 8 değil 8.0. Çıktı sorularında double dönen metotların .0 ile basıldığını unutma.

Math.round(-2.5) sonucu -2: “.5 yukarı” kuralı sayı doğrusunda yukarı, yani büyük olana doğru demek.

Rastgele sayılar

İki yol var:

import java.util.Random;
Random rand = new Random();
int die = rand.nextInt(6) + 1;                  // 1..6
int r = rand.nextInt(11) + 10;                  // 10..20
int m = (int) (Math.random() * 100) + 1;        // 1..100

Her ifade bir milyon kez çalıştırılınca görülen en küçük ve en büyük değerler:

1..6 10..20 1..100

Formül: min..max için rand.nextInt(max - min + 1) + min. nextInt(k) 0’dan k-1’e kadar k farklı değer üretir; + min aralığı kaydırır.

Math.random() 0.0 ile 1.0 arasında (1.0 hariç) bir double verir. Çarp, cast et, kaydır. Parantezin yeri kritik: (int) Math.random() * 100 her zaman 0’dır, çünkü cast çarpmadan önce yapılır.

Çözümlü örnek: yazma sorusu nasıl puan toplar

“isPrime yaz” gibi bir soruda kısmi puan şu sırayla gelir:

1. Başlık: public static boolean isPrime(int n). Cevap evet/hayır ise dönüş tipi boolean.
2. Özel durum: if (n < 2) return false;
3. Döngü ve koşul: for (int i = 2; i * i <= n; i++) if (n % i == 0) return false;
4. Döngüden sonra: return true;
5. Kâğıt üstünde bir örnekle test: 9 için i = 2 (kalan 1), i = 3 (kalan 0) → false. Doğru.

TUZAK · return true’yu else’e koymak. if (n % i == 0) return false; else return true; yazarsan döngü ilk turda biter, sadece 2’ye bölünmeyi kontrol etmiş olursun. 9’a “asal” der.

Sık yapılan hatalar

static int f(int x) { return x + 3; }
static int g(int x) { return f(x) * 2; }
// in main:
System.out.println(g(4));

static int mystery(int n) {
    int r = 0;
    for (int i = 1; i <= n; i++) {
        if (i % 2 == 1) r += i;
    }
    return r;
}
// in main:
System.out.println(mystery(6));

static void swap(int a, int b) {
    int t = a; a = b; b = t;
    System.out.println("in swap: " + a + " " + b);
}
// in main:
int x = 5, y = 9;
swap(x, y);
System.out.println("in main: " + x + " " + y);

static int early(int n) {
    if (n > 5) return 1;
    System.out.println("small");
    return 0;
}
// in main:
System.out.println(early(8));
System.out.println(early(2));

static int counter(int n) {
    n++;
    return n;
}
// in main:
int n = 10;
n = counter(n);
counter(n);
System.out.println(n);

static void show(int x)    { System.out.println("int: " + x); }
static void show(double x) { System.out.println("double: " + x); }
static void show(String s) { System.out.println("String: " + s); }
// in main:
show(7 / 2);
show(7 / 2.0);
show("" + 7 / 2);

static void p(double d) { System.out.println("double " + d); }
static void p(long l)   { System.out.println("long " + l); }
// in main:
p(5);
p(5.0f);

System.out.println(Math.pow(2, 3) + Math.max(2, 3));
System.out.println(Math.sqrt(25) + " " + Math.abs(-4) + " " + Math.round(2.5));
System.out.println(Math.ceil(4.1) + " " + Math.floor(4.9) + " " + (int) Math.ceil(4.1));

static int square(int x) { return x * x; }
static int twice(int n)  { return n * 2; }
static int max(int a, int b) { if (a > b) return a; return b; }
// in main:
System.out.println(square(square(2)) + square(3));
System.out.println(max(square(3), twice(5)));