Bölüm 9 — Konu 43: Generic Sınırlamalar (`<T extends ...>`)

#Sorun: Generic Tip Üzerinde Hiçbir Varsayımda Bulunamazsın

Bir önceki derste generic bir Kutu<T> yazmıştık. Ama T tamamen "sınırsız" olduğu için, içindeki değer üzerinde hiçbir özel işlem yapamayız:

class Kutu<T> {
  T deger;
  Kutu(this.deger);

  bool digeriylebuyukmu(Kutu<T> diger) {
    return deger > diger.deger; // ❌ HATA! T'nin '>' operatörüne sahip olduğu garanti değil
  }
}

Bu kod derlenmez — çünkü T, herhangi bir tip olabilir (bir String, bir bool, hatta kendi yazdığın bir class). Dart, T'nin > operatörünü desteklediğinden emin olamaz (örneğin bool tipinde > operatörü anlamsızdır). Bu yüzden derleyici, güvenli olmayan bu kodu reddediyor.

#Çözüm: extends ile Generic Sınırlama (Bound)

class Kutu<T extends Comparable> {
  T deger;
  Kutu(this.deger);

  bool digeriylebuyukmu(Kutu<T> diger) {
    return deger.compareTo(diger.deger) > 0; // ✅ artık güvenli!
  }
}

void main() {
  Kutu<int> k1 = Kutu(10);
  Kutu<int> k2 = Kutu(20);
  print(k1.digeriylebuyukmu(k2)); // false

  Kutu<String> k3 = Kutu("elma");
  Kutu<String> k4 = Kutu("armut");
  print(k3.digeriylebuyukmu(k4)); // false (alfabetik karşılaştırma)
}

<T extends Comparable>, "T, sadece Comparable interface'ini implemente eden tiplerden biri olabilir" anlamına gelir. Comparable, Dart'ın standart kütüphanesinde tanımlı, compareTo() metoduna sahip olmayı garanti eden bir interface'dir — int, double, String gibi birçok yerleşik tip bunu zaten implemente eder.

Bu sınırlama sayesinde ne kazanıyoruz? Dart artık, T her ne olursa olsun, compareTo() metoduna sahip olacağını garanti eder — bu yüzden deger.compareTo(diger.deger) çağrısı güvenle derlenir.

#Sınırlamayı İhlal Etmeye Çalışmak

class Kutu<T extends Comparable> {
  T deger;
  Kutu(this.deger);
}

void main() {
  Kutu<bool> k = Kutu(true); // ❌ HATA! bool, Comparable'ı implemente etmiyor
}

bool, compareTo() metoduna sahip değildir (iki boolean değeri "büyük/küçük" karşılaştırmak mantıklı değildir), bu yüzden Dart, Kutu<bool> oluşturmana derleme zamanında izin vermez. Bu, generic sınırlamanın asıl gücü — yanlış kullanımı, kod çalışmadan önce yakalıyor.

#Kendi Class'larınla Generic Sınırlama Kullanma

abstract class Hayvan {
  String isim;
  Hayvan(this.isim);
  void sesCikar();
}

class Kedi extends Hayvan {
  Kedi(String isim) : super(isim);
  @override
  void sesCikar() => print("Miyav!");
}

class HayvanBarinagi<T extends Hayvan> {
  List<T> hayvanlar = [];

  void ekle(T hayvan) {
    hayvanlar.add(hayvan);
  }

  void hepsiniSesletir() {
    for (var hayvan in hayvanlar) {
      hayvan.sesCikar(); // ✅ güvenli, çünkü T kesinlikle bir Hayvan
    }
  }
}

void main() {
  HayvanBarinagi<Kedi> kediBarinagi = HayvanBarinagi();
  kediBarinagi.ekle(Kedi("Tekir"));
  kediBarinagi.hepsiniSesletir(); // Miyav!
}

<T extends Hayvan>, HayvanBarinagi'nin sadece Hayvan'dan türeyen tiplerle (Kedi, Kopek gibi) kullanılabileceğini garanti ediyor. Bu sayede, hepsiniSesletir() metodu içinde hayvan.sesCikar() çağırmak güvenlidir — Dart, T'nin kesinlikle sesCikar() metoduna sahip olduğunu bilir (çünkü Hayvan'ın alt sınıfı olmak zorunda).

