Java’da Constructor Çağrılma Sırası: this() ve super()

Java constructor sırası ve this()/super() davranışı, nesne oluşturulurken hangi sınıfın önce çalıştığını anlamaya dayanır. Temel kural şudur: Constructor, nesnenin başlangıç durumunu hazırlar; metot ise nesne oluşturulduktan sonra çağrılan davranışı gerçekleştirir. Bir sınıfta parametreli constructor tanımlandığında, new Animal() gibi parametresiz çağrıların geçerli olup olmadığını ayrıca kontrol etmek gerekir.

Bu konuyu öğrenirken eğitmenimiz Berk Keskin’in önerdiği temel kontrol sorusunu kullanabilirsiniz: “Bu kod bir metot mu, constructor mı; adı sınıfla aynı mı?”

Constructor Nedir ve Metottan Nasıl Ayrılır?

Constructor, bir sınıftan new anahtar sözcüğüyle nesne oluşturulurken çalışan özel bir yapıdır. Sınıfla aynı ada sahip olur ve dönüş tipi taşımaz. Görevi, nesnenin başlangıç durumunu hazırlamaktır.

class Student {
    String name;

    Student(String name) {
        this.name = name;
    }

    void introduce() {
        System.out.println("Merhaba, ben " + name);
    }
}

class Main {
    public static void main(String[] args) {
        Student student = new Student("Ada");
        student.introduce();
    }
}

Bu örnekte Student(String name) bir constructordır. new Student("Ada") çalıştığında constructor çağrılır ve name alanı başlangıç değeriyle hazırlanır. introduce() ise bir metottur; nesne oluşturulduktan sonra ayrıca çağrılmıştır.

Constructor ile metot arasındaki önemli bir ayrıntı da dönüş tipiyle ilgilidir. Sınıf adıyla aynı olsa bile başına void yazılan yapı constructor değil, metottur:

class Book {
    Book() {
        System.out.println("Constructor");
    }

    void Book() {
        System.out.println("Metot");
    }
}

Constructor’lar kalıtımla alt sınıfa aktarılmaz ve override edilmez. Ancak alt sınıftan bir nesne oluşturulurken üst sınıf constructor’ı nesne başlatma zincirinin bir parçası olarak çalışabilir. Bu nedenle “constructor miras alınmıyor” ile “üst sınıf constructor’ı hiç çalışmıyor” ifadeleri aynı anlama gelmez.

Parametresiz Constructor Ne Zaman Otomatik Oluşur?

Bir sınıfta hiç constructor tanımlanmazsa derleyici, parametresiz bir constructor kullanılabilmesini sağlar. Böylece aşağıdaki çağrı geçerli olur:

class Animal {
    String type = "Bilinmiyor";
}

class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        System.out.println(animal.type);
    }
}

Beklenen çıktı:

Bilinmiyor

Ancak sınıfa en az bir constructor eklediğiniz anda bu otomatik davranışa güvenemezsiniz. Örneğin yalnızca parametreli constructor tanımlanırsa new Animal() çağrısı derleme hatasına yol açabilir:

class Animal {
    Animal(String type) {
        System.out.println(type);
    }
}

// Animal animal = new Animal();          // Hatalı
Animal animal = new Animal("Kedi");       // Geçerli

Buradaki sorun, çağrılan parametre listesine uygun constructor bulunmamasıdır. İsterseniz constructor aşırı yükleme kullanarak iki çağrıyı da destekleyebilirsiniz:

class Animal {
    Animal() {
        this("Bilinmiyor");
    }

    Animal(String type) {
        System.out.println(type);
    }
}

Kendi kodunuzdaki constructor hatasını incelerken şu karar akışını uygulayın:

1. Sınıfta açıkça tanımlanmış bir constructor var mı?
2. Çağırdığınız parametre listesiyle eşleşen bir constructor tanımlı mı?
3. Bu sınıf başka bir sınıftan kalıtım alıyorsa, üst sınıfta aynı çağrıya uygun constructor bulunuyor mu?

this() ve super() Hangi Constructor’a Geçiş Yapar?

Java’da this(), aynı sınıf içinde tanımlanmış başka bir constructor’a; super() ise doğrudan üst sınıfta bulunan constructor’a geçiş yapar. Parametre yazıldığında Java, çağrıyı parametre sayısı ve türleriyle eşleşen constructor imzasına yönlendirir.

Her iki çağrı da constructor gövdesindeki ilk ifade olmak zorundadır. Bu nedenle önce bir değişkene değer atayıp ardından this() veya super() yazamazsınız. Aynı constructor içinde hem this() hem de super() doğrudan birlikte kullanılamaz. Çünkü this() ile başlayan zincirin sonunda Java, üst sınıf constructor’ına ulaşır.

