Type Casting Java: Widening, Narrowing, dan Konversi Tipe

Arti Type Casting

Java bertipe statis: setiap nilai punya tipe, dan compiler tidak membiarkanmu mencampur tipe yang tidak cocok secara diam-diam. Type casting adalah cara mengubah nilai dari satu tipe ke tipe lain. Kadang Java melakukannya untukmu, dan kadang kamu harus memintanya secara eksplisit.

Ada dua arah. Dari tipe yang lebih kecil ke tipe yang lebih besar (int ke double) itu aman dan terjadi otomatis. Dari tipe yang lebih besar ke tipe yang lebih kecil (double ke int) bisa menghilangkan data, jadi Java memaksamu menuliskannya dengan cast.

Widening: Konversi Otomatis

Konversi widening memindahkan nilai ke tipe yang punya ruang lebih besar. Tidak ada yang bisa hilang, jadi Java melakukannya untukmu tanpa cast:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automatic

        System.out.println(price);   // 7.0
    }
}

int 7 masuk ke double dan menjadi 7.0. Urutan widening untuk angka adalah byte -> short -> int -> long -> float -> double; menyimpan nilai dari kiri ke kanan sepanjang rantai itu tidak pernah butuh cast. Itulah sebabnya mencampur tipe dalam aritmatika sering "langsung berhasil": Java melebarkan operand yang lebih kecil lebih dulu.

Narrowing: Cast Eksplisit

Arah sebaliknya, yaitu konversi narrowing, bisa membuang data, jadi compiler menolak kecuali kamu menulis tipe tujuan di dalam tanda kurung di depan nilainya:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // explicit narrowing cast

        System.out.println(whole);   // 3, not 4
    }
}

(int) pi adalah cast-nya. Perhatikan apa yang dilakukannya: cast ini memotong ke arah nol, cukup membuang bagian desimalnya. 3.9 menjadi 3, dan -3.9 menjadi -3. Cast tidak membulatkan. Kalau kamu ingin membulatkan, alatnya berbeda:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (truncates)
        System.out.println(Math.round(value));    // 4  (rounds)
    }
}

Lupa bahwa cast memotong adalah salah satu bug pemula yang paling umum. Kalau angka "bulat"-mu selalu kurang satu, biasanya inilah penyebabnya.

Jebakan Pembagian Integer

Jebakan ini pasti pernah dialami semua orang. Kalau kedua operand adalah int, operator / melakukan pembagian integer dan membuang sisanya, sebelum penyimpanan ke double terjadi:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - division done as ints first!
        double right = (double) a / b; // 3.5  - cast one operand first

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b adalah 7 / 2, dihitung sepenuhnya dengan matematika int, yang menghasilkan 3. Melebarkan ke double setelahnya hanya mengubah 3 menjadi 3.0, karena .5-nya sudah hilang. Melakukan cast pada satu operand ke double lebih dulu ((double) a / b) memaksa seluruh ekspresi menjadi floating-point, sehingga menghasilkan 3.5 yang kamu inginkan. Kamu cukup melakukan cast pada satu sisi; Java melebarkan sisi lainnya supaya cocok.

Saat Narrowing Meluap

Cast tidak memeriksa apakah nilainya muat. Kalau tidak muat, bit-bitnya langsung dipotong dan kamu mendapat hasil yang mengejutkan, tanpa error dan tanpa peringatan:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte only holds -128..127

        System.out.println(small);   // 44, not 300
    }
}

300 tidak muat di byte, jadi bit-bit tingginya dibuang dan hasilnya 44. Ini kehilangan data yang "diam-diam": program berjalan lancar tetapi memberi jawaban yang salah. Lakukan narrowing hanya kalau kamu yakin nilainya muat di tipe yang lebih kecil.

Konversi Antara Angka dan String

String adalah objek, bukan angka, jadi kamu tidak bisa melakukan cast dengan (int), karena itu error kompilasi. Konversinya memakai method khusus:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Dari teks ke angka, pakai Integer.parseInt / Double.parseDouble. Kalau string-nya bukan angka yang valid (misalnya "hello"), method ini akan melempar NumberFormatException. Dari angka ke teks, pakai String.valueOf(n) atau cukup gabungkan dengan "", karena n + "" memaksa int menjadi String. Perhatikan perbedaan antara "5" + 1 (yang menghasilkan string "51") dan 5 + 1 (yang menghasilkan 6); + berarti penggabungan begitu ada String yang terlibat.

Casting Objek

Casting juga berlaku untuk referensi objek, bukan hanya tipe primitif. Kamu bisa melakukan cast pada sebuah referensi ke tipe yang berkaitan di sepanjang rantai inheritance: widening ke tipe parent terjadi otomatis, sedangkan narrowing kembali ke bawah butuh cast eksplisit dan hanya aman kalau objeknya memang bertipe itu:

Object o = "hello";
String s = (String) o;        // OK: o actually refers to a String
Integer bad = (Integer) o;    // compiles, but throws ClassCastException at runtime

Cast kedua lolos kompilasi tetapi gagal saat runtime dengan ClassCastException, karena objeknya adalah String, bukan Integer. Kamu akan mempelajarinya dengan benar saat sampai di inheritance dan polimorfisme; untuk sekarang, cukup ketahui bahwa sintaks (Type) adalah ide yang sama yang diterapkan pada objek.