Bölüm 9 — Konu 42: Generic Sınıflar ve Fonksiyonlar

Bölüm 9'a hoş geldin. Bu bölüm, aslında Bölüm 4'te List<String>, Map<String, int> yazarken sürekli kullandığın <...> sözdiziminin arkasında ne olduğunu açıklayacak — generics.

#Generics Neden Var? — Problemi Anlamak

Diyelim ki, herhangi bir tipte tek bir değer tutan basit bir "kutu" sınıfı yazmak istiyorsun:

// Yaklaşım 1: dynamic kullanmak
class KutuDynamic {
  dynamic icerik;
  KutuDynamic(this.icerik);
}

void main() {
  KutuDynamic k = KutuDynamic("Merhaba");
  String metin = k.icerik; // ❌ HATA! dynamic, String'e otomatik dönüşmez, tip güvenliği yok
}

Bölüm 2'de dynamic'ten kaçınmayı öğrenmiştik — bu yaklaşım tip güvenliğini tamamen kaybettiriyor. Peki her tip için ayrı bir sınıf mı yazmalıyız?

// Yaklaşım 2: Her tip için ayrı sınıf — kod tekrarı!
class StringKutu {
  String icerik;
  StringKutu(this.icerik);
}

class IntKutu {
  int icerik;
  IntKutu(this.icerik);
}

class BoolKutu {
  bool icerik;
  BoolKutu(this.icerik);
}

Bu çalışır ama korkunç bir kod tekrarı — her yeni tip için yeni bir sınıf yazman gerekiyor. Generics, tam olarak bu problemi çözmek için var: hem tip güvenliğini koru, hem de kod tekrarını önle.

#Generic Sınıf Yazma

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

  void goster() {
    print("İçerik: $icerik, Tip: ${icerik.runtimeType}");
  }
}

void main() {
  Kutu<String> stringKutu = Kutu<String>("Merhaba");
  Kutu<int> intKutu = Kutu<int>(42);
  Kutu<bool> boolKutu = Kutu<bool>(true);

  stringKutu.goster(); // İçerik: Merhaba, Tip: String
  intKutu.goster();    // İçerik: 42, Tip: int
}

<T> ne anlama geliyor? T, bir tip parametresidir (type parameter) — "bu sınıf, kullanıldığı anda belirlenecek herhangi bir tip ile çalışabilir" anlamına gelir. T harfi bir kural değil, sadece yaygın bir konvansiyondur ("Type" kelimesinin kısaltması) — istersen Kutu<X> da yazabilirdin, ama T kullanmak yaygın ve okunması kolay bir tercihtir.

Tip güvenliği nasıl korunuyor?

void main() {
  Kutu<String> stringKutu = Kutu<String>("Merhaba");
  String metin = stringKutu.icerik; // ✅ çalışır! icerik zaten String olarak biliniyor

  stringKutu.icerik = 42; // ❌ HATA! Kutu<String>, sadece String kabul eder
}

Bu, generics'in gücünü gösteriyor: Kutu<String> dediğinde, Dart artık o kutunun kesinlikle String tutacağını bilir ve tip güvenliğini tam olarak korur — dynamic kullanmadığımız için hiçbir tip belirsizliği yok.

#Tip Çıkarımı Generics'te de Çalışır

void main() {
  var kutu = Kutu("Merhaba"); // <String> yazmadık, Dart otomatik anladı
  print(kutu.icerik.runtimeType); // String
}

Bölüm 2'de öğrendiğimiz tip çıkarımı, generics'te de geçerlidir — Kutu("Merhaba") yazdığında, Dart parametrenin String olduğunu görüp T'yi otomatik olarak String olarak belirler. Yine de, özellikle karmaşık durumlarda açıkça Kutu<String>(...) yazmak okunabilirlik açısından tercih edilir.

#Generic Fonksiyonlar

Sadece sınıflar değil, fonksiyonlar da generic olabilir:

T ilkEleman<T>(List<T> liste) {
  return liste[0];
}

void main() {
  List<String> isimler = ["Ahmet", "Ayşe"];
  List<int> sayilar = [10, 20, 30];

  print(ilkEleman(isimler)); // Ahmet — T, String olarak belirlendi
  print(ilkEleman(sayilar)); // 10 — T, int olarak belirlendi
}

