Nesne yönelimli programlama: kalıtım, dynamic binding ve vtable

Nesne yönelimli programlama (OOP) üç fikrin birleşimidir: abstract data type (geçen hafta), kalıtım (inheritance) ve dynamic binding. Bu sayfanın sınav karşılığı iki tür soru: “Hangi metot çalışır, ne basılır?” (override, overload, hiding, yapıcı sırası) ve “Dynamic binding nasıl uygulanır?” (vtable). İlk türde kural setini bilmek yeter.

Altın kurallar:

1. Override edilen instance metot nesnenin gerçek sınıfına göre seçilir.
2. Overload seçimi derlemede, argümanın bildirilen tipine göre yapılır.
3. Alanlar ve static metotlar dinamik bağlanmaz, değişkenin tipine bakılır.
4. Üst sınıfın yapıcısı önce çalışır.
5. vtable: üst sınıfınkini kopyala, override edileni değiştir, yeniyi sona ekle.

Neden kalıtım?

ADT’ler yeniden kullanılabilir ama neredeyse her zaman küçük değişiklik gerekir; kodu kopyalayıp değiştirmek bakım kâbusu. Kalıtım, var olan bir sınıftan (superclass, parent) yeni bir sınıf (subclass, derived) türetir: alt sınıf üst sınıfın alanlarını ve metotlarını alır, yenilerini ekler, bazılarını override eder.

Terimler:

• Class: ADT. Object: sınıfın bir örneği (instance).
• Method: sınıfta tanımlı alt program. Message: bir nesneye metot çağrısı göndermek.
• Instance variable: her nesnenin kendi kopyası. Class variable (Java static): sınıf başına bir tane.
• Alt sınıfın nesnesi üst sınıfın beklendiği her yerde kullanılabiliyorsa alt sınıf bir subtype’tır. Java’da public kalıtım bunu sağlar.

Kalıtımın dezavantajı: sınıflar arasında bağımlılık yaratır. Üst sınıftaki bir değişiklik tüm alt sınıfları etkileyebilir.

Dynamic binding

Üst sınıf tipinde bir referans, alt sınıflardan birinin nesnesini gösterebilir. Çağrılan metot override edilmişse hangi sürüm çalışır? Nesnenin gerçek sınıfınınki. Bu karar çalışma zamanında verilir: dynamic binding (polimorfizm).

Animal a = new Dog();
System.out.println(a.speak() + " " + a.name + " " + a.kind() + " " + a.intro());

Woof animal Animal I say Woof

Faydası: for (Animal an : zoo) an.speak(); kodu, ileride eklenecek Cat sınıfıyla da değişmeden çalışır.

Override ile overload karışınca

class P { void m(Object o) {...P.Object} void m(String s) {...P.String} }
class Q extends P { @Override void m(Object o) {...Q.Object} }
P p = new Q(); Object o = "text";
p.m(o); p.m("text");

Q.Object P.String

Tarif: (1) derleme zamanı: p’nin tipi P, argümanın bildirilen tipine göre P’deki imzalardan biri seçilir. o Object tipinde, içinde String olsa bile m(Object) seçilir. (2) çalışma zamanı: seçilen imzanın nesnenin sınıfındaki (Q) sürümü çalışır.

Yapıcı sırası

class A { A() { System.out.print("A "); show(); } void show() { ... "A.show" } }
class B extends A { int v = 7; B() { super(); System.out.print("B "); }
                    @Override void show() { ... "B.show v=" + v } }
new B();

A B.show v=0 B

Üst sınıf yapıcısı önce çalışır, alt sınıfın alan başlatıcıları ondan sonra. A’nın yapıcısındaki show() dinamik bağlanır ve henüz başlatılmamış v’yi (0) görür.

super ve private

X z = new Z();      // Z.hi → "Z+" + super.hi() → Y.hi → "Y+" + super.hi() → X.hi
System.out.println(z.hi());
System.out.println(new Derived().call());   // private who() override edilmez

Z+Y+X
Base

super.m() her zaman doğrudan üst sınıfın sürümüne gider. private metotlar miras alınmaz; aynı adlı metot alt sınıfta ayrı bir metottur.

Dil tasarım soruları

C++‘ta stack’teki bir nesne üst sınıf tipindeki bir değişkene değerle atanırsa alt sınıfın alanları kesilir (object slicing). Java’da tüm nesneler heap’te ve referansla erişildiği için bu sorun yok.

Abstract sınıf ve çoklu kalıtım

abstract class Shape { abstract double area(); }
Shape s = new Shape();     // error: Shape is abstract; cannot be instantiated

