Java'da Polimorfizm: Tek Arayüz, Çok Biçim

Tek Referans, Çok Tür

Polimorfizm, kalıtımın ve arayüzlerin getirisidir. Bir üst tür (veya bir arayüz) olarak tanımlanmış tek bir değişkenin herhangi bir alt türden nesneyi tutabilmesi ve üzerinde bir metot çağırdığınızda Java'nın değişkenin bildirilen türünün ima ettiği sürümü değil, nesnenin gerçek sınıfına ait sürümü çalıştırması anlamına gelir.

Kalıtım sayfasında temeli zaten görmüştünüz: bir alt sınıf, üst sınıfından bir metodu ezer. Polimorfizm, o ezmeyi değerli kılan şeydir - genel türe karşı kod yazmanıza ve her somut nesnenin kendi biçiminde davranmasına izin verir.

class Animal {
    String speak() { return "..."; }
}

class Dog extends Animal {
    String speak() { return "Woof"; }
}

class Cat extends Animal {
    String speak() { return "Meow"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // bir alt nesne tutan üst tür referansı
        Animal b = new Cat();

        System.out.println(a.speak());   // Woof
        System.out.println(b.speak());   // Meow
    }
}

Hem a hem de b Animal olarak bildirilmiştir, ancak her biri kendi sesini yazdırır. Bu seçim, gerçek nesneye göre çalışma zamanında gerçekleşir.

Dinamik Metot Çağrımı

Bunun arkasındaki mekanizma dinamik metot çağrımıdır (dynamic method dispatch): ezilen bir örnek metodu için JVM, hangi gerçeklemenin çağrılacağına karar vermek üzere nesnenin çalışma zamanı sınıfına bakar. Derleyici yalnızca metodun bildirilen türde var olduğunu kontrol eder; asıl seçim, program çalışana kadar ertelenir.

Bir döngünün, her birinin ne olduğunu hiç sormadan tüm tür karışımıyla baş edebilmesini sağlayan şey budur:

import java.util.List;

class Shape {
    double area() { return 0; }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Square(2), new Circle(3));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // her çağrı gerçek alt sınıfa yönlendirilir
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Döngü yalnızca Shape'i bilir. Daha sonra bir Triangle extends Shape ekleyin, bu kod değişmeden çalışmaya devam eder - bütün mesele budur. Kod, somut tür listesine değil soyutlamaya bağlıdır.

Upcasting ve Downcasting

Bir Dog'u bir Animal değişkeninde saklamak upcasting'tir - hiyerarşide daha genel bir türe doğru yukarı çıkmak. Her zaman güvenlidir ve Java bunu örtük olarak yapar, çünkü her Dog bir Animal'dır (is a).

Ters yöne gitmek downcasting'tir - bir üst referansı alıp onu belirli bir alt tür gibi ele almak. Bu yalnızca nesne gerçekten o alt türse geçerlidir, bu yüzden cast'i açıkça yazmanız gerekir ve yanılırsanız bir ClassCastException riskine girersiniz:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal { }

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // upcast - örtük, güvenli

        Dog d = (Dog) a;        // downcast - açık, geçerli çünkü a gerçekten bir Dog
        d.fetch();

        Animal c = new Cat();
        Dog wrong = (Dog) c;    // derlenir ama çalışma zamanında ClassCastException fırlatır
        wrong.fetch();
    }
}

Son cast sorunsuz derlenir - derleyici yanlış olduğunu kanıtlayamaz - ama çalışırken patlar çünkü bir Cat bir Dog değildir. Asla körü körüne downcast yapmayın.

Downcast'leri instanceof ile Koruyun

Downcasting yapmadan önce gerçek türü instanceof ile kontrol edin. Modern Java, sonucu aynı ifadede bağlamanıza izin verir (instanceof için desen eşleme), böylece ayrı cast'ten kurtulursunuz:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal {
    void scratch() { System.out.println("scratching"); }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Dog(), new Cat(), new Dog() };

        for (Animal animal : animals) {
            if (animal instanceof Dog dog) {     // türü kontrol eder VE dog'a bağlar
                dog.fetch();
            } else if (animal instanceof Cat cat) {
                cat.scratch();
            }
        }
    }
}

instanceof, null için false döndürür, bu yüzden bu kontrol sizi bir NullPointerException'dan da korur. Bununla birlikte, uzun instanceof zincirleri yazdığınızı fark ederseniz, bu genellikle davranışın ezilmiş bir metot olarak sınıfların içine ait olduğunun bir işaretidir - dallanmayı sizin için polimorfizm yapsın.

Overriding ve Overloading

Bu ikisi kulağa benzer gelir ama birbiriyle ilgisizdir ve onları karıştırmak klasik bir kafa karışıklığı kaynağıdır.

Overriding (ezme), bir alt sınıfın üst sınıf metodunu birebir aynı imzayla değiştirmesidir. Nesnenin türüne göre çalışma zamanında çözülür - kullanageldiğimiz polimorfizm budur.

Overloading (aşırı yükleme), tek bir sınıfın aynı ada sahip ancak parametre listeleri farklı birden çok metoda sahip olmasıdır. Argüman türlerine göre derleme zamanında çözülür ve hiçbir çalışma zamanı çağrımı içermez:

public class Main {
    static String describe(int x)    { return "int: " + x; }
    static String describe(double x) { return "double: " + x; }
    static String describe(String x) { return "String: " + x; }

    public static void main(String[] args) {
        System.out.println(describe(5));      // int: 5
        System.out.println(describe(5.0));    // double: 5.0
        System.out.println(describe("five")); // String: five
    }
}

Derleyici, eşleşen describe'ı tamamen argümanın statik türünden seçer. Burada hiçbir üst/alt nesne yer almaz, dolayısıyla bu çalışma zamanı polimorfizmi değildir - yalnızca bir metot adını yeniden kullanır.

Sık Yapılan Bir Hata: Alanlar Polimorfik Değildir

Yalnızca örnek metotları çalışma zamanında çağrılır. Alanlar ve statik metotlar bildirilen türe göre çözülür ve bu birçok kişiyi yanıltır:

class Parent {
    String label = "parent";
    String name() { return "Parent"; }
}

class Child extends Parent {
    String label = "child";          // gizler, ezmez
    String name() { return "Child"; }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.label);    // parent  - alan bildirilen türü kullanır
        System.out.println(p.name());   // Child   - metot çalışma zamanı türünü kullanır
    }
}

p.name(), Child'ın sürümünü çalıştırır (polimorfizm), ama p.label, Parent'ın alanını okur, çünkü alanlar ezilmez, gizlenir. Çözüm basittir: alanları private tutun ve onlara yalnızca metotlar üzerinden erişin, böylece polimorfik çağrı her zaman kazanır.

Sıradaki: Erişim Belirleyicileri

Polimorfizm yalnızca alt sınıflar doğru üyeleri görüp ezebildiğinde ve kodunuzun geri kalanı içeri uzanıp değişmezleri (invariant) bozamadığında temiz bir şekilde çalışır. Bu denge public, protected, private ve paket düzeyindeki erişimle - yani erişim belirleyicileriyle - kontrol edilir; sırada onlar var.