Bölüm 9: Metotlar

Bilgisayar ve Programlamaya Giriş

TanımParametreDönüşKapsamÖrnekler

Sercan KÜLCÜ · Giresun Üniversitesi

Giriş

Öğrenme Çıktıları

Tanımlama

Metot tanımlaması ve çağrısını yazmak.

Veri akışı

Parametre ve dönüş değerini kullanmak.

Kapsam

Yerel değişkenlerin yaşam alanını açıklamak.

Tasarım

Kısa, odaklı ve test edilebilir metotlar kurmak.

Temeller

Fonksiyon Nedir?

Java’da fonksiyonlar sınıf içinde metot olarak tanımlanır.
Belirli bir görevi adlandırır ve tekrar kullanılabilir bir birim oluşturur.
Girdi parametrelerle alınır; sonuç dönüş değeriyle verilir.
Örnek: Math.sqrt(16) → 4.0; nasıl hesapladığını bilmemiz gerekmez.

Temeller

Metot Çalışması

Argümanları değerlendir

Parametrelere kopyala

Gövdeyi çalıştır

Değer döndür

Çağrıya devam et

Her çağrı kendi parametre ve yerel değişkenleriyle çalışır.

Temeller

Metot Tanımı ve Çağrısı

static int topla(int a, int b) {
    int sonuc = a + b;
    return sonuc;
}

int toplam = topla(5, 3);
System.out.println(toplam);

int dönüş tipi; a ve b biçimsel parametrelerdir.
5 ve 3 gerçek argümanlardır.
Dönen değer değişkene atanabilir veya başka ifadede kullanılabilir.

Temeller · Kodu adım adım çalıştır

Kod İzleme: `topla(5, 3)`

main çalışıyor. Sağ taraf önce hesaplanmalı: topla(5, 3) çağrılır.

Yeni çerçeve açılır: argümanlar 5 ve 3, parametreler a ve b’ye kopyalanır.

Yerel değişken sonuc = 5 + 3 = 8; yalnızca topla’nın çerçevesinde yaşar.

return sonuc: 8 çağırana gönderilir, topla’nın çerçevesi kapanır.

Dönen değer çağrının yerine geçer: toplam = 8. a, b, sonuc artık yok.

8 yazılır.

static int topla(int a, int b) {
    int sonuc = a + b;
    return sonuc;
}

// main içinde:
int toplam = topla(5, 3);
System.out.println(toplam);

Temeller · Kodu adım adım çalıştır

Çağrı Yığını: metot metodu çağırınca

main, ortalama(9, 7)’yi çağırır. Yığında şimdilik tek çerçeve var.

ortalama çerçevesi main’in üstüne konur: x = 9, y = 7.

ortalama da bir metot çağırıyor: topla(x, y) → x ve y’nin değerleri (9, 7) gönderilir.

topla en üste: 3 çerçeve. Yalnız en üstteki çalışır.

return 16: topla’nın çerçevesi kapanır (son giren ilk çıkar).

16 çağrı yerine geçer: t = 16. ortalama kaldığı yerden sürer.

return t / 2 → 16 / 2 = 8 (tam sayı bölmesi). ortalama’nın çerçevesi kapanır.

main’e dönüldü: o = 8. x, y, t, a, b hiçbiri artık yok.

8 yazılır. Çerçeveler yığın (stack) gibi: son açılan ilk kapanır.

static int topla(int a, int b) {
    return a + b;
}
static int ortalama(int x, int y) {
    int t = topla(x, y);
    return t / 2;
}
int o = ortalama(9, 7);  // main içinde
System.out.println(o);

Temeller

Metot Tanımlamasının Parçaları

Örneklerde metotlar main ile aynı sınıfta ve static yazılır.

Temeller

`main` Metodunun İmzası ve `static`

`public static void main(String[] args)`
`public`: JVM dışarıdan çağırabilsin
`static`: nesne üretmeden çağrılsın
`void`: değer döndürmez
`main`: JVM’nin aradığı ad
`String[] args`: komut satırı argümanları

void selamla() { }
public static void main(String[] args) {
    selamla();   // hata
}

error: non-static method selamla() cannot be referenced from a static context

static metot sınıfa aittir; nesne olmadan çağrılır. static olmayan metot bir nesneye aittir.
static metot, static olmayan metoda ya da alana doğrudan erişemez; çözüm o metodu da static yapmaktır.
JVM programı başlatırken henüz hiç nesne yoktur; bu yüzden main static olmalıdır.

