Çok biçimlilik: dynamic binding, upcasting, downcasting

Çok biçimlilik (polymorphism), “aynı çağrı, farklı nesnede farklı davranış” demek. Bir Shape dizisine daire, kare, üçgen koyarsın; hepsine area() dersin, her biri kendi alanını hesaplar. Sınavın en ağır çıktı soruları bu konudan gelir: üst sınıf tipindeki değişken, alt sınıf nesnesi, araya super ve cast serpiştirilmiş kod. Hepsini iki soru sorarak çözersin: derleyici neye izin verir ve çalışırken hangi sürüm çalışır.

Altın kurallar:

1. Derleyici değişkenin tipine bakar (static type). Değişkenin tipinde olmayan metodu çağıramazsın.
2. JVM nesnenin tipine bakar (dynamic type). Override edilmiş metotlarda nesnenin sürümü çalışır.
3. Upcasting otomatik, downcasting cast ister. Cast yanlışsa çalışırken ClassCastException.
4. Dynamic binding sadece override edilmiş instance metotlarda. Alanlar, static ve private metotlar değişkenin tipine göre seçilir.

Static tip ve dynamic tip

Animal a = new Lion();

Bu satırda iki tip var. a değişkeninin tipi Animal (static tip, derleme zamanında belli). Gösterdiği nesnenin tipi Lion (dynamic tip, çalışma zamanında belli). Bu atama geçerli çünkü her Lion bir Animal’dır (is-a). Tersine Lion l = new Animal(); derlenmez.

Örneklerde kullanacağımız hiyerarşi:

class Animal {
    void speak() { System.out.println("Animal speaks"); }
}
class Cat extends Animal {
    @Override void speak() { System.out.println("Meow"); }
    void purr() { System.out.println("Purr"); }
}
class Lion extends Cat {
    @Override void speak() { System.out.println("Roar"); }
}

Dynamic binding

Override edilmiş bir metodu çağırdığında hangi sürümün çalışacağı programın çalıştığı anda, nesneye bakılarak belirlenir. Buna dynamic binding (ya da late binding) denir.

Animal a = new Lion();
a.speak();
Animal b = new Cat();
b.speak();
((Cat) b).purr();

Roar
Meow
Purr

Gerçek gücü dizilerde ve metot parametrelerinde görürsün. Aşağıda Shape.toString() sadece bir kez yazıldı ama içindeki name() ve area() her nesnede farklı çalışıyor:

class Shape {
    String name() { return "Shape"; }
    double area() { return 0; }
    public String toString() { return name() + " area=" + area(); }
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override String name() { return "Circle"; }
    @Override double area() { return Math.PI * r * r; }
    double diameter() { return 2 * r; }
}
class Square extends Shape {
    double s;
    Square(double s) { this.s = s; }
    @Override String name() { return "Square"; }
    @Override double area() { return s * s; }
}

Shape[] shapes = { new Circle(1), new Square(2), new Shape() };
for (Shape s : shapes) System.out.println(s);

Circle area=3.141592653589793
Square area=4.0
Shape area=0.0

Yeni bir Triangle sınıfı eklersen bu döngüye dokunmana gerek yok. Polimorfizmin asıl faydası bu: kod üst tiple yazılır, yeni alt tipler eklendikçe çalışmaya devam eder.

super ile karışık çağrılar

super.a() sadece o tek çağrıyı üst sınıfın sürümüne yönlendirir. Üst sınıfın metodu içinde başka bir metot çağrılırsa (b() aslında this.b()), this hâlâ alt sınıf nesnesidir ve yine dynamic binding devreye girer.

class First {
    void a() { System.out.println("First.a"); b(); }
    void b() { System.out.println("First.b"); }
}
class Second extends First {
    @Override void a() { System.out.println("Second.a"); super.a(); }
    @Override void b() { System.out.println("Second.b"); }
}
First f = new Second();
f.a();

Second.a
First.a
Second.b

f.a()          nesne Second → Second.a        "Second.a"
  super.a()    açıkça First.a                  "First.a"
    this.b()   this = Second nesnesi → Second.b "Second.b"

Upcasting ve downcasting

Downcasting’de iki ayrı kontrol olur:

1. Derleme zamanı: Tipler aynı kalıtım çizgisinde mi? (Cat) animalRef derlenir. Kardeş sınıflar arasında, örneğin (Dog) catRef, derlenmez: incompatible types: Cat cannot be converted to Dog.
2. Çalışma zamanı: Nesne gerçekten o tipte mi (ya da alt tipinde mi)? Değilse ClassCastException.

try {
    Animal an = new Animal();
    Cat ct = (Cat) an;     // derlenir, ama nesne Cat değil
    ct.purr();
} catch (ClassCastException e) {
    System.out.println("ClassCastException");
}

ClassCastException

