Bölüm 7 — Konu 33: Metod Override Etme, `@override`

Bir önceki derste sesCikar() örneğinde override'ı kısaca görmüştük. Şimdi bunu tam olarak işleyelim — bu, kalıtımın gerçek gücünü ortaya çıkaran kavramdır.

#Override Nedir?

Override etmek, bir alt sınıfın, üst sınıftan devraldığı bir metodun davranışını kendi ihtiyacına göre değiştirmesidir.

class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() {
    print("Miyav!");
  }
}

class Kopek extends Hayvan {
  @override
  void sesCikar() {
    print("Hav hav!");
  }
}

void main() {
  Hayvan h = Hayvan();
  Kedi k = Kedi();
  Kopek köpek = Kopek();

  h.sesCikar();      // Bir hayvan sesi çıkarıyor
  k.sesCikar();      // Miyav!
  köpek.sesCikar();  // Hav hav!
}

Kedi ve Kopek, Hayvan'dan sesCikar() metodunu devralıyor ama her biri kendi versiyonuyla değiştiriyor (override ediyor). Metod adı ve imzası (parametre tipleri, dönüş tipi) aynı kalmalı — sadece gövde (davranış) değişiyor.

#@override Anotasyonu — Neden Önemli?

class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() { // ✅ doğru — üst sınıfta gerçekten var olan bir metodu override ediyor
    print("Miyav!");
  }
}

@override, teknik olarak zorunlu değildir — onsuz da kod çalışır. Ama şiddetle önerilir, çünkü Dart derleyicisine "ben bilerek bir üst sınıf metodunu değiştiriyorum" der ve bu bir güvenlik ağı sağlar:

class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikarr() { // yazım hatası! "sesCikar" değil "sesCikarr"
    print("Miyav!");
  }
}

Bu kod, @override sayesinde derleme zamanında hata verir — çünkü Dart, Hayvan sınıfında sesCikarr diye bir metod olmadığını görür ve "bunu override ettiğini iddia ediyorsun ama böyle bir metod yok" diye uyarır. Eğer @override yazmasaydık, bu kod sessizce derlenirdi — ama sesCikarr, aslında sesCikar'ı override etmiyor, tamamen yeni ve ayrı bir metod olarak eklenmiş olurdu. Bu, gerçek kodda fark edilmesi çok zor bir hataya yol açabilir. @override kullanmak, bu tür yazım hatalarını anında yakalamanı sağlar.

#Polymorphism (Çok Biçimlilik) — Override'ın Asıl Gücü

class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

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

class Kopek extends Hayvan {
  @override
  void sesCikar() => print("Hav hav!");
}

void tumHayvanlariSesletir(List<Hayvan> hayvanlar) {
  for (var hayvan in hayvanlar) {
    hayvan.sesCikar(); // her biri KENDİ override edilmiş versiyonunu çalıştırır!
  }
}

void main() {
  List<Hayvan> hayvanlar = [Kedi(), Kopek(), Hayvan()];
  tumHayvanlariSesletir(hayvanlar);
  // Miyav!
  // Hav hav!
  // Bir hayvan sesi çıkarıyor
}

Bu, polymorphism (çok biçimlilik) dediğimiz kavramın somut bir örneğidir: tumHayvanlariSesletir fonksiyonu, listedeki her elemanın gerçek tipinin ne olduğunu bilmek zorunda değildir — hepsine Hayvan gibi davranır (List<Hayvan>), ama her biri kendi override ettiği sesCikar() versiyonunu çalıştırır. Bu, Dart'ın çalışma zamanında, her nesnenin gerçek tipine göre doğru metodu seçmesi sayesinde olur (buna "dynamic dispatch" denir, ileri bir kavram — şimdilik sadece bu davranışın var olduğunu bilmen yeterli).

Bu neden bu kadar güçlü? Çünkü kod, genel (generic) bir şekilde yazılabilir — tumHayvanlariSesletir, gelecekte yeni bir hayvan türü (örneğin Kus) eklendiğinde hiç değişmeden çalışmaya devam eder, yeter ki Kus da Hayvan'dan türeyip sesCikar()'ı override etsin.

#Üst Sınıfın Davranışını Tamamen Değiştirme vs Üzerine Ekleme

class Calisan {
  double maasHesapla() {
    return 5000;
  }
}

