Bölüm 6 — Konu 30: Getter / Setter

#Neden Getter/Setter'a İhtiyaç Var?

Bölüm 6'ya kadar, bir class'ın alanlarına doğrudan erişip değiştirebiliyorduk:

class Dikdortgen {
  double genislik;
  double yukseklik;
  Dikdortgen(this.genislik, this.yukseklik);
}

void main() {
  Dikdortgen d = Dikdortgen(4, 5);
  d.genislik = -10; // ❌ mantıksal olarak hatalı ama Dart bunu engellemiyor!
  print(d.genislik); // -10 — negatif bir genişlik, anlamsız ama kabul edildi
}

Bu bir sorun — bir dikdörtgenin genişliği negatif olamaz, ama şu anki kodumuz bunu engelleyemiyor. Getter ve setter'lar, bir alana erişimi/değişimini kontrol altına almanı sağlayan mekanizmalardır.

#Getter — Hesaplanmış Bir "Özellik" Tanımlama

class Dikdortgen {
  double genislik;
  double yukseklik;

  Dikdortgen(this.genislik, this.yukseklik);

  double get alan {
    return genislik * yukseklik;
  }

  double get cevre => 2 * (genislik + yukseklik); // arrow ile kısa yazım
}

void main() {
  Dikdortgen d = Dikdortgen(4, 5);
  print(d.alan);  // 20.0 — parantez YOK, tıpkı bir alan gibi erişiliyor!
  print(d.cevre); // 18.0
}

Kritik detay: d.alan yazdık, d.alan() değil. Getter'lar, dışarıdan bakıldığında sıradan bir alan gibi görünür (parantezsiz erişilir), ama arka planda aslında bir metod gibi çalışır — her erişimde hesaplama yeniden yapılır.

Bunu neden bir alan olarak değil de getter olarak tanımlıyoruz? Çünkü alan, genislik ve yukseklik'ten türetilen bir değerdir — kendi başına saklanmasına gerek yoktur, her ihtiyaç duyulduğunda hesaplanabilir. Eğer alan'ı sıradan bir alan olarak tutsaydık, genislik her değiştiğinde alan'ı da elle güncellemen gerekirdi — bu, hataya çok açık bir yaklaşımdır (birini güncelleyip diğerini unutmak gibi). Getter, bu senkronizasyon sorununu tamamen ortadan kaldırır.

#Setter — Bir Değeri Atarken Kontrol Uygulama

class Dikdortgen {
  double _genislik; // alt çizgi ile başlıyor — "private" (birazdan açıklayacağız)

  Dikdortgen(this._genislik);

  double get genislik => _genislik;

  set genislik(double yeniDeger) {
    if (yeniDeger < 0) {
      print("Hata: Genişlik negatif olamaz, işlem reddedildi.");
      return;
    }
    _genislik = yeniDeger;
  }
}

void main() {
  Dikdortgen d = Dikdortgen(10);
  print(d.genislik); // 10.0

  d.genislik = 20; // setter çağrılıyor, parantez yok
  print(d.genislik); // 20.0

  d.genislik = -5; // setter içindeki kontrol devreye giriyor
  // Hata: Genişlik negatif olamaz, işlem reddedildi.
  print(d.genislik); // 20.0 — değişmedi!
}

Yapıyı parçalayalım:

• _genislik — gerçek veriyi tutan private alan (alt çizgi ile başlıyor, birazdan açıklayacağız).
• get genislik => _genislik; — dışarıya genislik adıyla okuma izni veren getter.
• set genislik(double yeniDeger) { ... } — dışarıdan genislik'e yazma girişimini yakalayan, kontrol eden setter.

d.genislik = 20; yazdığında, aslında arka planda set genislik(20) metodun çalışıyor — ama sözdizimi olarak sanki doğrudan bir alana atama yapıyormuşsun gibi görünüyor. Bu, encapsulation (kapsülleme) dediğimiz OOP prensibinin temel bir uygulamasıdır: dış dünyaya basit bir arayüz (d.genislik) sunarken, arka planda kontrol mekanizmalarını gizli tutabiliyorsun.

#_ (Alt Çizgi) — Private Alan/Metod Kuralı

Bölüm 1'de kısaca değindiğimiz alt çizgi kuralını burada tam olarak açıklayalım: Dart'ta, bir alan/metod/class adının başına _ koymak, onu o dosyaya (library) özel yapar — başka bir dosyadan doğrudan erişilemez hale gelir.

// dikdortgen.dart dosyası
class Dikdortgen {
  double _genislik; // sadece bu dosya içinden erişilebilir
  Dikdortgen(this._genislik);
}

