• Söz dizimi: class AltSinif extends UstSinif. extends: “genişletir”.
• extends sonrasına yalnızca bir sınıf yazılabilir.
• Alt sınıf, üst sınıfın public ve protected üyelerini kendi üyesiymiş gibi kullanır.
• Üst sınıftaki aynı adlı alanı alt sınıfta yeniden tanımlamak onu gizler (hiding); iki ayrı değişken oluşur ve kafa karıştırır. Yapılmamalıdır.
• extends yazılmazsa sınıf, gizlice Object sınıfından türer.

• new Kedi(...) tek bir nesne oluşturur; üst sınıf için ayrı bir nesne oluşmaz.
• Nesnede üst sınıftan gelen alanlar için de yer ayrılır. private olsalar bile oradadırlar; yalnızca Kedi'nin kodu onlara adıyla erişemez.
• super ayrı bir nesne değildir: aynı nesnenin üst sınıf kısmına, üst sınıfın kodu üzerinden ulaşmanın yoludur.

Kanıt: yapıcıdaki getClass()

class Hayvan {
    Hayvan() {
        System.out.println("Hayvan() içinde: "
            + getClass().getSimpleName());
    }
}
class Kedi extends Hayvan { }
// main içinde:
new Kedi();
new Hayvan();

Hayvan() içinde: Kedi
Hayvan() içinde: Hayvan

Hayvan yapıcısı çalışırken bile nesnenin gerçek sınıfı Kedi'dir: yapıcı zinciri, aynı nesnenin kısımlarını sırayla kurar.

Önce: aynı kod iki yerde

class Ogrenci {
    private String ad;
    private int yas;
    private double ortalama;
    String kimlik() { return ad + " (" + yas + ")"; }
}
class Ogretmen {
    private String ad;
    private int yas;
    private String brans;
    String kimlik() { return ad + " (" + yas + ")"; }
}

Yaş biçimi değişirse iki sınıf da düzeltilmeli; biri unutulursa çıktılar tutarsız olur.

Sonra: ortak kısım Kisi'de

class Kisi {
    private String ad;
    private int yas;
    Kisi(String ad, int yas) { this.ad = ad; this.yas = yas; }
    String kimlik() { return ad + " (" + yas + ")"; }
}
class Ogrenci extends Kisi {
    private double ortalama;
    Ogrenci(String ad, int yas, double ortalama) {
        super(ad, yas);
        this.ortalama = ortalama;
    }
    @Override String kimlik() {
        return super.kimlik() + ", ort. " + ortalama;
    }
}   // Ogretmen de aynı biçimde: brans eklenir

Ece (20), ort. 3.4
Murat (41), Fizik

public class GelismisHesapMakinesi
        extends HesapMakinesi {
    // Yeni yetenek: üs alma
    public double us(double taban, int us) {
        double sonuc = 1.0;
        for (int i = 0; i < us; i++) {
            sonuc *= taban;
        }
        return sonuc;
    }
    // faktoriyel(int) benzer biçimde eklenir
}
// main içinde
GelismisHesapMakinesi h = new GelismisHesapMakinesi();
System.out.println(h.topla(5, 3));         // 8.0  (miras)
System.out.println(h.hafizayiGoruntule()); // 8.0  (miras)
System.out.println(h.us(2, 5));            // 32.0 (yeni)

class Kedi extends Hayvan {
    private boolean evcil;

    Kedi(String isim, boolean evcil) {
        super(isim);         // Hayvan(String)
        this.evcil = evcil;  // kendi verisi
    }

    @Override
    public String toString() {
        return super.toString()   // Hayvan'ınki
               + ", Evcil: " + evcil;
    }
}
// main içinde
System.out.println(new Kedi("Mavi", true));

Çıktı

İsim: Mavi, Sağlık: 100.0, Evcil: true

Hayvan'ın toString() metodu isim ve sağlık bilgisini döndürür; Kedi yalnızca kendi alanını ekler.

1) Üst sınıfta parametresiz yapıcı yok

class Hayvan {
    private String isim;
    Hayvan(String isim) { this.isim = isim; }
}
class Kedi extends Hayvan {
    Kedi(String isim) {
        // derleyici buraya super(); ekler
        System.out.println("Kedi");
    }
}

error: constructor Hayvan in class Hayvan
  cannot be applied to given types;
  required: String
  found:    no arguments

2) super(...) ilk satırda değil

Kedi(String isim) {
    System.out.println("Kedi");
    super(isim);
}

error: call to super must be first
  statement in constructor