class Yonetici extends Calisan {
  @override
  double maasHesapla() {
    return super.maasHesapla() + 2000; // üst sınıfın sonucunu al, üzerine ekle
  }
}

class Stajyer extends Calisan {
  @override
  double maasHesapla() {
    return 1500; // üst sınıfı hiç kullanmadan tamamen kendi mantığını yaz
  }
}

void main() {
  print(Calisan().maasHesapla());   // 5000.0
  print(Yonetici().maasHesapla());  // 7000.0 — 5000 + 2000
  print(Stajyer().maasHesapla());   // 1500.0 — tamamen farklı
}

Bu örnek, bir önceki derste gördüğümüz super.metodAdi() kullanımını override bağlamında pekiştiriyor: Yonetici, üst sınıfın davranışını temel alıp üzerine ekliyor; Stajyer ise üst sınıfı hiç kullanmadan tamamen kendi davranışını tanımlıyor. İkisi de geçerli override yaklaşımlarıdır, ihtiyaca göre seçilir.

#Override Ederken Dikkat Edilmesi Gereken Kural — İmza Uyumu

class Hayvan {
  void sesCikar(String ekstra) {
    print("Hayvan sesi: $ekstra");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() { // ❌ HATA! parametre eksik, üst sınıfla uyuşmuyor
    print("Miyav!");
  }
}

Override ederken, metodun parametre sayısı, tipleri ve dönüş tipi üst sınıftakiyle uyumlu olmalıdır (tam olarak aynı olması gerekmez ama tip sisteminin izin verdiği ölçüde uyumlu olmalı — buna "Liskov substitution principle" denir, ileri bir OOP prensibi). Basitçe: üst sınıfın imzasını değiştiremezsin, sadece gövdesini (davranışını) değiştirebilirsin.

#toString() Override — Tekrar Hatırlatma

Bölüm 6'da gördüğümüz toString() override örneği, aslında tam olarak bu derste öğrendiğimiz mekanizmanın bir uygulamasıydı:

class Kisi {
  String isim;
  Kisi(this.isim);

  @override
  String toString() => "Kisi: $isim"; // Object'ten gelen toString()'i override ediyoruz
}

void main() {
  print(Kisi("Ahmet")); // Kisi: Ahmet
}

Her class, örtük olarak Object'ten türediği için (Bölüm 7 Konu 32'de gördük), toString() de aslında Object sınıfından override edilen bir metoddur — şimdi bunun neden çalıştığını tam olarak anlıyorsun.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Override, bir alt sınıfın üst sınıftan devraldığı bir metodun davranışını değiştirmesidir; metod imzası aynı kalmalı.
• @override zorunlu değildir ama şiddetle önerilir — yazım hatalarını derleme zamanında yakalamanı sağlar.
• Polymorphism, farklı alt sınıfların aynı metodu farklı şekillerde override etmesi ve kodun bunları genel bir şekilde (üst sınıf tipi üzerinden) işleyebilmesidir.
• super.metodAdi() ile üst sınıfın davranışının üzerine eklenebilir, ya da hiç çağrılmadan tamamen değiştirilebilir.
• Override edilen metodun parametre ve dönüş tipleri üst sınıfla uyumlu olmalıdır.

#📝 Ödevler

• [ ] Sekil adında bir üst sınıf yaz (alanHesapla() metoduyla), Daire ve Kare alt sınıflarıyla bu metodu override et.
• [ ] @override yazmadan bilerek bir yazım hatası (yanlış metod adı) yap, kodun sessizce derlendiğini gözlemle; sonra @override ekleyip hatanın nasıl yakalandığını gör.
• [ ] List<Sekil> alıp içindeki her şeklin alanHesapla() sonucunu yazdıran bir fonksiyon yaz (polymorphism'i kullanarak) — en az 2 farklı şekil tipiyle test et.
• [ ] Bir override'da super.metodAdi() çağırarak üst sınıfın davranışının üzerine ekleme yapan, başka bir override'da ise üst sınıfı hiç çağırmadan tamamen farklı davranan iki örnek yaz.
• [ ] Kendi yazdığın bir class'ta toString() metodunu override ederek anlamlı bir çıktı üret, print() ile test et.

Sıradaki konu: Bölüm 7 — Konu 34: Soyut Sınıflar (abstract class)