// main.dart dosyası
import 'dikdortgen.dart';

void main() {
  Dikdortgen d = Dikdortgen(10);
  print(d._genislik); // ❌ HATA! Başka bir dosyadan private alana erişilemez
}

Bu, Java/C# gibi dillerdeki private anahtar kelimesine benzer bir işlev görür ama Dart'ta ayrı bir anahtar kelime yoktur — sadece isim kuralı (_ öneki) kullanılır. Bunun dosya (library) seviyesinde çalıştığını bilmen önemli — aynı dosya içindeki başka bir class, _genislik'e erişebilir, ama farklı bir dosyadaki class erişemez.

#Neden Getter/Setter + Private Alan Kalıbı Bu Kadar Yaygın?

class BankaHesabi {
  double _bakiye = 0;

  double get bakiye => _bakiye;

  void paraYatir(double miktar) {
    if (miktar <= 0) {
      print("Geçersiz miktar");
      return;
    }
    _bakiye += miktar;
  }

  void paraCek(double miktar) {
    if (miktar > _bakiye) {
      print("Yetersiz bakiye");
      return;
    }
    _bakiye -= miktar;
  }
}

void main() {
  BankaHesabi hesap = BankaHesabi();
  hesap.paraYatir(1000);
  print(hesap.bakiye); // 1000.0

  hesap.paraCek(2000); // Yetersiz bakiye
  print(hesap.bakiye); // 1000.0 — değişmedi

  hesap.bakiye = 5000; // ❌ HATA! bakiye için setter yok, sadece getter var
}

Bu örnek, çok önemli bir kalıbı gösteriyor: bakiye alanı için sadece getter tanımladık, setter tanımlamadık. Bu, bakiye'yi dışarıdan salt-okunur (read-only) yapıyor — değeri sadece paraYatir() ve paraCek() metodları aracılığıyla, kontrollü bir şekilde değiştirilebiliyor. Bu, gerçek dünyada bir banka hesabının nasıl çalışması gerektiğine çok benzer — bakiyeyi doğrudan "20000 yap" diyemezsin, sadece yatırma/çekme işlemleriyle değiştirebilirsin.

#Getter/Setter Olmadan Sadece Getter Tanımlamak — Basit Kalıp

class Kisi {
  final String ad;
  final String soyad;

  Kisi(this.ad, this.soyad);

  String get tamAd => "$ad $soyad"; // sadece getter, setter yok
}

void main() {
  Kisi k = Kisi("Ahmet", "Yılmaz");
  print(k.tamAd); // Ahmet Yılmaz

  k.tamAd = "Başka İsim"; // ❌ HATA! setter tanımlanmadı
}

tamAd, ad ve soyad'dan türetildiği için, ona doğrudan bir değer atamak zaten mantıksız olurdu — bu yüzden sadece getter tanımlamak, bu tür "salt hesaplanmış" özellikler için doğal ve doğru bir kalıptır.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Getter (get), dışarıya bir alan gibi görünen ama aslında hesaplama yapan bir metoddur; parantezsiz çağrılır.
• Setter (set), bir değeri atarken kontrol/doğrulama uygulamanı sağlar; nesne.alan = deger şeklinde çağrılır.
• _ öneki, bir alan/metodu dosyaya (library) özel (private) yapar.
• Yaygın kalıp: gerçek veriyi _alan olarak private tut, get/set ile kontrollü erişim sağla.
• Sadece getter tanımlayıp setter tanımlamamak, bir özelliği dışarıdan salt-okunur yapmanın basit bir yoludur.

#📝 Ödevler

• [ ] Bir Daire sınıfı yaz — yaricap alanı olsun, alan ve cevre için getter'lar tanımla (hesaplanmış özellikler).
• [ ] Bir Sicaklik sınıfı yaz — private bir _derece (Celsius) alanı olsun, negatif mutlak sıfırdan (-273.15) düşük bir değer atanmaya çalışıldığında reddeden bir setter yaz.
• [ ] BankaHesabi örneğindeki gibi, sadece getter'ı olan (setter'ı olmayan) bir "salt-okunur" alan tasarla ve doğrudan atama yapmaya çalışarak hatayı gözlemle.
• [ ] _ ile başlayan private bir alanı, aynı dosya içinde başka bir class'tan erişip erişemediğini test et (iki class'ı aynı dosyada tanımlayarak dene).
• [ ] Sadece getter ile hesaplanan bir "tam ad" veya benzeri bir birleşik özellik tanımla, doğrudan atama yapmaya çalışıp hatayı gözlemle.

Sıradaki konu: Bölüm 6 — Konu 31: Statik Üyeler (static)