---
baslik: Sınıflar ve metotlar
bolum: Kendi türlerin
ozet: sinif, kurucu (kur), self ile metotlar ve kalıtım
---

Yapı veriyi bir arada tutar. Bir banka hesabı ise yalnız veri değildir: para yatırılır, çekilir, yetersiz bakiyede işlem reddedilir. Davranışı olan nesneler için `sinif` kullanırsın.

## Sınıf, kurucu ve self

`sinif` tanımı yapıya benzer. Farkları:

- `fonksiyon kur(self, ...)` bir **kurucudur**: nesne oluşturulurken çalışır.
- Metotların ilk parametresi `self`'tir: "bu nesnenin kendisi" demektir. Alanlara `self.alan` ile ulaşırsın.

```kbl
sinif Hesap:
    sahip = ""
    bakiye = 0.0

    fonksiyon kur(self, kisi: metin, ilk: ondalik):
        self.sahip = kisi
        self.bakiye = ilk

    fonksiyon yatir(self, miktar: ondalik):
        self.bakiye += miktar

    fonksiyon ozet(self) -> metin:
        don f"{self.sahip}: {self.bakiye:.2f} TL"

h = Hesap("Ayşe", 100.0)
h.yatir(50.0)
yazdir(h.ozet())
```
```cikti
Ayşe: 150.00 TL
```

`Hesap("Ayşe", 100.0)` yazınca `kur(self, "Ayşe", 100.0)` çağrılır.

## Metot nesneyi kalıcı olarak değiştirir

Metot kendi nesnesinin alanlarını değiştirdiğinde değişiklik kalıcıdır. Bir metot ayrıca değer de döndürebilir.

```kbl
sinif Hesap:
    bakiye = 0.0

    fonksiyon kur(self, ilk: ondalik):
        self.bakiye = ilk

    fonksiyon cek(self, miktar: ondalik) -> mantik:
        eger miktar > self.bakiye:
            don yanlis
        self.bakiye -= miktar
        don dogru

h = Hesap(100.0)
yazdir(h.cek(30.0))
yazdir(h.cek(500.0))
yazdir(h.bakiye)
```
```cikti
doğru
yanlış
70.0
```

## Her nesnenin kendi alanları vardır

Aynı sınıftan oluşturulan nesneler birbirinden bağımsızdır.

```kbl
sinif Sayac:
    adet = 0

    fonksiyon kur(self, baslangic: sayi):
        self.adet = baslangic

    fonksiyon artir(self):
        self.adet += 1

a = Sayac(0)
b = Sayac(10)
a.artir()
a.artir()
b.artir()
yazdir(f"a: {a.adet}, b: {b.adet}")
```
```cikti
a: 2, b: 11
```

## Metot başka bir nesne alabilir

```kbl
yapi Kitap:
    ad = ""
    sayfa = 0

sinif Okuyucu:
    ad = ""
    okunan_sayfa = 0
    kitap_sayisi = 0

    fonksiyon kur(self, isim: metin):
        self.ad = isim

    fonksiyon bitirdi(self, k: Kitap):
        self.okunan_sayfa += k.sayfa
        self.kitap_sayisi += 1

    fonksiyon rapor(self) -> metin:
        don f"{self.ad}: {self.kitap_sayisi} kitap, {self.okunan_sayfa} sayfa"

elif = Okuyucu("Elif")
elif.bitirdi(Kitap("Çalıkuşu", 544))
elif.bitirdi(Kitap("Kuyucaklı Yusuf", 232))
yazdir(elif.rapor())
```
```cikti
Elif: 2 kitap, 776 sayfa
```

> **Dikkat:** Kurucunun adı mutlaka `kur`, ilk parametresi `self` olmalıdır. Parametre adını alanla aynı seçmek yerine farklı bir ad ver (`self.ad = isim`); kod daha kolay okunur.

## Kalıtım

Bir sınıf başka bir sınıfın alanlarını ve metotlarını devralabilir. Taban sınıfın adı parantez içinde yazılır. Türev sınıf bir metodu yeniden tanımlarsa (geçersiz kılma) kendi sürümü kullanılır.

```kbl
sinif Hayvan:
    ad = ""

    fonksiyon kur(self, isim: metin):
        self.ad = isim

    fonksiyon ses(self) -> metin:
        don "..."

    fonksiyon tanit(self) -> metin:
        don f"Ben {self.ad}."

sinif Kedi(Hayvan):
    fonksiyon ses(self) -> metin:
        don "Miyav!"

k = Kedi("Tekir")
yazdir(k.tanit())
yazdir(k.ses())
```
```cikti
Ben Tekir.
Miyav!
```

`Kedi`'nin kendi `kur`'u yok; `Hayvan`'ınkini devraldı. `tanit` de devralındı, `ses` ise yeniden tanımlandı.

> **İpucu:** Kalıtımda türev sınıfın kendi alanları ve kurucusu varsa, kurucusunun ilk satırında `ust.kur(...)` ile taban sınıfı kurar. Başlangıçta kalıtıma çok yaslanma; çoğu iş için yapılar ve basit sınıflar yeter.

## Alıştırma

```alistirma
`Termometre` sınıfı yaz: `olcumler` alanı (boş sayı listesi, `liste<sayi> = []`), `ekle(self, d: sayi)` metodu ve ortalamayı döndüren `ortalama(self) -> ondalik` metodu olsun. Verilen ölçümlerle ortalamayı 1 basamakla yazdır.
%%%
# buraya yaz

t = Termometre()
t.ekle(18)
t.ekle(24)
t.ekle(27)
yazdir(f"{t.ortalama():.1f}")
%%%
sinif Termometre:
    olcumler: liste<sayi> = []

    fonksiyon ekle(self, d: sayi):
        self.olcumler.ekle(d)

    fonksiyon ortalama(self) -> ondalik:
        toplam = 0
        dongu o icinde self.olcumler:
            toplam += o
        don toplam / self.olcumler.uzunluk()

t = Termometre()
t.ekle(18)
t.ekle(24)
t.ekle(27)
yazdir(f"{t.ortalama():.1f}")
%%%
23.0
```

```alistirma
Verilen `Hesap` sınıfına `cek(self, miktar: sayi) -> mantik` metodunu ekle: bakiye yetmezse `yanlis` döndürsün ve bakiyeye dokunmasın. Programın çıktısı aşağıdaki gibi olmalı.
%%%
sinif Hesap:
    bakiye = 0

    fonksiyon kur(self, ilk: sayi):
        self.bakiye = ilk

    # buraya yaz

h = Hesap(200)
yazdir(h.cek(150))
yazdir(h.cek(100))
yazdir(h.bakiye)
%%%
sinif Hesap:
    bakiye = 0

    fonksiyon kur(self, ilk: sayi):
        self.bakiye = ilk

    fonksiyon cek(self, miktar: sayi) -> mantik:
        eger miktar > self.bakiye:
            don yanlis
        self.bakiye -= miktar
        don dogru

h = Hesap(200)
yazdir(h.cek(150))
yazdir(h.cek(100))
yazdir(h.bakiye)
%%%
doğru
yanlış
50
```