ilkEleman<T>(List<T> liste), herhangi bir tipteki listenin ilk elemanını, o listenin tipini koruyarak döndürür. Eğer bunu generic olmadan, dynamic ile yazsaydık:

dynamic ilkElemanDynamic(List liste) {
  return liste[0];
}

void main() {
  List<String> isimler = ["Ahmet", "Ayşe"];
  String isim = ilkElemanDynamic(isimler); // ❌ HATA! dynamic, String'e otomatik atanamaz
}

Generic versiyon, çağrıldığı listenin gerçek tipini koruyarak döndürüyor — bu, dynamic versiyonunun kaybettiği tip güvenliğini tam olarak sağlıyor.

#Birden Fazla Tip Parametresi

class Cift<A, B> {
  A birinci;
  B ikinci;
  Cift(this.birinci, this.ikinci);

  @override
  String toString() => "($birinci, $ikinci)";
}

void main() {
  Cift<String, int> yasBilgisi = Cift("Ahmet", 25);
  print(yasBilgisi); // (Ahmet, 25)

  Cift<String, bool> aktiflikBilgisi = Cift("Sistem", true);
  print(aktiflikBilgisi); // (Sistem, true)
}

Bu, aslında Bölüm 4'te sürekli kullandığımız Map<K, V>'nin tam olarak nasıl çalıştığının basitleştirilmiş bir versiyonu — Map, içeride iki tip parametresi alan (K: key tipi, V: value tipi) generic bir sınıftır.

#Generic Metod (Sınıf Generic Olmasa Bile)

class Yardimci {
  T ikisindenBuyuguGetir<T extends Comparable>(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
  }
}

Burada Yardimci sınıfının kendisi generic değil, ama içindeki bir metod generic — bu, sadece o metod çağrıldığında tip parametresi belirlenecek anlamına gelir. T extends Comparable kısmını (generic sınırlama) bir sonraki derste tam olarak işleyeceğiz.

#Dart'ın Kendi Koleksiyonları — Artık Nasıl Çalıştıklarını Biliyorsun

List<String> isimler = [];   // List<T>, T=String
Map<String, int> yaslar = {}; // Map<K, V>, K=String, V=int
Set<int> sayilar = {};        // Set<T>, T=int

Bölüm 4'te bunları "kullanmayı" öğrenmiştik, şimdi neden bu şekilde tasarlandıklarını anlıyorsun — List, Map, Set sınıflarının hepsi generic olarak yazılmış, bu sayede herhangi bir tipte veri tutabiliyorlar, ama her kullanımda tam tip güvenliği koruyorlar.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Generics, dynamic kullanmadan (tip güvenliğini kaybetmeden) hem esnek hem tip-güvenli kod yazmanı sağlar.
• <T>, bir tip parametresidir — sınıf/fonksiyon kullanıldığı anda gerçek bir tiple değiştirilir.
• Generic sınıflarda tip çıkarımı çalışır, ama açıkça belirtmek genelde daha okunabilirdir.
• Fonksiyonlar da generic olabilir (T fonksiyon<T>(...)), farklı tiplerle aynı mantığı tekrar yazmadan çalıştırabilirsin.
• Birden fazla tip parametresi (<A, B>) kullanılabilir — Map<K, V> buna bir örnektir.
• Dart'ın kendi List, Map, Set koleksiyonları, generics kullanılarak tasarlanmıştır.

#📝 Ödevler

• [ ] Herhangi bir tipte eleman tutabilen generic bir Kutu<T> sınıfı yaz, en az 3 farklı tiple (String, int, bool) kullan.
• [ ] Bir listenin son elemanını döndüren generic bir fonksiyon yaz (sonEleman<T>(List<T> liste)), farklı tipte listelerle test et.
• [ ] Cift<A, B> benzeri, iki farklı tipte değer tutan generic bir sınıf yaz, en az iki farklı tip kombinasyonuyla kullan.
• [ ] Generic olmayan (dynamic kullanan) bir fonksiyon ile aynı işi yapan generic bir fonksiyonu karşılaştırmalı olarak yaz, tip güvenliği farkını göster.
• [ ] Kendi Cift<A, B> sınıfına, A ve B değerlerini yer değiştiren bir takasEt() metodu ekle (yeni bir Cift<B, A> döndürsün).

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