Dönüş

void Metotlar

static void cizgiCiz(int n) {
    for (int i = 0; i < n; i++)
        System.out.print("-");
    System.out.println();
}
// main içinde:
cizgiCiz(5);           // -----
int x = cizgiCiz(5);   // HATA: void değer vermez

void: metot çağrıya bir değer döndürmez; iş yan etkidir (ekrana yazmak gibi).
Bu yüzden void çağrı bir atamanın ya da ifadenin parçası olamaz.
return; (değersiz) void metottan erken çıkmak için kullanılabilir.

Dönüş

Erken Dönüş

static void yazdirPozitif(int sayi) {
    if (sayi <= 0) return;
    System.out.println(sayi);
}

Özel durumu başta ele almak iç içeliği azaltabilir.
Değer döndüren metotta her yol uyumlu bir değer döndürmelidir.

Dönüş · Kodu adım adım çalıştır

Kod İzleme: `yazdirPozitif(-3)` ve `(7)`

İlk çağrı: argüman −3.

Çerçeve açılır: sayi = −3.

−3 <= 0 → true → return; Metot hemen biter; println’e hiç gelinmez.

main sonraki satırdan sürer: ikinci çağrı, argüman 7.

Yepyeni bir çerçeve: sayi = 7 (önceki çağrının sayi’sı çoktan yok oldu).

7 <= 0 → false → erken dönüş yok, devam.

7 yazılır.

Kapanış süslü parantezine gelindi: void metot burada kendiliğinden döner.

static void yazdirPozitif(int sayi) {
    if (sayi <= 0) return;
    System.out.println(sayi);
}
// main içinde:
yazdirPozitif(-3);
yazdirPozitif(7);

Dönüş

Derleme Hataları: `return` ve Tip

static int yaz(int n) {
    if (n > 0) {
        return 1;
    }
}

error: missing return statement (kapanan } satırında)

static int f() {
    return 2.5;
}

error: incompatible types: possible lossy conversion from double to int

void olmayan metotta her yol return ile bitmelidir; burada if’in false dalı eksik. Çözüm: sona return 0; eklemek.
Değer, dönüş tipine sığmalıdır: return (int) 2.5; derlenir (2 döner) ya da dönüş tipi double yapılır.
void metotta return 1; → error: incompatible types: unexpected return value

Parametreler

Parametre Aktarımı

Java her zaman değer ile aktarır (pass by value).
İlkel tipte değerin kopyası parametreye yazılır: iki ayrı bellek kutusu.
Metot kendi kopyasını değiştirse de çağıranın değişkeni değişmez.
Nesnelerde (ör. dizilerde) referansın kopyası aktarılır.

Parametreler · Kodu adım adım çalıştır

Değer ile Aktarım: `artir(sayi)`

main’de sayi = 5: main çerçevesinde bir kutu.

artir(sayi): gönderilen değişken değil, değeri (5).

Yeni çerçevede ayrı bir kutu: x = 5 (kopya).

x++ → x = 6. Yalnızca artir’ın kutusu değişti; main’deki sayi hâlâ 5.

Metot biter; çerçeve ve içindeki x (6) silinir. Değer geri gönderilmez (void).

5 yazılır. Değiştirmek isteseydik: static int artir(int x) { return x + 1; } ve sayi = artir(sayi);

static void artir(int x) {
    x++;
}
// main içinde:
int sayi = 5;
artir(sayi);
System.out.println(sayi);   // 5

Parametreler · Kodu adım adım çalıştır

Değer ile Aktarım Tuzağı: `swap(x, y)`

main’de x = 3 ve y = 5: main çerçevesinde iki ayrı kutu.

swap(x, y): gönderilen değişkenlerin kendisi değil, değerleri (3 ve 5).

swap’in çerçevesinde iki yeni kutu: a = 3 ve b = 5 (kopyalar). x ve y ile bağlantı yok.

t = a → t = 3: geçici kutu a’nın değerini saklar.

a = b → a = 5. Eski a değeri artık yalnızca t’de.

b = t → b = 3. swap’in kopyaları yer değiştirdi (a = 5, b = 3); ama main’deki x ve y’ye hiç dokunulmadı.

