Tipe Data Java: Primitif, Tipe Referensi, dan Nilai Default

Dua Keluarga: Primitif dan Referensi

Setiap nilai di Java punya tipe, dan tipe itu termasuk salah satu dari dua keluarga. Tipe primitif menyimpan nilai mentah secara langsung: sebuah angka, satu karakter, atau true/false. Tipe referensi menyimpan referensi (pointer) ke sebuah objek yang berada di tempat lain di memori: String, array, dan setiap class yang didefinisikan olehmu atau oleh library.

Perbedaan ini penting karena primitif itu ringan dan disalin berdasarkan nilainya, sedangkan variabel referensi menunjuk ke objek yang bisa dipakai bersama. Mulailah dengan delapan tipe primitif, karena semuanya dibangun di atas fondasi ini.

Delapan Tipe Primitif

Java punya tepat delapan tipe primitif bawaan. Enam di antaranya angka, satu karakter, dan satu boolean:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // 8-bit integer,  -128 .. 127
        short  s = 30000;        // 16-bit integer
        int    i = 2_000_000;    // 32-bit integer (the default for whole numbers)
        long   big = 9_000_000_000L; // 64-bit integer - note the L

        float  f = 3.14f;        // 32-bit decimal - note the f
        double d = 3.141592653589793; // 64-bit decimal (the default for decimals)

        char   c = 'A';          // a single 16-bit Unicode character
        boolean flag = true;     // only true or false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Beberapa hal yang perlu diperhatikan sejak awal: garis bawah pada 2_000_000 hanyalah pemisah visual yang diabaikan compiler, sufiks L dan f itu wajib (penjelasannya ada di bawah), dan char memakai tanda kutip tunggal, sedangkan String memakai tanda kutip ganda.

Memilih Tipe Numerik

Kamu hampir tidak pernah butuh byte atau short, karena keduanya hanya menghemat memori pada array yang sangat besar. Keputusan yang sebenarnya adalah antara int/long untuk bilangan bulat dan float/double untuk bilangan desimal.

Jebakannya adalah overflow. int diam-diam berputar balik saat melewati rentangnya. Tidak ada error, hanya jawaban yang salah:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // wraps to a negative number!

        long safe = (long) maxInt + 1;  // promote to long first
        System.out.println(safe);
    }
}

maxInt + 1 mengalami overflow menjadi -2147483648 karena kedua operandnya int dan hasilnya tetap int. Melakukan cast salah satu sisi ke long terlebih dahulu membuat perhitungannya dilakukan dalam 64 bit. Kalau sebuah nilai bisa jadi besar, terutama milidetik sejak tahun 1970, pakai long.

Literal dan Sufiksnya

Literal angka tanpa tambahan apa pun punya tipe default, dan ini sering menjebak. 100 adalah int; 3.14 adalah double. Untuk menulis literal long atau float, kamu harus menambahkan sufiks:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // without L this is too big for int -> error
        float ratio = 0.5f;               // without f the right side is a double -> error
        double pi = 3.14;                 // fine - decimals default to double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Hapus L dari 8_000_000_000L, maka kodenya tidak akan bisa dikompilasi, karena literal itu melebihi rentang int sebelum sempat sampai ke variabel long. Hapus f dari 0.5f, maka Java akan protes bahwa double tidak bisa diberikan ke float tanpa cast. Sufiksnya tidak peka huruf besar kecil, tetapi pakai L huruf besar, karena l huruf kecil terlihat persis seperti angka 1.

char Sebenarnya Angka yang Menyamar

char menyimpan satu code unit Unicode 16-bit, artinya ia sekaligus berfungsi sebagai bilangan bulat kecil tanpa tanda. Kamu bisa melakukan aritmetika padanya dan mengonversinya bolak-balik dengan cast:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - the Unicode value of 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Ini kadang berguna untuk menggeser huruf, tetapi jangan mengandalkannya untuk teks, karena untuk itulah String ada. Perhatikan bahwa char memakai tanda kutip tunggal ('A'); tanda kutip ganda ("A") menghasilkan String berisi satu karakter, yang merupakan tipe yang sama sekali berbeda.

Nilai Default (dan Jebakan Variabel Lokal)

Field dan elemen array yang tidak kamu inisialisasi mendapat nilai default yang masuk akal. Tetapi ini hanya berlaku untuk field dan slot array: variabel lokal tidak mendapat nilai default, dan memakainya sebelum diberi nilai menghasilkan error kompilasi, bukan kejutan saat runtime.

public class Main {
    static int counter;        // field -> defaults to 0
    static boolean ready;      // field -> defaults to false
    static String name;        // field -> defaults to null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // array elements default to 0
        System.out.println(nums[0]); // 0
    }
}

Kalau kamu menulis int x; System.out.println(x); di dalam main, compiler akan menolaknya dengan pesan "variable x might not have been initialized." Ketegasan ini justru fitur: ia mencegahmu membaca nilai sampah. Nilai default yang perlu diingat: tipe numerik 0, boolean false, char '\u0000', dan setiap tipe referensi null.

Berikutnya: String

String adalah tipe referensi yang paling sering akan kamu pakai: teks, nilai yang digabungkan, input dari pengguna. Perilakunya berbeda dari tipe primitif di sini: ia adalah objek, ia immutable, dan membandingkan string punya jebakannya sendiri. Halaman berikutnya membahasnya.