Örneğin this("Mavi", 3) çağrısı, mevcut sınıfta String ve int parametrelerini alan constructor’ı arar. super("Mavi") ise doğrudan üst sınıfta tek bir String parametresi alan constructor’a yönelir. Dolayısıyla constructor seçimi, yalnızca çağrının adına değil, parametre imzasına bağlıdır.

Bu eşleşmeleri ve temel Java konularını uygulamalı biçimde çalışmak isteyen öğrenciler, eğitmenimiz Berk Keskin eşliğinde Java özel ders sayfasındaki birebir çalışma sürecini inceleyebilir.

• Çağrının ilk ifade olup olmadığını kontrol edin.
• Parametre sayısını ve türlerini hedef constructor ile karşılaştırın.
• this() çağrısının aynı sınıfta, super() çağrısının doğrudan üst sınıfta aranacağını unutmayın.
• Aynı constructor içinde iki çağrıyı art arda kullanmaya çalışmayın.

Alt Sınıf Nesnesinde Constructor Çağrılma Sırası Nasıl İzlenir?

Bir alt sınıftan nesne üretildiğinde Java önce üst sınıfın constructor’ını çalıştırır, ardından alt sınıfın constructor gövdesine geçer. Bunun nedeni, oluşturulan nesnenin önce üst sınıfa ait bölümünün hazırlanması, sonra alt sınıfa özgü alan ve işlemlerin yürütülmesidir.

class Animal {
    Animal() {
        System.out.println("Animal constructor");
    }
}

class Dog extends Animal {
    Dog() {
        this("Karabaş", 0);
    }