swap bitince çerçevesi (a, b, t) silinir. main’de hâlâ x = 3, y = 5: yalnızca kopyalar takas edildi. Gerçek takas için sonucu döndürmek ya da dizi kullanmak gerekir.

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

Parametreler

Metot Aşırı Yükleme

static int alan(int kenar) {
    return kenar * kenar;
}
static int alan(int en, int boy) {
    return en * boy;
}
// HATA: yalnız dönüş tipi farklı
static double alan(int kenar) { … }

Aynı ad, farklı parametre listesi (sayı, tip veya sıra).
Yalnızca dönüş tipini değiştirmek yetmez: çağrıdan hangisi olduğu anlaşılmaz.
Derleyici çağrıdaki argümanlara bakarak uygun imzayı seçer.
Tanıdık örnek: println(int), println(double), println(String).

Parametreler · Kodu adım adım çalıştır

Kod İzleme: derleyici hangi `alan`’ı seçer?

alan(4): derleyici argümanlara bakar: 1 tane int.

Aynı ada sahip iki metot var; parametre sayısı/tipi uyan alan(int) seçilir. Bu karar program çalışmadan, derlemede verilir.

Çalışma zamanında alan(int) çağrılır: kenar = 4 → return 16.

16 yazılır.

alan(3, 5): 2 int argüman → alan(int, int) seçilir.

en = 3, boy = 5 → return 15.

15 yazılır. alan(2.5) yazılsaydı hiçbir imza uymaz → derleme hatası (double → int otomatik olmaz).

static int alan(int kenar) {
    return kenar * kenar;
}
static int alan(int en, int boy) {
    return en * boy;
}
System.out.println(alan(4));      // main
System.out.println(alan(3, 5));   // main

Parametreler

Değişken Sayıda Argüman (varargs)

static int topla(int... s) {
    int t = 0;
    for (int v : s) t += v;
    return t;
}
topla(1, 2, 3)   // 6
topla()          // 0
topla(new int[]{4, 5})   // 9

int... s: istenen sayıda argüman; metot içinde s bir int[] dizisidir.
Derleyici çağrıdaki değerleri bir diziye paketler; argüman yoksa boş dizi (s.length == 0) olur.
Varargs parametresi listenin en sonunda olmalı ve metotta yalnız bir tane bulunabilir.
Tanıdık örnek: printf(String, Object...).

Parametreler · Kodu adım adım çalıştır

Değişken Sayıda Argüman: `topla(1, 2, 3)`

topla(1, 2, 3): derleyici üç değeri new int[]{1, 2, 3} dizisine paketler.

s bir int[] dizisidir: s = {1, 2, 3}, s.length = 3.

t = 0: toplam için yerel kutu.

Gelişmiş for, 1. tur: v = 1 → t = 0 + 1 = 1.

2. tur: v = 2 → t = 1 + 2 = 3.

3. tur: v = 3 → t = 3 + 3 = 6. Dizide öğe kalmadı.

return t → 6 döner. v döngüyle birlikte kapsam dışında.

6 yazılır. topla çerçevesi (s, t) silindi.

static int topla(int... s) {
    int t = 0;
    for (int v : s) t += v;
    return t;
}
// main içinde:
System.out.println(topla(1, 2, 3));
System.out.println(topla());

Parametreler · Kodu adım adım çalıştır

Boş Çağrı: `topla()`

topla(): hiç argüman yok → derleyici boş dizi (new int[0]) geçirir; null değil.

s boş bir dizi: s.length = 0.

t = 0.

Dizi boş: gövde hiç çalışmaz, t 0 kalır.

return t → 0 döner.

0 yazılır. Boş çağrı hata değildir; sonuç toplamanın etkisiz elemanı olan 0’dır.

static int topla(int... s) {
    int t = 0;
    for (int v : s) t += v;
    return t;
}
// main içinde:
System.out.println(topla(1, 2, 3));
System.out.println(topla());

Kapsam

Yerel Kapsam

Parametreler ve metot içinde bildirilen değişkenler yereldir.
Bir blokta ({ }) bildirilen değişken yalnızca o blok ve iç bloklarda görünür.
Aynı kapsamda aynı adlı iki yerel değişken bildirilemez.
Başka metodun yerel değişkenine erişilemez.

Kapsam · Kodu adım adım çalıştır

Kapsam Örneği: `hesapla(3)`

main, hesapla(3)’ü çağırır.