Hiç yapıcı yazılmamış sınıfa derleyici parametresiz bir varsayılan yapıcı (default constructor) ekler; bir yapıcı yazıldığı anda bu eklenmez.

Geçersiz kılma (overriding): alt sınıfın, üst sınıftan kalıtımla aldığı bir metodu aynı imzayla yeniden yazarak kendi davranışını vermesidir.

• Ad ve parametre listesi aynı olmalı.
• Dönüş tipi aynı (veya onun alt tipi) olmalı.
• Erişim daraltılamaz: public metot public kalmalı.
• final, static ve private metotlar geçersiz kılınamaz.

class Sekil {
    public void ciz() {
        System.out.println("Şekil çiziliyor.");
    }
}
class Dikdortgen extends Sekil {
    @Override
    public void ciz() {
        System.out.println("Dikdörtgen çiziliyor.");
    }
}
// main içinde
new Sekil().ciz();
new Dikdortgen().ciz();

Şekil çiziliyor.
Dikdörtgen çiziliyor.

// alt sınıfta: void ciz()
error: ciz() in Dikdortgen cannot override
  ciz() in Sekil
  attempting to assign weaker access
  privileges; was public

// alt sınıfta: public int ciz()
error: ciz() in Dikdortgen cannot override
  ciz() in Sekil
  return type int is not compatible
  with void

d.ciz("Mavi") çıktısı

Mavi dikdörtgen çiziliyor.

Her iki kavram da çok biçimliliğin (polymorphism) temelidir.

• @Override bir etikettir (annotation): metodun, üst sınıftan kalıtımla alınan bir metodu geçersiz kıldığını bildirir.
• Derleyiciye bunu kontrol etmesini söyler: üst sınıfta böyle bir metot yoksa derleme hatası verir.
• Kodu daha okunabilir yapar; diğer geliştiricilere metodun üst sınıftan geldiğini gösterir.
• Zorunlu değildir, ama her zaman yazılması önerilir: yazım hatalarını hemen yakalar.

public class Dikdortgen extends Sekil {
    // miras alınan metodu geçersiz kıl
    @Override
    public void ciz() {
        System.out.println("Dikdörtgen çiziliyor.");
    }
}

Yazım hatası: Ciz (büyük C)

    @Override
    public void Ciz() { ... }

error: method does not override or implement
  a method from a supertype

@Override olmasaydı Ciz() sessizce yeni bir metot olurdu ve ciz() çağrıları hâlâ Sekil'in sürümünü çalıştırırdı.

class Hayvan {
    Hayvan yavrula() { return new Hayvan(); }
    public String toString() { return "Hayvan"; }
}
class Kedi extends Hayvan {
    @Override
    Kedi yavrula() { return new Kedi(); }  // alt tip
    void miyavla() { System.out.println("miyav"); }
    public String toString() { return "Kedi"; }
}
// main içinde:
Kedi k = new Kedi();
k.yavrula().miyavla();   // dönüşüm gerekmez
Hayvan h = k;
System.out.println(h.yavrula());

miyav
Kedi

• Geçersiz kılan metot, üst sınıftaki dönüş tipinin bir alt tipini döndürebilir: kovaryant dönüş tipi (covariant return type).
• Kedi referansıyla çağıran, sonucu doğrudan Kedi olarak alır; (Kedi) dönüşümüne gerek kalmaz.
• Hayvan referansıyla çağıran için söz bozulmaz: bir Kedi de bir Hayvan'dır.
• Yalnızca referans tiplerinde geçerlidir; int yerine long döndürmek olmaz.

İlgisiz tip: String yavrula()

error: yavrula() in Kedi cannot override
  yavrula() in Hayvan
  return type String is not compatible with Hayvan

class Ust {
    private void selam() { System.out.println("Ust.selam"); }
    void cagir() { selam(); }
}
class Alt extends Ust {
    void selam() { System.out.println("Alt.selam"); } // yeni
}
// main içinde:
Alt a = new Alt();
a.cagir();
a.selam();

Ust.selam
Alt.selam

Alt'taki metoda @Override eklenirse

error: method does not override or implement
  a method from a supertype

• private bir metot alt sınıfa görünmez; alt sınıfta aynı adla yazılan metot onunla ilgisiz, yeni bir metottur.
• Ust.cagir() içindeki selam() çağrısı derleme sırasında Ust'un kendi private metoduna bağlanır. Nesne bir Alt olsa da Ust.selam yazılır.
• @Override alışkanlığı bu yanılgıyı derleme anında ortaya çıkarır.