    Dog(String name, int age) {
        super();
        System.out.println("Dog constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Dog();
    }
}

Programın beklenen çıktısı şöyledir:

Animal constructor
Dog constructor

main içinde new Dog() çalıştığında önce Dog() çağrılır. Bu constructor, ilk ifade olarak this("Karabaş", 0) çağrısını yapar ve aynı sınıftaki parametreli constructor’a geçer. Ardından bu constructor’ın ilk ifadesi olan super() çalışır ve Animal() gövdesi ekrana ilk satırı yazdırır. Üst sınıf constructor’ı tamamlanınca Dog gövdesindeki yazdırma işlemi gerçekleşir.

Çıktı sırasını karıştıran bir öğrenci için uygulanabilir hata ayıklama senaryosu şu şekilde ilerleyebilir:

1. Önce çıktı satırlarını numaralandırın: 1. Animal constructor, 2. Dog constructor.
2. İlk satırı Animal() gövdesindeki println ile eşleştirin.
3. Dog() içindeki this(...) çağrısının, doğrudan yazdırma yapmadan başka bir Dog constructor’ına geçtiğini belirleyin.
4. super() satırının üst sınıf constructor’ını çalıştırdığını kontrol edin.
5. Son satırın, üst sınıf tamamlandıktan sonra çalışan Dog(String, int) gövdesinden geldiğini doğrulayın.

Benzer constructor sorularındaki seviyenizi görmek için Java bilgi testi üzerinden mevcut Java bilginizi ölçebilir, ardından özellikle kalıtım ve parametre eşleşmesi konularını hedefleyebilirsiniz.

Üst Sınıfta Uygun Constructor Yoksa Hata Nasıl Düzeltilir?

Alt sınıf constructor’ında açıkça başka bir constructor çağrısı yazılmadığında Java, ilk ifade olarak örtük biçimde super() eklemeyi dener. Ancak üst sınıfta parametresiz constructor bulunmuyorsa bu çağrı başarısız olur ve derleme hatası oluşur.

class Kullanici {
    Kullanici(String ad) {
        System.out.println(ad);
    }
}

class Ogrenci extends Kullanici {
    Ogrenci() {
        System.out.println("Öğrenci oluşturuldu");
    }
}

Bu örnekte Ogrenci() constructor’ı yazılırken Java, görünmeyen bir super() çağrısı eklemeye çalışır. Fakat Kullanici sınıfında Kullanici() bulunmaz; yalnızca String parametresi alan constructor vardır. Bu nedenle genellikle “constructor Kullanici() tanımsız” anlamına gelen bir derleme hatası görülür.

Hata nasıl adım adım teşhis edilir?

• Hata mesajını oku: Derleyicinin hangi sınıfta ve hangi constructor imzasında sorun gördüğünü belirle.
• Sınıf hiyerarşisini çiz: Örneğin Ogrenci extends Kullanici ilişkisinde alt ve üst sınıfı açıkça yaz.
• Constructor imzalarını yaz: Parametre sayısı ve türleriyle birlikte hangi constructor’ların bulunduğunu listele.
• İlk ifade kuralını kontrol et: Alt sınıf constructor’ının ilk satırında this(...) veya super(...) olup olmadığına bak.
• Örtük çağrıyı düşün: Hiçbir çağrı yoksa Java’nın otomatik olarak super() eklediğini hatırla.
• Üst sınıfta parametresiz constructor olup olmadığını kontrol et: Yoksa açık ve uygun bir super(deger) çağrısı gerekir.
• Argümanları karşılaştır: Gönderilen değerlerin sayısı ve türleri üst sınıftaki constructor ile eşleşmeli.
• Çıktıyı yeniden çalıştır: Düzeltmeden sonra programı tekrar derle ve constructor çıktılarının sırasını kontrol et.

İki temel düzeltme yaklaşımı

İlk yaklaşım, üst sınıfa parametresiz bir constructor eklemektir. Bu yöntem, üst sınıfın varsayılan bir başlangıç durumuna sahip olabildiği durumlarda uygundur.

class Kullanici {
    Kullanici() {
        System.out.println("Kullanıcı hazır");
    }
}

class Ogrenci extends Kullanici {
    Ogrenci() {
        System.out.println("Öğrenci hazır");
    }
}

public class Main {
    public static void main(String[] args) {
        new Ogrenci();
    }
}

Beklenen çıktı sırası şöyledir:

Kullanıcı hazır
Öğrenci hazır

İkinci yaklaşım, üst sınıfta zaten bulunan parametreli constructor’ı alt sınıftan doğru argümanlarla çağırmaktır. Bu durumda super("Ayşe") ifadesi constructor gövdesindeki ilk ifade olmalıdır. Constructor çağrılma sırasını ve parametre eşleşmesini uygulamalı olarak pekiştirmek isteyen öğrenciler için canlı sınıflı Java eğitimleri soru-cevap desteğiyle yararlı bir sonraki adım olabilir.

Sık karıştırılan constructor hataları

this() ve super() constructor gövdesinin ortasında kullanılamaz. Örneğin aşağıdaki kullanım hatalıdır:

Ogrenci() {
    System.out.println("Başladı");
    super("Ayşe"); // Hatalı: ilk ifade değil
}

Argüman türü de eşleşmelidir. Üst sınıfta Kullanici(String ad) varsa super(25) çağrısı uygun değildir. Ayrıca constructor zinciri döngüye girmemelidir. Örneğin A() içinde this(1), A(int) içinde tekrar this() çağrılırsa constructor’lar birbirini sonsuz biçimde çağırmaya çalışır ve derleme hatası oluşur.

Sık Sorulan Sorular

Java’da constructor içinde this() ve super() neden ilk ifade olmak zorundadır?

Çünkü nesnenin başlangıç aşamasında önce aynı sınıftaki veya üst sınıftaki constructor zincirinin tamamlanması gerekir. Java, constructor gövdesindeki diğer işlemlerden önce bu başlangıç adımının kesinleşmesini zorunlu tutar.

Alt sınıf constructor’ı yazılmadığında Java hangi constructor’ı çağırır?

Alt sınıf için varsayılan constructor oluşturulursa Java, üst sınıfın parametresiz constructor’ını örtük olarak çağırır. Üst sınıfta böyle bir constructor yoksa alt sınıfın varsayılan constructor’ı derlenemez.

Üst sınıfta yalnızca parametreli constructor varsa alt sınıf nasıl doğru constructor çağrısı yapar?

Alt sınıf constructor’ının ilk satırında, üst sınıftaki imzayla eşleşen bir çağrı yazılır. Örneğin üst sınıfta Kullanici(String ad) varsa alt sınıf super("Ayşe") kullanabilir.

this() ile super() arasındaki temel fark nedir?

this() aynı sınıf içinde bulunan başka bir constructor’ı çağırır. super() ise doğrudan üst sınıftaki constructor’a geçiş yapar. İkisi de constructor içinde ilk ifade olmalıdır.

Constructor çıktılarının sırasını adım adım nasıl teşhis edebilirim?

Önce sınıf hiyerarşisini yaz, ardından her constructor’ın ilk ifadesini kontrol et. Sonra örtük super() çağrısını değerlendir, parametre türlerini karşılaştır ve programı yeniden çalıştırarak üst sınıftan alt sınıfa doğru oluşan çıktıyı izle.

Bu bölümün yazarı eğitmenimiz Berk Keskin; amaç, constructor hatalarını ezberlemeden çağrı zincirini düşünerek çözebilmeyi sağlamaktır.