Metot kapsamı açılır: parametre n = 3.

sonuc metot kapsamında: metodun sonuna kadar görünür.

3 > 0 → true: if bloğuna girilir, yeni bir iç kapsam açılır.

katki = 3 × 2 = 6: yalnızca if bloğunun içinde var.

İç bloktan dış kapsamdaki sonuc’a erişilebilir: sonuc = 0 + 6 = 6.

Blok kapandı: katki yok oldu. Burada katki yazmak derleme hatası olurdu.

return 6: metot kapsamı da kapanır (n ve sonuc silinir).

Dönen 6 println’e argüman olur ve yazılır.

static int hesapla(int n) {
    int sonuc = 0;
    if (n > 0) {
        int katki = n * 2;
        sonuc += katki;
    }
    return sonuc;
}
System.out.println(hesapla(3));  // main

Kapsam

Kapsam: Aynı Adlı Değişken

int x = 1;
if (x > 0) {
    int x = 5;   // hata
}

error: variable x is already defined in method main(String[])

İç blokta dış kapsamdaki yerel değişkenle aynı ad kullanılamaz; yerel değişken yerel değişkeni gölgelemez.
Parametre de yereldir: topla(int a, int b) içinde int a = 3; aynı hatayı verir.
Blok bitince değişken silinir: for (int i …) { } sonrası int i = 7; yazılabilir.
static alanla aynı adlı yerel değişken derlenir; yerel olan görünür, alan değişmez.

Kütüphane

Sık Kullanılan Hazır Metotlar: Math

Çağrı	Sonuç	Dönüş tipi	Not
`Math.abs(-7)`	7	int	mutlak değer (aşırı yüklü: int, long, double…)
`Math.max(3, 9)`	9	int	büyük olanı döndürür
`Math.sqrt(16)`	4.0	double	karekök; sonuç her zaman double
`Math.pow(2, 10)`	1024.0	double	üs; int’e atamak için (int) gerekir
`Math.round(2.5)`	3	long	en yakın tam sayıya yuvarlar

Belgelerde parametre, dönüş tipi ve özel durumlar okunmalı (ör. Math.sqrt(-1) → NaN).

Tasarım

Soyutlama

Metot, çağıran koddan uygulama ayrıntısını saklar.
İyi adlandırılmış metot ne yapıldığını söyler; nasıl yapıldığı gövdede kalır.
Gövde değişse bile imza aynı kaldıkça çağıranlar etkilenmez.

Tasarım

Ayrıştırma

Büyük görev tek sorumluluklu alt görevlere ayrılır.
Her alt görev için girdi, çıktı ve hata davranışı belirlenir.
Üst düzey metot bu görevleri anlamlı sırada birleştirir; okuması içindekiler tablosu gibi olur.

Tasarım

İyi Metot Tasarımı

İlke	Soru
Tek görev	Metot tek cümleyle açıklanabiliyor mu?
Anlamlı ad	Ad sonuç veya eylemi söylüyor mu?
Az parametre	Girdilerin hepsi gerekli mi?
Belirgin sonuç	Dönüş ve yan etkiler açık mı?
Test edilebilirlik	Metot bağımsız örneklerle denenebilir mi?

Örnek

Önce Metot Sözleşmesi

Metot adı yaptığı işi açıkça belirtmelidir.
Parametrelerin geçerli değer aralığı tanımlanmalıdır.
Dönüş değerinin anlamı ve hata davranışı bilinmelidir.

// Görev : sayının onluk basamak sayısını döndürür.
// Girdi : herhangi bir int (negatif de olabilir).
// Çıktı : 1..10; 0 için 1, -507 için 3.
static int basamakSayisi(int sayi) { … }

Örnek

Tek / Çift

static boolean ciftMi(int sayi) {
    return sayi % 2 == 0;
}

boolean sonuç kararlarda doğrudan kullanılabilir.
Metot ekrana yazmak yerine sonucu döndürür.

Örnekler · Kodu adım adım çalıştır

Kod İzleme: `ciftMi(7)`

if koşulunu bulmak için önce ciftMi(7) çağrılır.

Çerçeve açılır: sayi = 7.

7 % 2 = 1 → 1 == 0 → false. return false.

Dönüş değeri çağrının yerine geçer: if (false) → then dalı atlanır.

else dalı: tek yazılır. Metot yalnızca hesapladı; yazma kararı çağırana ait.