Çoklu kalıtımda iki üst sınıf aynı imzalı iki metot getirirse (diamond problem) hangisi seçilir? C++ programcıya Walker::move ile nitelemeyi zorunlu tutar. Java sınıflarda çoklu kalıtıma izin vermez; interface’lerdeki default metotlar çakışırsa derleyici override ister:

interface Walker { default String move() { return "walk"; } }
interface Swimmer { default String move() { return "swim"; } }
class Duck implements Walker, Swimmer {
    public String move() { return Walker.super.move() + "&" + Swimmer.super.move(); }
}

walk&swim

Uygulama: CIR ve vtable

Class instance record (CIR), bir nesnenin bellekteki yapısıdır; record gibi derlemede belirlenir. Alt sınıfın CIR’i, üst sınıfın CIR’ini kopyalar ve kendi alanlarını sona ekler. Böylece üst sınıfın alanları her alt sınıf nesnesinde aynı ofsettedir.

Dinamik bağlanan metotlar için her sınıfın bir virtual method table’ı (vtable) vardır: sınıftaki dinamik bağlanan her metot için kodun adresi. Her CIR, sınıfının vtable’ını gösteren bir pointer taşır.

class Shape  { area(); draw(); name(); }
class Circle extends Shape  { override area(); new radius(); }
class Ring   extends Circle { override draw(); override area(); }

slot    Shape vtable    Circle vtable    Ring vtable
0       Shape.area      Circle.area      Ring.area
1       Shape.draw      Shape.draw       Ring.draw
2       Shape.name      Shape.name       Shape.name
3       -               Circle.radius    Circle.radius

for (Shape s : new Shape[]{ new Shape(), new Circle(), new Ring() })
    System.out.println(s.area() + " " + s.draw() + " " + s.name());

Shape.area Shape.draw Shape.name
Circle.area Shape.draw Shape.name
Ring.area Ring.draw Shape.name

Derleyici s.area() çağrısını “nesnenin vtable’ında slot 0’daki adrese git” koduna çevirir. Hangi sınıf olursa olsun slot 0 hep area’dır; çalışmada sadece hangi tablonun okunduğu değişir. Maliyet: her çağrıda bir dolaylı adresleme. Statik bağlanan metotlar (C++ non-virtual, Java private/final) bu maliyeti ödemez ve vtable’da yer almaz.

Çoklu kalıtımda iş karmaşıklaşır: nesnenin her üst sınıf için ayrı bir vtable göstergesi ve parçası olur.

Sık yapılan hatalar

class Animal {
    String name = "animal";
    String speak() { return "..."; }
    static String kind() { return "Animal"; }
    String intro() { return "I say " + speak(); }
}
class Dog extends Animal {
    String name = "dog";
    @Override String speak() { return "Woof"; }
    static String kind() { return "Dog"; }
}
// in main:
Animal a = new Dog();
System.out.println(a.speak() + " " + a.name + " " + a.kind() + " " + a.intro());

class A { A() { System.out.print("A "); show(); }
          void show() { System.out.print("A.show "); } }
class B extends A { int v = 7;
          B() { super(); System.out.print("B "); }
          @Override void show() { System.out.print("B.show v=" + v + " "); } }
// in main:
new B();

class P { void m(Object o) { System.out.print("P.Object "); }
          void m(String s) { System.out.print("P.String "); } }
class Q extends P { @Override void m(Object o) { System.out.print("Q.Object "); } }
// in main:
P p = new Q();
Object o = "text";
p.m(o);
p.m("text");

class Shape  { area(); draw(); name(); }
class Circle extends Shape  { override area(); new radius(); }
class Ring   extends Circle { override draw(); override area(); }

class Base { private String who() { return "Base"; }
             String call() { return who(); } }
class Derived extends Base { private String who() { return "Derived"; } }
// in main:
System.out.println(new Derived().call());

class X { String hi() { return "X"; } }
class Y extends X { @Override String hi() { return "Y+" + super.hi(); } }
class Z extends Y { @Override String hi() { return "Z+" + super.hi(); } }
// in main:
X z = new Z();
System.out.println(z.hi());

abstract class Shape { abstract double area(); }
// in main:
Shape s = new Shape();

Animal[] zoo = { new Animal(), new Dog(), new Dog() };
int woofs = 0;
for (Animal an : zoo) if (an.speak().equals("Woof")) woofs++;
System.out.println(woofs + " " + (zoo[1] instanceof Animal) + " " + (zoo[0] instanceof Dog));