0Pricing
Java Academy · Ders

Yöntem Aşırı Yükleme Kuralları

Java'nın aşırı yüklenmiş yöntemleri nasıl çözdüğünü ve yaygın belirsizlik sorunlarını anlayın.

Yöntem Aşırı Yükleme Kuralları, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

Yöntem Aşırı Yükleme Kuralları

Yöntem aşırı yükleme, aynı ada ancak farklı parametre listelerine sahip birden çok yöntem tanımlamanızı sağlar. Java, kesin çözümleme kurallarını kullanarak derleme zamanında en uygun eşleşmeyi seçer.

Aşırı Yükleme Nedir?

Aşırı yüklenmiş yöntemler aynı adı taşır, ancak parametre sayısı, türü veya sırasıyla farklılaşır. Yalnızca dönüş türü, aşırı yükleme için NOT yeterlidir.

class Calculator {
    int add(int a, int b)     { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c)   { return a + b + c; }

    // compile error — same signature, different return type only:
    // long add(int a, int b) { return a + b; }
}

Calculator calc = new Calculator();
System.out.println(calc.add(1, 2));       // 3 (int)
System.out.println(calc.add(1.5, 2.5));   // 4.0 (double)
System.out.println(calc.add(1, 2, 3));    // 6 (3-arg)

Çözümleme: En Belirgin Eşleşme

Java, uygulanabilir yöntemler arasından en belirgin olanı seçer. Genişletme, otomatik kutulama ve değişken sayıda bağımsız değişken kullanımı tercih sırasına göre denenir.

static void print(int x)    { System.out.println("int: "    + x); }
static void print(long x)   { System.out.println("long: "   + x); }
static void print(Object x) { System.out.println("Object: " + x); }

print(42);       // int: 42 (exact match — most specific)
print(42L);      // long: 42 (exact match)
print(3.14);     // Object: 3.14 (no float match, widening then autoboxing)

Otomatik Kutulamadan Önce Genişletme

Java, bir ilkel türü sarmalayıcı türe otomatik olarak kutulamak yerine genişletmeyi tercih eder. Bu durum şaşırtıcı sonuçlar üretebilir.

static void display(long n)    { System.out.println("long: " + n); }
static void display(Integer n) { System.out.println("Integer: " + n); }

int x = 100;
display(x); // long: 100 — widens int to long BEFORE autoboxing to Integer
// This surprises many developers!

static void show(Long n)    { System.out.println("Long"); }
static void show(Integer n) { System.out.println("Integer"); }

// show(100); // compile error — ambiguous! Neither is more specific

Null Bağımsız Değişkeni Belirsizliği

Aşırı yüklenmiş yöntemlere null geçirmek, birden çok yöntem referans türlerini kabul ediyorsa belirsiz olabilir. Çözümlemek için null değerini dönüştürün.

static void handle(String s)  { System.out.println("String: " + s); }
static void handle(Integer i) { System.out.println("Integer: " + i); }
static void handle(Object o)  { System.out.println("Object"); }

handle((String) null);  // String: null (cast resolves ambiguity)
handle((Integer) null); // Integer: null
// handle(null);        // compile error: ambiguous (String vs Integer)

Kalıtımla Aşırı Yükleme

Yöntem çözümlemesi, çalışma zamanı türünü değil, referans değişkeninin bildirilmiş türünü dikkate alır; bu, derleme zamanında verilen bir karardır.

class Animal {}
class Dog extends Animal {}

static void greet(Animal a) { System.out.println("Animal"); }
static void greet(Dog d)    { System.out.println("Dog"); }

Animal a = new Dog(); // declared as Animal
greet(a);   // Animal — compile-time type is Animal!

Dog d = new Dog();
greet(d);   // Dog — compile-time type is Dog

Aşırı Yükleme ve Geçersiz Kılma Karşılaştırması

Aşırı yükleme derleme zamanında verilen bir karardır (statik dağıtım). Geçersiz kılma ise gerçek nesne türüne dayalı olarak çalışma zamanında verilen bir karardır (dinamik dağıtım).

class Base {
    void run() { System.out.println("Base.run"); }
}
class Sub extends Base {
    @Override
    void run() { System.out.println("Sub.run"); } // overriding

    void run(int speed) { System.out.println("Sub.run(" + speed + ")"); } // overloading
}

Base b = new Sub();
b.run();     // Sub.run — override (runtime dispatch)
// b.run(10); // compile error — Base doesn't have run(int)

Yaygın Aşırı Yükleme Kalıpları

API'lerde aşırı yüklemenin yaygın bir kullanımı, tam parametreli sürüme yetki veren kolaylık yöntemleri sağlamaktır.