static boolean ciftMi(int sayi) {
    return sayi % 2 == 0;
}
// main içinde:
if (ciftMi(7)) System.out.println("çift");
else System.out.println("tek");

Örnek

Basamak Sayısı

static int basamakSayisi(int sayi) {
    long kalan = Math.abs((long) sayi);
    if (kalan == 0) return 1;
    int adet = 0;
    while (kalan > 0) {
        adet++;
        kalan /= 10;
    }
    return adet;
}
System.out.println(basamakSayisi(-507));

(long) önce dönüştürür: Math.abs(-2147483648) int’te yine negatif kalırdı.
0 için erken dönüş: 1 basamak.
Sonuç ekrana yazılmaz, döndürülür; çağıran istediği gibi kullanır.

Örnekler · Kodu adım adım çalıştır

Kod İzleme: `basamakSayisi(-507)`

println’in argümanı için önce basamakSayisi(-507) çağrılır.

Çerçeve açılır: sayi = −507.

Math.abs((long) −507) → kalan = 507. (Hazır metot da bir çağrıdır: değer döndürür.)

507 == 0 → false: erken dönüş yok.

Sayaç adet = 0.

Tur 1: 507 > 0 → adet = 1, kalan = 507 / 10 = 50.

Tur 2: 50 > 0 → adet = 2, kalan = 50 / 10 = 5.

Tur 3: 5 > 0 → adet = 3, kalan = 5 / 10 = 0.

0 > 0 → false: döngü biter.

return 3: çerçeve kapanır.

Çağrının yerine 3 geçer: println(3) → 3 yazılır.

static int basamakSayisi(int sayi) {
    long kalan = Math.abs((long) sayi);
    if (kalan == 0) return 1;
    int adet = 0;
    while (kalan > 0) {
        adet++;
        kalan /= 10;
    }
    return adet;
}
System.out.println(basamakSayisi(-507));

Örnek

Asal mı?

static boolean asalMi(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= n / i; i++)
        if (n % i == 0) return false;
    return true;
}

İlk bölen bulunduğunda erken dönüş yapılır.

Örnekler · Kodu adım adım çalıştır

Kod İzleme: `asalMi(15)` ve `asalMi(7)`

asalMi(15) çağrılır.

n = 15: 15 < 2 → false.

2 <= 15/2 = 7 → true; 15 % 2 = 1 → bölmüyor, i++.

3 <= 5 → true; 15 % 3 = 0 → return false: kalan turlar hiç çalışmaz (erken dönüş).

Dönen false println’e verilir ve yazılır.

asalMi(7) çağrılır.

n = 7: 7 < 2 → false.

2 <= 7/2 = 3 → true; 7 % 2 = 1 → bölmüyor, i++.

3 <= 7/3 = 2 → false: √7’ye kadar bölen yok.

Döngü erken dönüş olmadan bitti → return true.

Dönen true println’e verilir ve yazılır.

static boolean asalMi(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= n / i; i++)
        if (n % i == 0) return false;
    return true;
}
System.out.println(asalMi(15));  // main
System.out.println(asalMi(7));   // main

Örnekler · Kodu adım adım çalıştır

ebob: Öklid algoritması (48, 18)

Öklid algoritması en büyük ortak böleni (EBOB) bulur: ebob(a, b) = ebob(b, a % b); b = 0 olunca cevap a.

Çerçeve açılır: a = 48, b = 18.

Koşul: 18 != 0 → true.

r = 48 % 18 = 12; a = 18, b = 12. (ebob(48, 18) = ebob(18, 12))

Koşul: 12 != 0 → true.

r = 18 % 12 = 6; a = 12, b = 6. (ebob(18, 12) = ebob(12, 6))

Koşul: 6 != 0 → true.

r = 12 % 6 = 0; a = 6, b = 0. (ebob(12, 6) = ebob(6, 0))

Koşul: 0 != 0 → false.

return 6.

6 yazılır: 48 = 6 × 8, 18 = 6 × 3. Yalnızca 3 tur; 1’den 18’e tüm sayıları denemekten çok hızlı.

static int ebob(int a, int b) {
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}
System.out.println(ebob(48, 18));  // main

Örnekler · Kodu adım adım çalıştır

ekok(12, 18): metot içinden metot çağrısı

main, ekok(12, 18)’i çağırır.

ekok çerçevesi: a = 12, b = 18.