TUZAK · derleniyor diye çalışacak sanma. “Find the error” sorularında önce derleme hatası mı çalışma hatası mı olduğunu ayır. Animal’dan Cat’e cast her zaman derlenir; patlayıp patlamayacağı nesneye bağlı.

instanceof

x instanceof T, x’in gösterdiği nesne T tipinde ya da T’nin bir alt tipinde ise true döner. Downcast’ten önce kontrol için kullanılır.

Animal l = new Lion();
System.out.println(l instanceof Animal);
System.out.println(l instanceof Cat);
System.out.println(l instanceof Lion);
Animal plain = new Animal();
System.out.println(plain instanceof Cat);
Animal nul = null;
System.out.println(nul instanceof Animal);

true
true
true
false
false

Klasik kalıp ve Java 16’dan beri gelen kısa yazımı (pattern matching):

static void describe(Shape s) {
    System.out.print(s.name());
    if (s instanceof Circle) {            // klasik
        Circle c = (Circle) s;
        System.out.print(" d=" + c.diameter());
    }
    System.out.println();
}
describe(new Circle(1.5));
describe(new Square(3));

Shape sh = new Circle(2);
if (sh instanceof Circle cc)              // kontrol + cast tek satırda
    System.out.println("r=" + cc.r);

Circle d=3.0
Square
r=2.0

İPUCU · instanceof zinciri kötü kokar. if (s instanceof Circle) ... else if (s instanceof Square) ... yazıyorsan genelde o işi Shape’e bir metot olarak koyup override etmen gerekir. Sınavdaki “use polymorphism” ifadesi tam olarak bunu ister.

Overload ve override bir arada

En zor çıktı sorusu tipi. İki adımda çöz:

1. Derleme zamanı, imza seçimi: argümanların static tiplerine bakarak hangi parametre listesinin çağrılacağı belirlenir (overload).
2. Çalışma zamanı, sürüm seçimi: o imzanın, nesnenin gerçek sınıfındaki override edilmiş sürümü çalışır.

class X {
    void m(Object o) { System.out.println("X.m(Object)"); }
    void m(String s) { System.out.println("X.m(String)"); }
}
class Y extends X {
    @Override void m(Object o) { System.out.println("Y.m(Object)"); }
}
X obj = new Y();
obj.m("hi");          // imza m(String); Y onu override etmedi
Object o = "hi";
obj.m(o);             // imza m(Object); Y override etti
new X().m(o);

X.m(String)
Y.m(Object)
X.m(Object)

o gerçekte bir String tutsa da, imza seçiminde değişkenin tipi (Object) kullanılır.

Dynamic binding olmayan şeyler

Animal.info();        // static
Animal c2 = new Cat();
c2.info();            // nesne Cat ama static: Animal'ınki

Animal info
Animal info

Sık yapılan hatalar

class Animal { void speak() { System.out.println("Animal speaks"); } }
class Cat extends Animal { @Override void speak() { System.out.println("Meow"); } }
class Lion extends Cat { @Override void speak() { System.out.println("Roar"); } }
// in main:
Animal a = new Lion();
a.speak();

class Animal { void speak() { } }
class Cat extends Animal { void purr() { } }
// in main:
Animal a = new Cat();
a.purr();

Animal a = new Animal();
Cat c = a;

Animal an = new Animal();
Cat ct = (Cat) an;
ct.purr();

class Animal { }
class Cat extends Animal { }
class Dog extends Animal { }
// in main:
Cat c = new Cat();
Dog d = (Dog) c;

Animal l = new Lion();          // Lion extends Cat extends Animal
System.out.println(l instanceof Cat);
Animal plain = new Animal();
System.out.println(plain instanceof Cat);
Animal nul = null;
System.out.println(nul instanceof Animal);

class First {
    void a() { System.out.println("First.a"); b(); }
    void b() { System.out.println("First.b"); }
}
class Second extends First {
    @Override void a() { System.out.println("Second.a"); super.a(); }
    @Override void b() { System.out.println("Second.b"); }
}
// in main:
First f = new Second();
f.a();

class X {
    void m(Object o) { System.out.println("X.m(Object)"); }
    void m(String s) { System.out.println("X.m(String)"); }
}
class Y extends X {
    @Override void m(Object o) { System.out.println("Y.m(Object)"); }
}
// in main:
X obj = new Y();
obj.m("hi");
Object o = "hi";
obj.m(o);

class Animal { static void info() { System.out.println("Animal info"); } }
class Cat extends Animal { static void info() { System.out.println("Cat info"); } }
// in main:
Animal c = new Cat();
c.info();

Shape[] shapes = { new Circle(1), new Square(2), new Shape() };
for (Shape s : shapes) System.out.println(s);
// Shape.toString() returns name() + " area=" + area();
// Circle and Square override name() and area(), Shape returns "Shape" and 0

public static double totalArea(Shape[] shapes) {
    double sum = 0;
    for (Shape s : shapes) {
        sum += s.area();     // dynamic binding
    }
    return sum;
}