Constructor Java: Menginisialisasi Objek dengan new

Kenapa Constructor Ada

Di halaman sebelumnya kamu membuat class dan membuat objek dengan new. Constructor adalah kode yang benar-benar berjalan selama pemanggilan new itu. Tujuannya cuma satu: mengembalikan objek yang siap dipakai, dengan semua field wajibnya sudah terisi dan tanpa state yang baru setengah diinisialisasi.

Constructor mirip dengan method, dengan dua perbedaan: namanya sama dengan nama class, dan ia tidak punya tipe return, bahkan void pun tidak.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // constructor: same name as class, no return type
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // the constructor runs here
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) mengalokasikan objek lalu menjalankan isi constructor dengan x = 3 dan y = 4. Saat new selesai, p sudah terinisialisasi sepenuhnya.

Kata Kunci this

Di dalam constructor di atas, parameternya bernama x dan y, sama dengan nama field-nya. this.x berarti "field x milik objek ini", sedangkan x saja merujuk ke parameter. Tanpa this, x = x hanya mengisi parameter dengan dirinya sendiri dan membiarkan field-nya tidak tersentuh.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // field = parameter
        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);
    }
}

Kamu hanya perlu this saat sebuah parameter menutupi (shadow) sebuah field, tetapi banyak orang memakainya di mana-mana agar lebih jelas. Kesalahan yang umum adalah melupakannya saat nama bentrok: kodenya bisa dikompilasi, berjalan, dan diam-diam membiarkan field-mu tetap bernilai default (null, 0, false).

Default Constructor

Kalau kamu tidak pernah menulis constructor, Java diam-diam menyediakan default constructor: constructor public tanpa argumen yang tidak melakukan apa pun. Itulah sebabnya new tetap berfungsi pada class yang sama sekali tidak punya constructor.

Masalahnya: begitu kamu menulis constructor apa pun, constructor gratis itu hilang.

class Box {
    int size;

    Box(int size) {       // now there is NO no-arg constructor
        this.size = size;
    }
}

new Box();   // compile error: no constructor Box() exists

Kalau kamu tetap ingin new Box() berfungsi, deklarasikan sendiri constructor tanpa argumennya:

class Box {
    int size;

    Box() {               // explicit no-arg constructor
        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
    }
}

Constructor Overloading

Sebuah class bisa punya beberapa constructor asalkan daftar parameternya berbeda. Ini sebenarnya method overloading yang diterapkan pada constructor. Masing-masing menawarkan cara yang berbeda untuk membuat objek.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // a default 1x1 square
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // a square
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // a full rectangle
        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 memilih constructor yang cocok berdasarkan jumlah dan tipe argumen yang kamu berikan ke new.

Chaining dengan this()

Perhatikan pengulangan di atas: setiap constructor mengisi field-nya sendiri. Kamu bisa menghindarinya dengan membuat satu constructor memanggil constructor lain lewat this(...). Pemanggilan itu harus menjadi pernyataan pertama di dalam constructor.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delegates to the two-arg constructor
    }

    Rectangle(int side) {
        this(side, side);    // also delegates
    }

    Rectangle(int width, int height) {   // the single "real" constructor
        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
    }
}

Sekarang inisialisasi yang sebenarnya berada di satu tempat. Constructor yang lebih kecil hanya mengisi nilai default lalu meneruskan pekerjaannya. Kalau kamu mencoba menaruh pernyataan sebelum this(...), compiler akan menolaknya.

Constructor dan super()

Setiap constructor secara implisit memanggil constructor superclass-nya terlebih dahulu. Kalau kamu tidak menulis apa-apa, Java menyisipkan super() tersembunyi (constructor superclass tanpa argumen) di awal isi constructor. Kamu akan berurusan langsung dengan ini begitu mulai membuat subclass, yang menjadi topik berikutnya.

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

class Dog extends Animal {
    Dog(String name) {
        super(name);   // must call the parent constructor explicitly here
    }
}

Karena Animal tidak punya constructor tanpa argumen, Dog wajib memanggil super(name) secara eksplisit: tidak ada super() gratis yang bisa diandalkan. Sama seperti this(), pemanggilan super(...) harus menjadi pernyataan pertama di dalam constructor.

Berikutnya: Inheritance

Constructor menginisialisasi satu objek, tetapi super() sudah memberi isyarat tentang sesuatu yang lebih besar: class bisa dibangun di atas class lain, memakai ulang field, method, dan constructor-nya. Hubungan itu, satu class meng-extend class lain, disebut inheritance (pewarisan), dan itu topik halaman berikutnya.