İfadeyi hesaplamak için ekok, ebob(a, b) metodunu çağırır: yığında 3 çerçeve.

ebob kendi döngüsünü çalıştırır: (12, 18) → (18, 12) → (12, 6) → (6, 0) → return 6. Adları aynı olsa da ebob’un a, b’si ayrı kutulardır.

Çağrının yerine 6 geçer: 12 / 6 * 18 = 2 * 18 = 36. Önce bölmek, a * b’nin taşmasını önler.

return 36: ekok’un çerçevesi kapanır.

36 yazılır. Metot başka metodu çağırarak işini kısaltır: kod tekrarı yok.

static int ekok(int a, int b) {
    return a / ebob(a, b) * b;
}
// ebob: Öklid algoritmasıyla EBOB
System.out.println(ekok(12, 18));  // main

Örnekler · Kodu adım adım çalıştır

Yeniden kullanım: `enBuyuk3(4, 9, 7)`

main, üç sayının en büyüğünü ister.

enBuyuk3 çerçevesi: a = 4, b = 9, c = 7.

İç içe çağrıda önce içteki hesaplanır: enBuyuk(4, 9).

Yeni çerçeve (a = 4, b = 9): 4 > 9 → false.

return b → 9.

İfade sadeleşti: enBuyuk(9, 7). Aynı metot ikinci kez çağrılır.

Yeni çerçeve (a = 9, b = 7): 9 > 7 → true → return a → 9.

enBuyuk3 de 9 döndürür.

9 yazılır. Karşılaştırma mantığı tek yerde (enBuyuk): hata varsa tek yerde düzeltilir.

static int enBuyuk(int a, int b) {
    if (a > b) return a;
    return b;
}
static int enBuyuk3(int a, int b, int c) {
    return enBuyuk(enBuyuk(a, b), c);
}
System.out.println(enBuyuk3(4, 9, 7));  // main

Örnekler · Kodu adım adım çalıştır

double döndüren metotlar: sıcaklık dönüşümü

fahrenheit(25): int argüman 25, double parametreye 25.0 olarak genişletilir.

c = 25.0.

25.0 × 9 = 225.0; / 5 = 45.0; + 32 = 77.0 → return.

f = 77.0 (double).

77.0 yazılır (double olduğu için .0 ile).

celsius(f): f’nin değeri (77.0) kopyalanır.

(77.0 − 32) × 5 / 9 = 45.0 × 5 / 9 = 25.0. 5 / 9 * (f - 32) yazılsaydı 5 / 9 tam sayı bölmesiyle 0 olurdu!

25.0 yazılır: iki metot birbirinin tersi (test için güzel bir kontrol).

static double fahrenheit(double c) {
    return c * 9 / 5 + 32;
}
static double celsius(double f) {
    return (f - 32) * 5 / 9;
}
double f = fahrenheit(25);          // main
System.out.println(f);
System.out.println(celsius(f));

Örnek

Saf Metot ve Yan Etki

Aynı girdi için aynı sonucu döndüren ve dış durumu değiştirmeyen metot daha kolay test edilir.
Hesaplama metodu ile ekrana yazma metodu ayrılabilir.
Gerektiğinde yan etki açıkça adlandırılmalı ve sınırlandırılmalıdır.

Safstatic int kare(int x) { return x * x; }

kare(4) her zaman 16; her yerde kullanılabilir.

Yan etkilistatic void kareYaz(int x) { System.out.println(x * x); }

Yalnızca ekrana yazar; sonuç başka hesapta kullanılamaz.

Özet

Bölüm Özeti

Metot bir görevi adlandırır, parametrelerle girdi alır ve sonuç döndürebilir.
Java'da argümanlar her zaman değer ile aktarılır.
Aşırı yüklemede aynı ad farklı parametre listeleriyle kullanılır.
Kapsam, değişkenin nerede erişilebilir olduğunu belirler.
Metot başka metodu çağırabilir (ekok → ebob, enBuyuk3 → enBuyuk); her çağrı yığında kendi çerçevesini açar.
Sonucu ekrana yazmak yerine döndüren metot daha kolay test edilir ve yeniden kullanılır.

Özet

Kontrol Soruları