class Connection {
    void connect(String host, int port, int timeout) {
        System.out.println("Connecting to " + host + ":" + port + " timeout=" + timeout);
    }

    // Convenience overloads
    void connect(String host, int port) {
        connect(host, port, 30); // delegate with default timeout
    }

    void connect(String host) {
        connect(host, 5432); // delegate with default port
    }
}

new Connection().connect("db.example.com");
// Connecting to db.example.com:5432 timeout=30

Aşırı Yükleme ve Jenerikler

Jenerik yöntem aşırı yüklemesi dikkat gerektirir; tür silme, görünüşte farklı olan iki imzanın derlemeden sonra aynı olmasına neden olabilir.

// Type erasure problem: both methods erase to the same signature!
// static void process(List<String> list) {} // compile error
// static void process(List<Integer> list) {} // duplicate after erasure

// Solutions:
// 1. Use different method names: processStrings / processIntegers
// 2. Use a generic method with bounded type:
static <T extends Number> void processNumbers(List<T> list) {
    list.forEach(n -> System.out.println(n.doubleValue()));
}
processNumbers(List.of(1, 2, 3));
processNumbers(List.of(1.5, 2.5));

Uygulamalı: Oluşturucu Tarzı Aşırı Yüklemeler

Esnek nesne oluşturma olanağı sağlamak için oluşturucu/fabrika arayüzlerinde aşırı yükleme yaygın olarak kullanılır.

class Notification {
    final String title, body;
    final String imageUrl;
    final boolean urgent;

    // Factory overloads for convenience
    static Notification simple(String title, String body) {
        return new Notification(title, body, null, false);
    }
    static Notification urgent(String title, String body) {
        return new Notification(title, body, null, true);
    }
    static Notification withImage(String title, String body, String url) {
        return new Notification(title, body, url, false);
    }
    Notification(String title, String body, String imageUrl, boolean urgent) {
        this.title = title; this.body = body;
        this.imageUrl = imageUrl; this.urgent = urgent;
    }
}

Aşırı Yüklemenin Tuzakları

Şu yaygın aşırı yükleme hatalarından kaçının:

  • Aynı işlem için çok fazla aşırı yükleme kullanmak; bunun yerine bir oluşturucu kullanın
  • Yalnızca parametre sırasıyla farklılaşan aşırı yüklemeler; bunlar kafa karıştırıcıdır
  • Şaşırtıcı genişletme: bir int, Integer yerine long olarak çözümlenebilir
// Confusing: order-based overloads
// void save(String name, int age)  {}
// void save(int age, String name)  {} // very confusing!

// Better: use a record/DTO
record UserData(String name, int age) {}
void save(UserData data) {}

// Surprising widening
static void m(long x)   { System.out.println("long"); }
static void m(Integer x){ System.out.println("Integer"); }
int v = 5;
m(v); // long! widening preferred over autoboxing

Kısa Kontrol

Bir metot hem long hem de Integer parametreleriyle aşırı yüklenmişse, bir int bağımsız değişkeni geçirilirken hangisi seçilir?

Özet: Metot Aşırı Yükleme Kuralları

Önemli noktalar:

  • Aşırı yükleme; parametre sayısına, türüne veya sırasına göre farklılaşır — yalnızca dönüş türüne göre değil (NOT)
  • Java, aşırı yüklemeleri derleme zamanında bağımsız değişkenlerin bildirilen türünü kullanarak çözümler
  • Bir ilkel türü genişletmek, onu bir sarmalayıcı türe otomatik olarak kutulamaya tercih edilir
  • null bağımsız değişkenleri belirsizliğe yol açabilir — çözmek için tür dönüşümü kullanın: handle((String) null)
  • Aşırı yükleme derleme zamanında, geçersiz kılma ise çalışma zamanında gerçekleşir — bunlar farklı mekanizmalardır
  • Kolaylık sağlayan aşırı yüklemeleri, tüm parametreleri alan bir ana metoda yönlendirin

Sıkça Sorulan Sorular

“Yöntem Aşırı Yükleme Kuralları” dersi ücretsiz mi?

Evet — “Yöntem Aşırı Yükleme Kuralları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“Yöntem Aşırı Yükleme Kuralları” dersinde ne öğreneceğim?

Java'nın aşırı yüklenmiş yöntemleri nasıl çözdüğünü ve yaygın belirsizlik sorunlarını anlayın. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Yöntem Aşırı Yükleme Kuralları” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Yöntem Aşırı Yükleme Kuralları
  2. Değişken Sayıda Parametre
  3. Statik Alanlar ve Sabitler
  4. Yardımcı Sınıflar ve Statik Fabrika Yöntemleri
← Java Academy Sayfasına Dön