Main Metodu ve Program Girisi
Main metodu, Java programinin baslangic noktasidir. JVM, programi calistirirken ilk olarak main metodunu arar ve calistirir.
public static void main(String[] args) {
// Program buradan baslar
}Java’nin Temelleri
2026
---
title: "Metotlar, Overloading ve Ozyineleme"
description: "Java'da metot tanimlama, parametre gecisi, overload ve recursive metot yapisini ogrenin"
author: "Teknik Kitap Yazarı"
date: 2024-01-15
tags: [Java, metot, overloading, recursion, parametre]
---Metot, belirli bir islevi yerine getiren ve gerektiginde cagrilabilen kod bloklaridir. Metotlar sayesinde kod tekrarini onler, moduler bir yapi olusturur ve kodun bakimini kolaylastiririz.
📚 Pedagojik Kutu: Metotlar, bir fabrikadaki makineler gibidir. Her makine belirli bir isi yapar, hammaddeleri (parametreleri) alir ve bir urun (donus degeri) uretir. Makineyi calistirmak icin dugmeye basmak (metot cagrisi) yeterlidir.
[ErisimBelirteci] [DonusTipi] metotAdi([ParametreListesi]) {
// Metot govdesi
// Islemler...
return [donusDegeri]; // void degilse zorunlu
}public class MetotOrnekleri {
// Geri donus degeri olan metot
public static int topla(int sayi1, int sayi2) {
return sayi1 + sayi2;
}
// Geri donus degeri olmayan metot (void)
public static void selamla(String isim) {
System.out.println("Merhaba, " + isim + "!");
}
public static void main(String[] args) {
// Metot cagirma
int sonuc = topla(5, 3);
System.out.println("Toplam: " + sonuc);
selamla("Ahmet");
}
}Metot imzasi, bir metodu benzersiz kilan bilesenlerdir: - Metot adi: Metodu tanimlayan isim - Parametre listesi: Parametrelerin sayisi, tipleri ve sirasi - Donus tipi: Metodun dondurdugu degerin tipi (imzanin bir parcasi degildir)
📚 Pedagojik Kutu: Metot imzasini bir kimlik karti gibi dusunun. Ayni isimde ama farkli parametrelere sahip metotlar, farkli kimlik kartlarina sahip kisiler gibidir. Java, hangi metodu cagiracagina imzaya bakarak karar verir.
Main metodu, Java programinin baslangic noktasidir. JVM, programi calistirirken ilk olarak main metodunu arar ve calistirir.
public static void main(String[] args) {
// Program buradan baslar
}Java’da parametre gecisi iki sekilde gerceklesir: deger tipi ve referans tipi.
📚 Pedagojik Kutu: Parametre gecisini bir fotokopi makinesi gibi dusunun. Deger tiplerinde, size verilen belgenin bir fotokopisini alirsiniz. Aslinda degisiklik yapamazsiniz. Referans tiplerinde ise, size belgenin kendisi verilir, uzerinde degisiklik yapabilirsiniz.
public class ParametreGecisi {
// Deger tipi parametre (int)
public static void degistirDeger(int sayi) {
sayi = 100; // Bu degisiklik ana metoda yansimaz
}
// Referans tipi parametre (Array)
public static void degistirDizi(int[] dizi) {
dizi[0] = 100; // Bu degisiklik ana metoda yansir
}
public static void main(String[] args) {
int x = 5;
degistirDeger(x);
System.out.println("x'in degeri: " + x); // 5
int[] sayilar = {1, 2, 3};
degistirDizi(sayilar);
System.out.println("sayilar[0]: " + sayilar[0]); // 100
}
}ref ve out anahtar kelimeleri, deger tiplerinin referans olarak gecirilmesini saglar.
📚 Pedagojik Kutu: ref ve out, deger tiplerini gecici olarak referans tipine donusturen sihirli anahtarlar gibidir. ref’te degerin ilk degeri olmalidir, out’ta ise metot icinde deger atanmalidir.
public class RefOutOrnekleri {
// ref ile degisiklik ana metoda yansir
public static void swap(ref int a, ref int b) {
int temp = a;
a = b;
b = temp;
}
// out ile coklu deger dondurme
public static bool bolme(int bolunen, int bolen, out int bolum, out int kalan) {
bolum = bolunen / bolen;
kalan = bolunen % bolen;
return true;
}
public static void main(String[] args) {
int x = 5, y = 10;
swap(ref x, ref y);
System.out.println("x: " + x + ", y: " + y); // x: 10, y: 5
int bolum, kalan;
bolme(17, 5, out bolum, out kalan);
System.out.println("Bolum: " + bolum + ", Kalan: " + kalan);
}
}Java’da dogrudan varsayilan parametre destegi yoktur, ancak metot overloading ile benzer bir davranis elde edilebilir.
public class VarsayilanParametre {
// Varsayilan parametre icin overload
public static void mesajGoster(String mesaj) {
System.out.println(mesaj);
}
public static void mesajGoster() {
mesajGoster("Varsayilan mesaj");
}
public static void main(String[] args) {
mesajGoster("Ozel mesaj");
mesajGoster(); // Varsayilan mesaj
}
}Metot overloading, ayni isimde ancak farkli parametre listelerine sahip metotlarin tanimlanmasidir. Bu sayede ayni islevi farkli parametre tipleriyle veya sayilariyla gerceklestirebiliriz.
📚 Pedagojik Kutu: Overloading, bir restorandaki “menuden sec” kavrami gibidir. Ayni islem (yemek siparisi) farkli parametrelerle (porsiyon buyuklugu, icecek cesidi) yapilabilir.
public class OverloadingOrnekleri {
// Ayni isim, farkli parametre sayisi
public static int topla(int a, int b) {
return a + b;
}
public static int topla(int a, int b, int c) {
return a + b + c;
}
// Ayni isim, farkli parametre tipi
public static double topla(double a, double b) {
return a + b;
}
public static void main(String[] args) {
System.out.println(topla(5, 3)); // 8
System.out.println(topla(5, 3, 2)); // 10
System.out.println(topla(5.5, 3.2)); // 8.7
}
}Java, en uygun overload’u secerken implicit tip donusumlerini de dikkate alir.
public class TipDonusumuOverload {
public static void islem(int a) {
System.out.println("int: " + a);
}
public static void islem(double a) {
System.out.println("double: " + a);
}
public static void main(String[] args) {
islem(5); // int: 5
islem(5.5); // double: 5.5
islem(5L); // double: 5.0 (long -> double donusumu)
}
}Ozyineleme, bir metodun kendini cagirmasi prensibine dayanir. Her ozyinelemeli metot iki temel bilesenden olusur: - Temel durum (base case): Ozyinelemenin durdugu kosul - Ozyinelemeli durum (recursive case): Metodun kendini cagirdigi kosul
📚 Pedagojik Kutu: Ozyineleme, bir aynanin karsisina gecip kendinizi sonsuza kadar yansitmaniz gibidir. Ancak temel durum, bu sonsuz yansimayi durduran bir dugmedir. Dogadaki fraktallar, karnabahar ve Matruksa bebekler ozyinelemenin guzel ornekleridir.
public class FaktoriyelKarsilastirma {
// Iteratif faktoriyel
public static int faktoriyelIteratif(int n) {
int sonuc = 1;
for (int i = 1; i <= n; i++) {
sonuc *= i;
}
return sonuc;
}
// Recursive faktoriyel
public static int faktoriyelRecursive(int n) {
// Temel durum
if (n == 0 || n == 1) {
return 1;
}
// Ozyinelemeli durum
return n * faktoriyelRecursive(n - 1);
}
public static void main(String[] args) {
System.out.println("Iteratif: " + faktoriyelIteratif(5)); // 120
System.out.println("Recursive: " + faktoriyelRecursive(5)); // 120
}
}public class FibonacciKarsilastirma {
// Recursive Fibonacci (performans sorunlu)
public static int fibRecursive(int n) {
if (n <= 1) {
return n;
}
return fibRecursive(n - 1) + fibRecursive(n - 2);
}
// Iteratif Fibonacci (performansli)
public static int fibIteratif(int n) {
if (n <= 1) {
return n;
}
int onceki = 0, suanki = 1;
for (int i = 2; i <= n; i++) {
int gecici = suanki;
suanki = onceki + suanki;
onceki = gecici;
}
return suanki;
}
public static void main(String[] args) {
int n = 10;
System.out.println("Recursive Fibonacci(" + n + "): " + fibRecursive(n));
System.out.println("Iteratif Fibonacci(" + n + "): " + fibIteratif(n));
}
}Ozyineleme derinligi arttikca stack bellek dolabilir ve StackOverflowError hatasi olusabilir.
public class DerinOzyineleme {
private static int derinlik = 0;
public static void recursiveMetot() {
derinlik++;
System.out.println("Derinlik: " + derinlik);
recursiveMetot(); // Sonsuz ozyineleme
}
public static void main(String[] args) {
try {
recursiveMetot();
} catch (StackOverflowError e) {
System.out.println("Stack overflow! Derinlik: " + derinlik);
}
}
}import java.util.Scanner;
public class HesapMakinesi {
// Overload ile toplama
public static int topla(int a, int b) {
return a + b;
}
public static double topla(double a, double b) {
return a + b;
}
// Overload ile cikarma
public static int cikar(int a, int b) {
return a - b;
}
public static double cikar(double a, double b) {
return a - b;
}
// Recursive us alma
public static int usAl(int taban, int us) {
if (us == 0) {
return 1;
}
return taban * usAl(taban, us - 1);
}
// Recursive faktoriyel
public static int faktoriyel(int n) {
if (n <= 1) {
return 1;
}
return n * faktoriyel(n - 1);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Hesap Makinesi");
System.out.println("1. Topla (int)");
System.out.println("2. Topla (double)");
System.out.println("3. Us Al (recursive)");
System.out.println("4. Faktoriyel (recursive)");
System.out.print("Seciminiz: ");
int secim = scanner.nextInt();
switch (secim) {
case 1:
System.out.print("Iki tam sayi girin: ");
System.out.println("Sonuc: " + topla(scanner.nextInt(), scanner.nextInt()));
break;
case 2:
System.out.print("Iki ondalikli sayi girin: ");
System.out.println("Sonuc: " + topla(scanner.nextDouble(), scanner.nextDouble()));
break;
case 3:
System.out.print("Taban ve us girin: ");
System.out.println("Sonuc: " + usAl(scanner.nextInt(), scanner.nextInt()));
break;
case 4:
System.out.print("Bir sayi girin: ");
System.out.println("Sonuc: " + faktoriyel(scanner.nextInt()));
break;
default:
System.out.println("Gecersiz secim!");
}
scanner.close();
}
}Bu bolumde Java’da metot kavramini, parametre gecis mekanizmalarini, metot overloading’i ve ozyinelemeyi ogrendik. Metotlar, kod tekrarini onlemenin ve moduler yapi olusturmanin temel yoludur. Overloading, ayni isimdeki metotlarin farkli parametrelerle calismasini saglarken, ozyineleme karmasik problemleri basit bir sekilde cozmemize olanak tanir.