Parametre ile argüman arasındaki fark nedir?
void metot hangi durumda kullanılır?
artir(sayi) çağrısından sonra sayi neden değişmez?
Aşırı yüklemede hangi bölüm farklı olmalıdır? int f(int) ile double f(int) neden birlikte olamaz?
ciftMi neden ekrana yazmak yerine boolean döndürür?

Özet

Alıştırmalar

static boolean artikYil(int yil) yazın (4/100/400 kuralı) ve 1900, 2000, 2024 ile deneyin.
static long faktoriyel(int n) ve bunu kullanan static long kombinasyon(int n, int r) = n! / (r! (n − r)!) yazın.
static int tersCevir(int sayi) ve onu çağıran static boolean palindromMu(int sayi) yazın.
static double ortalama(int a, int b, int c): neden (a + b + c) / 3 yanlış sonuç verebilir? Düzeltin.
Aşırı yükleme: enBuyuk(double, double) ekleyin; enBuyuk(3, 4.5) hangisini çağırır?
asalMi ile 1..100 arasındaki ikiz asalları (5–7, 11–13 …) listeleyen bir main yazın.

Özet

Kaynaklar

Deitel ve Deitel, Java: How to Program, Early Objects, 11. baskı, Pearson, 2018.
Liang, Introduction to Java Programming and Data Structures, 13. baskı, Pearson, 2024.
Oracle, The Java Tutorials: Defining Methods, Passing Information to a Method.
Oracle, Java Language Specification SE 21: Bölüm 8, Classes (§8.4 Method Declarations).
Sedgewick ve Wayne, Computer Science: An Interdisciplinary Approach, Addison-Wesley, 2016: 2.1 Static Methods.
Downey ve Mayfield, Think Java, 2. baskı, O'Reilly, 2019 (ücretsiz çevrim içi sürüm).

Son

Metotlar

Sonraki sunum: Diziler · Çalışma soruları · Simülatör: Metot Çağrı Yığını · Terim sözlüğü

Bölüm 9: Metotlar

Öğrenme Çıktıları

Fonksiyon Nedir?

Metot Çalışması

Metot Tanımı ve Çağrısı

Kod İzleme: topla(5, 3)

Çağrı Yığını: metot metodu çağırınca

Metot Tanımlamasının Parçaları

main Metodunun İmzası ve static

void Metotlar

Erken Dönüş

Kod İzleme: yazdirPozitif(-3) ve (7)

Derleme Hataları: return ve Tip

Parametre Aktarımı

Değer ile Aktarım: artir(sayi)

Değer ile Aktarım Tuzağı: swap(x, y)

Metot Aşırı Yükleme

Kod İzleme: derleyici hangi alan’ı seçer?

Değişken Sayıda Argüman (varargs)

Değişken Sayıda Argüman: topla(1, 2, 3)

Boş Çağrı: topla()

Yerel Kapsam

Kapsam Örneği: hesapla(3)

Kapsam: Aynı Adlı Değişken

Sık Kullanılan Hazır Metotlar: Math

Soyutlama

Ayrıştırma

İyi Metot Tasarımı

Önce Metot Sözleşmesi

Tek / Çift

Kod İzleme: ciftMi(7)

Basamak Sayısı

Kod İzleme: basamakSayisi(-507)

Asal mı?

Kod İzleme: asalMi(15) ve asalMi(7)

ebob: Öklid algoritması (48, 18)

ekok(12, 18): metot içinden metot çağrısı

Yeniden kullanım: enBuyuk3(4, 9, 7)

double döndüren metotlar: sıcaklık dönüşümü

Saf Metot ve Yan Etki

Bölüm Özeti

Kontrol Soruları

Alıştırmalar

Kaynaklar

Son

Kod İzleme: `topla(5, 3)`

`main` Metodunun İmzası ve `static`

Kod İzleme: `yazdirPozitif(-3)` ve `(7)`

Derleme Hataları: `return` ve Tip

Değer ile Aktarım: `artir(sayi)`

Değer ile Aktarım Tuzağı: `swap(x, y)`

Kod İzleme: derleyici hangi `alan`’ı seçer?

Değişken Sayıda Argüman: `topla(1, 2, 3)`

Boş Çağrı: `topla()`

Kapsam Örneği: `hesapla(3)`

Kod İzleme: `ciftMi(7)`

Kod İzleme: `basamakSayisi(-507)`

Kod İzleme: `asalMi(15)` ve `asalMi(7)`

Yeniden kullanım: `enBuyuk3(4, 9, 7)`