Java Yapıcı Metotlar: new ile Nesneleri Başlatma

Yapıcılar Neden Vardır

Önceki sayfada sınıflar oluşturup new ile nesneler ürettiniz. Yapıcı, o new çağrısı sırasında gerçekten çalışan koddur. Tek amacı, kullanıma hazır bir nesneyi geri vermektir: tüm zorunlu alanları ayarlanmış, yarı başlatılmış hiçbir durumu kalmamış bir nesne.

Bir yapıcı metoda benzer, ancak iki farkı vardır: sınıfla aynı ada sahiptir ve dönüş tipi yoktur, void bile değil.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // yapıcı: sınıfla aynı ad, dönüş tipi yok
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // yapıcı burada çalışır
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) nesneyi tahsis eder ve ardından yapıcının gövdesini x = 3 ve y = 4 ile çalıştırır. new döndüğünde p tamamen başlatılmış olur.

this Anahtar Kelimesi

Yukarıdaki yapıcıda parametreler x ve y olarak adlandırılmıştır; alanlarla aynı. this.x "bu nesneye ait x alanı" anlamına gelirken, yalın x parametreye atıfta bulunur. this olmadan, x = x ifadesi yalnızca parametreyi kendisine atar ve alanı el değmeden bırakır.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // alan = parametre
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

this'e yalnızca bir parametre bir alanı gölgelediğinde ihtiyacınız vardır, ama birçok kişi netlik için onu her yerde kullanır. Sık yapılan hata, adlar çakıştığında onu unutmaktır: kod derlenir, çalışır ve alanlarınızı sessizce varsayılan değerlerinde (null, 0, false) bırakır.

Varsayılan Yapıcı

Hiç yapıcı yazmazsanız, Java sessizce bir varsayılan yapıcı sağlar: fazladan hiçbir şey yapmayan, argümansız, public bir yapıcı. İşte bu yüzden hiç yapıcısı olmayan sınıflarda new çalışıyordu.

İşin püf noktası: herhangi bir yapıcı yazdığınız anda ücretsiz olanı kaybolur.

class Box {
    int size;

    Box(int size) {       // artık argümansız yapıcı YOK
        this.size = size;
    }
}

new Box();   // derleme hatası: Box() yapıcısı yok

new Box() ifadesinin yine de çalışmasını istiyorsanız, argümansız yapıcıyı kendiniz bildirin:

class Box {
    int size;

    Box() {               // açık argümansız yapıcı
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

Yapıcı Aşırı Yükleme

Bir sınıf, parametre listeleri farklı olduğu sürece birden fazla yapıcıya sahip olabilir; bu, metot aşırı yüklemenin yapıcılara uygulanmış halidir. Her biri nesneyi oluşturmanın farklı bir yolunu sunar.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // varsayılan 1x1 kare
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // bir kare
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // tam bir dikdörtgen
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java, new'e geçirdiğiniz argümanların sayısına ve tiplerine göre eşleşen yapıcıyı seçer.

this() ile Zincirleme

Yukarıdaki tekrarı fark edin: her yapıcı alanları kendisi atıyor. Bir yapıcının this(...) ile başka bir yapıcıyı çağırmasını sağlayarak bundan kaçınabilirsiniz. Çağrı, yapıcının ilk ifadesi olmalıdır.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // iki argümanlı yapıcıya devreder
    }

    Rectangle(int side) {
        this(side, side);    // o da devreder
    }

    Rectangle(int width, int height) {   // tek "gerçek" yapıcı
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

Artık asıl başlatma tek bir yerde yaşıyor. Daha küçük yapıcılar yalnızca varsayılan değerleri doldurup işi iletir. Eğer this(...) çağrısından önce bir ifade koymaya kalkarsanız, derleyici bunu reddeder.

Yapıcılar ve super()

Her yapıcı önce örtük olarak üst sınıfının yapıcısını çağırır. Hiçbir şey yazmazsanız, Java gövdenin en üstüne gizli bir super() (üst sınıfın argümansız yapıcısı) ekler. Alt sınıf oluşturmaya başladığınızda bununla doğrudan çalışacaksınız; bu da bir sonraki konu.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // ebeveyn yapıcısını burada açıkça çağırmak gerekir
    }
}

Animal'ın argümansız bir yapıcısı olmadığından, Dog super(name) çağrısını açıkça yapmak zorundadır; başvurulacak ücretsiz bir super() yoktur. Tıpkı this() gibi, bir super(...) çağrısı da yapıcının ilk ifadesi olmak zorundadır.

Sıradaki: Kalıtım

Yapıcılar tek bir nesneyi başlatır, ama super() zaten daha büyük bir şeyin ipucunu verdi: sınıflar diğer sınıfların üzerine inşa edilebilir; onların alanlarını, metotlarını ve yapıcılarını yeniden kullanabilir. Bu ilişki, bir sınıfın bir diğerini genişletmesi, kalıtımdır ve bir sonraki sayfanın konusudur.