Java’da kurucu fonksiyon (Constructor) yazımı ile ilgili basit kurallar.

Kurucu Fonksiyonlar (Constructor’lar) yazarken uyulması gereken bazı temel kurallardan bahsedelim.

Constructor’u kısaca anlatmak gerekirse; Java’da her nesnenin yeni instance’ı (Örneği) oluşturulurken aslında o nesnenin  constructor’ı çalıştırılır. Ayrıca constructor tanımlanmamış olsa bile Java tarafından o nesnenin constructor’u oluşturulur. Bu oluşturulan constructor’a varsayılan constructor denir ve hiç bir parametresi yoktur. Constructor’lar new keyword’ü ile çağırılırlar. Ör: String text = new String();

Bu kısa bilginin ardın asıl konumuz olan constructor yazım kurallarına geri dönelim.

• Constructor adı, class (sınıf) adı ile aynı olmalıdır. Eğer class adından farklı bir isim verilirse compile time (derleme zamanı) hatası ile karşılaşırız. Çünkü class isminden farklı bir isim kullanılırsa, Java bunu bir method zanleder ve Invalid method declaration; method type required hatası oluşur.

class A {
    A() {
        // A Class'ının constructor'ı
    }
 
    A1() {
        // Compile time hatası, metod zanlediyor.
    }
}

• Constructor’lar geri dönüş tipine sahip olmamalıdır. Eğer constructor için geri dönüş tipi belirlerseniz, bu onu metod yapar. Class ile aynı adı taşıyan böyle bir metod yaparsanız, sadece uyarı verilir (hata oluşmaz), ancak böyle bir metod tanımlaması önerilmez.

class A
{
     A()
     {
         // A Class'ının constructor'ı, her hangi bir geri dönüş tipine sahip değil
     }
     void A()
     {
         // constructor'un geri dönüş tipi var. Metod olarak algılanır ve uyarı verilir.
     }
}

• Her class’ın bir constructor’ı olmalıdır. Eğer class için bir constructor yazılmamış ise derleyici sizin yerinize default (varsayılan) constructor’ı kullanacaktır. default constructor hiç bir parametre almaz.

class A
{
     // Hiç constructor yazılmamış
}

yukarıdaki kodu compiler (derleyici) şu şekilde yorumlar

class A
{
    public A()
    {
        //   Compiler tarafından oluşturulan Constructor.
    }
}

• Constructor’lar private olarak tanımlanabilirler. Ancak bu şekilde bir tanımlamadan sonra class dışında kullanılamazlar. Kullanılmak istenilirse Error:(15, 17) A() has private access in A hatası ile karşılaşırsınız.

class A {
    private A() {
        // Private Constructor
    }
 
    void methodOne() {
        //private constructor'ı class içinde kullanabilirsiniz.
        A a1 = new A();
    }
}
 
class MainClass {
    public static void main(String[] args) {
        //private constructor'ı ait olduğu class dışında kullanamazsınız. Hata ile karşılaşırsınız.
         //A a1 = new A();
    }
}

• Bir class birden çok constructor’a sahip olabilir. Buna Constructor Overloading (Yapıcı fonksiyon aşırı yüklemesi) denir. Birden çok constructor tanımlaması ile, class birden çok şekilde oluşturulabilir.

class A {
    A() {
        // İlk Constructor
    }
 
    A(int i) {
        // İkinci Constructor
    }
 
    A(int i, int j) {
        // Üçüncü Constructor
    }
}

Yukarıdaki class’ın bir instance’ı (örneği) oluşturulmak istenirse, aşağıdaki yollarla bu istek gerçekleştirilebilir.

class MainClass {
    public static void main(String[] args) {
        A a1 = new A();      //İlk Constructor Kullanılarak
        A a2 = new A(10);    // İkinci Constructor Kullanılarak
        A a3 = new A(10, 20);    // Üçüncü Constructor Kullanılarak
    }
}

• Yinelenen constructor’lara izin verilmez. Eğer programınızı yinelenen constructor’larla derlemek isterseniz compile time hatası ile karşılaşırsınız.

class A {
    A(int i) {
        // Yinelenen Constructor
    }
 
    A(int i) {
        // Yinelenen Constructor
    }
}

• Constructor parametreleri aynı isimde olamaz. Aynı isimde iki parametre compile time hatası almanıza neden olur.

class A {
    A(long i, int i) {
        // Yinelenen parametre adı. Compile time hatası
    }
}

• Constructor adından önce yanlızca public, protected ve private keyword’lerine izin verilir. Eğer bunlar dışında bir keyword kullanılırsa compile time hatası ile karşılaşılır.

class A {
    final A() {
        //final olamaz
    }
 
    static A() {
        //static olamaz
    }
 
    abstract A() {
        //abstract olamaz
    }
}

• Constructor içerisinde super() veya this() kullanmak isterseniz, constructor’ın ilk ifadesi super veya this olmalıdır. Aksi halde compile time hatası alınır. super() ifadesi class’ın varsayılan cunstructor’unu çalıştırmak için kullanılır. this() ifadesi ise class içersindeki herhangi bir constructor’ı açmak için kullanılır.

class A {
    A() {
        //Varsayılan, derleme işlemi sırasında super() ifadesi ile karşılaşılınca burası çalıştırılacaktır.
        System.out.println("İlk Constructor");
    }
 
    A(int i) {
        //soper ilk ifade olduğu için doğru yerde
        super();
        System.out.println("İkinci Constructor");
    }
 
    A(int i, int j) {
        //this ilk ifade olduğu için doğru yerde
        this(i);
        System.out.println("Üçüncü Constructor");
    }
 
    A(int i, int j, int k) {
        System.out.println("Dördüncü Constructor");
        // super(); //super ilk ifade olmadığı için yanlış yerde. Bu satırı aktif ederseniz compile time hatası alırsınız.
    }
}

• Recursive  (yinelemeli) constructor çağırmalarına izin verilmez.

class A {
    A() {
        this();
        // Burada compile hatası
    }
}

• Cylic (çevrimsel – döngüsel) çağırmalara izin verilmez.

class A {
    A() {
        this(10);
        // Compile time hatası
    }
 
    A(int i) {
        this();
        // Compile time hatası
    }
}

Eminim bilmediginiz bir cok kural ogrenmissinizdir. Bir sonraki makalede gorusmek uzere…