Urun[] sepet = {new Urun("Kalem", 50),
    new GidaUrunu("Ekmek", 10),
    new IndirimliUrun("Kulaklık", 1000, 0.25)};
for (Urun u : sepet) System.out.println(u);

Kalem: 60.0 TL
Ekmek: 10.1 TL
Kulaklık: 900.0 TL (%25 indirim)

• GidaUrunu yalnızca kdvOrani()'nı değiştirir; satisFiyati() ve toString() yazılmadığı hâlde %1 ile hesaplanır, çünkü Urun'un içindeki çağrı nesnenin sınıfına göre seçilir.
• IndirimliUrun üst sınıfın hesabını değiştirmez, genişletir: super.satisFiyati() sonucuna indirimi uygular. 1000 × 1,20 × 0,75 = 900.

package evcil;     // başka paket
import canli.Hayvan;

public class Kedi extends Hayvan {
    public Kedi(String isim) { super(isim); }
    public void uyu() {
        // protected alan: izin var
        System.out.println(isim + " uyuyor.");
        // saglik += 5;  // private: hata
        saglikEkle(5);   // protected metot
        System.out.println("Sağlık: "
                           + getSaglik());
    }
}

new Kedi("Mavi").uyu(); çıktısı

Mavi uyuyor.
Sağlık: 105.0

Yorum satırı açılırsa

error: saglik has private access in Hayvan

package evcil;
import canli.Hayvan;
public class Kedi extends Hayvan {
    public Kedi(String isim) { super(isim); }
    void karsilastir(Kedi k, Hayvan h) {
        System.out.println(isim);    // kendi alanı
        System.out.println(k.isim);  // Kedi üzerinden
        System.out.println(h.isim);  // Hayvan üzerinden
    }
}

evcil/Kedi.java:8: error: isim has protected access in Hayvan
        System.out.println(h.isim);

class Hayvan {
    public final void nefesAl() { ... }
}
class Kedi extends Hayvan {
    public void nefesAl() { ... }
}

error: nefesAl() in Kedi cannot override
  nefesAl() in Hayvan
  overridden method is final

final class Sabit { ... }
class Deneme extends Sabit { }

error: cannot inherit from final Sabit

error: cannot find symbol
  symbol:   method kislikMi()
  location: variable p of type Parca

Is-a (kalıtım, inheritance)

• Bir sınıfın başka bir sınıftan türetilmesidir; türetilen sınıf üst sınıfın bir türüdür.
• Alt sınıf nesnesi, üst sınıfın nesnesi gibi de kullanılabilir.

Has-a (oluşum, composition)

• Bir sınıfın başka bir sınıf tipinde alan içermesidir.
• Nesne, içinde diğer nesnelere referanslar tutar.

// Is-a ilişkisi (kalıtım)
public class Araba extends Arac {
    // Has-a ilişkisi (oluşum)
    private Motor motor;

    public Araba(int beygirGucu) {
        motor = new Motor(beygirGucu);
    }
    public void yolaCik() {
        motor.calistir();   // Motor'a devret
        hizlan(50);         // Arac'tan miras
        System.out.println("Hız: " + hiz
                           + " km/sa");
    }
}
// Motor: beygirGucu alanı ve calistir():
//   "Motor çalıştı: " + beygirGucu + " BG"

new Araba(110).yolaCik();

Motor çalıştı: 110 BG
Hız: 50 km/sa

class D extends B, C { }   // geçersiz

error: '{' expected

class SayanListe2 {
    private final Liste liste = new Liste(); // has-a
    private int eklemeSayisi = 0;
    void ekle(String s) {
        eklemeSayisi++;
        liste.ekle(s);            // iletir
    }
    void hepsiniEkle(String[] dizi) {
        eklemeSayisi += dizi.length;
        liste.hepsiniEkle(dizi);  // iletir
    }
    int getEklemeSayisi() { return eklemeSayisi; }
    int boyut() { return liste.boyut(); }
}

SayanListe2 l2 = new SayanListe2();
l2.hepsiniEkle(new String[] {"a", "b", "c"});
System.out.println(l2.getEklemeSayisi()
    + " " + l2.boyut());

3 3

• Yeni sınıf bir Liste'den türemez, bir Liste'ye sahiptir. Her metot önce kendi işini yapar, sonra çağrıyı içteki nesneye iletir (forwarding).
• liste.hepsiniEkle(...) içindeki ekle çağrıları düz bir Liste nesnesinde çalışır; SayanListe2'ye geri dönmez. Sayaç doğrudur: 3.
• Liste'nin iç ayrıntısı değişse de sonuç değişmez: bağlılık yalnızca public metotlaradır.
• Bedeli: SayanListe2 bir Liste beklenen yere verilemez. Gerekirse ikisi ortak bir arayüzü uygular.