void main() {
  HayvanBarinagi<String> stringBarinagi = HayvanBarinagi(); // ❌ HATA! String, Hayvan'dan türemiyor
}

#Sınırlama Olmadan vs Sınırlama İle — Karşılaştırma

// Sınırsız generic — hiçbir varsayımda bulunamazsın
class KutuSinirsiz<T> {
  T deger;
  KutuSinirsiz(this.deger);
  // sadece Object'in metodlarını (toString, ==ile vb.) kullanabilirsin
}

// Sınırlı generic — belirli bir "yetenek" garanti edilir
class KutuSinirli<T extends Comparable> {
  T deger;
  KutuSinirli(this.deger);
  // Comparable'ın metodlarını (compareTo) güvenle kullanabilirsin
}

Ne zaman sınırlama kullanılır? Generic tipin, sınıfın içinde belirli bir davranışa (bir metoda, bir alana) sahip olması gerektiğinde. Eğer generic tipi sadece "saklamak" için kullanıyorsan (Bölüm 9 Konu 42'deki basit Kutu<T> gibi), sınırlamaya gerek yoktur. Ama generic tip üzerinde işlem yapman gerekiyorsa (karşılaştırma, belirli bir metod çağırma), sınırlama şarttır.

#Object — Varsayılan (Örtük) Sınırlama

Aslında, sınırlama belirtmediğinde bile, Dart örtük olarak <T extends Object?> varsayar (ya da null safety bağlamına göre Object) — yani her generic tip, en azından Object'in (Bölüm 2'de gördüğümüz tip hiyerarşisinin köküdür) sahip olduğu temel metodlara (toString(), == gibi) her zaman sahiptir.

#Birden Fazla Generic Parametrede Sınırlama

class Eslesme<K extends Comparable, V> {
  K anahtar;
  V deger;
  Eslesme(this.anahtar, this.deger);
}

Sınırlama, birden fazla tip parametresinin her birine ayrı ayrı uygulanabilir — burada sadece K sınırlandırıldı, V sınırsız bırakıldı.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Sınırlanmamış (<T>) bir generic tip üzerinde, sadece Object'in temel metodlarını güvenle kullanabilirsin.
• <T extends TipAdı>, generic tipin belirli bir sınıf/interface'den türemesini zorunlu kılar — bu, o tipin belirli metod/alanlara sahip olacağını garanti eder.
• Sınırlama ihlal edildiğinde (örn. Kutu<bool> ile Comparable sınırlaması), hata derleme zamanında yakalanır.
• Generic tip üzerinde özel bir davranış (karşılaştırma, belirli bir metod çağırma) gerekiyorsa sınırlama şarttır; sadece "saklamak" için sınırlamaya gerek yoktur.
• Birden fazla tip parametresinin her biri ayrı ayrı sınırlandırılabilir.

#📝 Ödevler

• [ ] Comparable sınırlamalı bir Kutu<T> sınıfı yaz, iki farklı Kutu<int> nesnesini karşılaştıran bir metod ekle.
• [ ] Kutu<bool> oluşturmayı deneyip (eğer Comparable sınırlaması varsa) derleme hatasını gözlemle.
• [ ] Kendi soyut sınıfını (örn. Sekil, alanHesapla() metoduyla) yaz, bu sınıfla sınırlandırılmış generic bir SekilKoleksiyonu<T extends Sekil> sınıfı oluştur, içindeki tüm şekillerin toplam alanını hesaplayan bir metod ekle.
• [ ] Sınırlanmamış bir generic sınıfta, sınırlı olmadığı için hangi işlemleri yapamayacağını (örn. karşılaştırma, belirli bir metod çağırma) örnekle göster.
• [ ] İki tip parametreli bir generic sınıf yaz, sadece birini sınırlandır, ikisini de kullanan bir metod ekle.

Sıradaki konu: Bölüm 9 — Konu 44: Dart'ın Built-in Generic Koleksiyonları Nasıl Çalışır (List<T>, Map<K,V>)