class Dikdortgen {
    protected int en, boy;
    void setEn(int en) { this.en = en; }
    void setBoy(int boy) { this.boy = boy; }
    int alan() { return en * boy; }
}
class Kare extends Dikdortgen {
    @Override void setEn(int k) { en = k; boy = k; }
    @Override void setBoy(int k) { en = k; boy = k; }
}
static void genislet(Dikdortgen d) {
    d.setEn(5);
    d.setBoy(4);
    System.out.println("Beklenen 20, bulunan "
        + d.alan());
}
// main içinde:
genislet(new Dikdortgen());
genislet(new Kare());

Beklenen 20, bulunan 20
Beklenen 20, bulunan 16

• Liskov yerine koyma ilkesi (Liskov substitution principle): üst sınıf tipiyle yazılmış kod, bir alt sınıfın nesnesiyle de doğru çalışmalıdır. Derlenmesi yetmez.
• Matematikte her kare bir dikdörtgendir. Ama bu Dikdortgen sınıfı “en ve boy birbirinden bağımsız değişir” sözünü verir; Kare bu sözü tutamaz.
• genislet hatalı değildir; hata, sözü bozan alt sınıftadır.
• Çözümler: Kare'yi Dikdortgen'den türetmemek (ikisi de Sekil'den türer) ya da sınıfları değiştirilemez yapmak.

• Her sınıf java.lang.Object sınıfından türer; extends yazılmamışsa dolaylı olarak.
• Bu yüzden her nesnede aşağıdaki metotlar hazır bulunur.
• Varsayılan sürümleri genellikle işimize yaramaz; anlamlı sınıflarda geçersiz kılınırlar.

class Nokta { }
// derleyicinin gördüğü:
class Nokta extends Object { }

Geçersiz kılınmadan

class Nokta {
    private int x, y;
    Nokta(int x, int y) {
        this.x = x; this.y = y;
    }
}
// main içinde
System.out.println(new Nokta(3, 4));

Nokta@28a418fc

@ sonrası değer her çalıştırmada değişebilir; okunaklı değildir. null bir referans yazdırılırsa toString çağrılmaz, null yazılır.

Geçersiz kılınarak

class Nokta {
    private int x, y;
    Nokta(int x, int y) {
        this.x = x; this.y = y;
    }
    @Override
    public String toString() {
        return "Nokta[x=" + x + ", y=" + y + "]";
    }
}
// main içinde
Nokta n = new Nokta(3, 4);
System.out.println(n);
System.out.println("Konum: " + n);

Nokta[x=3, y=4]
Konum: Nokta[x=3, y=4]

• public boolean equals(Object other): iki nesnenin eşdeğer olup olmadığını söyler.
• Varsayılan olarak yalnızca referansları karşılaştırır: geçersiz kılınmazsa == işleci gibi davranır.
• Geçersiz kılınarak davranışı değiştirilir: metot iki nesnenin durumunu (alanlarını) karşılaştırmalı ve eşitse true dönmelidir.
• Parametre Object tipindedir; hatalı durumları engellemek için önce tip kontrolü yapılmalıdır.

equals sözleşmesi

instanceof ile tip kontrolü

public boolean equals(Object nesne) {
    if (nesne instanceof Nokta) {
        // nesne bir Nokta nesnesidir;
        // dönüştürüp karşılaştır
        Nokta diger = (Nokta) nesne;
        return x == diger.x && y == diger.y;
    } else {
        // nesne bir Nokta değildir;
        // eşit olamaz
        return false;
    }
}

• Parametre tipi Object olmalıdır; equals(Nokta n) yazmak geçersiz kılma değil, aşırı yüklemedir.
• Dönüşüm ((Nokta) nesne) yalnızca tip kontrolünden sonra güvenlidir.

Deneme

Nokta a = new Nokta(3, 4);
Nokta b = new Nokta(3, 4);
System.out.println(a == b);
System.out.println(a.equals(b));
System.out.println(a.equals("3,4"));
System.out.println(a.equals(null));

false
true
false
false

• this == obj: aynı nesneyse hemen true (hızlı yol).
• getClass() nesnenin gerçek sınıfını verir; iki tarafın sınıfı birebir aynı olmalıdır.
• İlkel tipler (int yas) == ile, nesne tipindeki alanlar (String ad) equals ile karşılaştırılır.