Variabel dan Tipe Data di Java

Di Java, setiap variabel memiliki tipe data yang ditentukan secara eksplisit dan tidak bisa berubah. Java membedakan dua kategori tipe data: primitive types (tipe dasar seperti int, double, boolean) dan reference types (objek seperti String, array, class). Pemahaman perbedaan ini sangat penting karena mempengaruhi cara data disimpan dan dimanipulasi. Mari kita pelajari selengkapnya.

Mendeklarasikan Variabel

public class ContohVariabel {
    public static void main(String[] args) {
        // tipe_data nama_variabel = nilai;
        int umur = 22;
        double ipk = 3.75;
        String nama = "Dewi Rahayu";
        boolean lulus = true;

        System.out.println("Nama: " + nama);
        System.out.println("Umur: " + umur);
        System.out.println("IPK: " + ipk);
        System.out.println("Lulus: " + lulus);
    }
}
// Output:
// Nama: Dewi Rahayu
// Umur: 22
// IPK: 3.75
// Lulus: true

Tipe Primitif (Primitive Types)

Java memiliki 8 tipe primitif — disimpan langsung di stack memory (bukan sebagai objek):

Tipe Integer

byte kecil = 127;           // 8-bit: -128 s/d 127
short sedang = 32767;       // 16-bit: -32,768 s/d 32,767
int umum = 2_147_483_647;   // 32-bit: paling umum digunakan
long besar = 9_000_000_000L; // 64-bit: perlu suffix 'L'

System.out.println("Ukuran int: " + Integer.SIZE + " bit");
// Output: Ukuran int: 32 bit

System.out.println("Max int: " + Integer.MAX_VALUE);
// Output: Max int: 2147483647

Tipe Desimal

float harga = 99.99f;         // 32-bit, ~7 digit presisi (perlu suffix 'f')
double pi = 3.141592653589793; // 64-bit, ~15 digit presisi

System.out.printf("Pi: %.5f%n", pi);
// Output: Pi: 3.14159

Tipe Lainnya

char huruf = 'J';            // 16-bit Unicode character
boolean aktif = true;        // hanya true atau false

System.out.println(huruf);   // Output: J
System.out.println((int) huruf); // Output: 74 (nilai Unicode 'J')

String — Reference Type

String di Java bukan tipe primitif, melainkan sebuah class (reference type):

String nama = "Budi Santoso";
String kota = "Bandung";

// Panjang string
System.out.println(nama.length()); // Output: 12

// Menggabungkan string
String salam = "Halo, " + nama + " dari " + kota + "!";
System.out.println(salam);
// Output: Halo, Budi Santoso dari Bandung!

// Metode String yang berguna
System.out.println(nama.toUpperCase());       // Output: BUDI SANTOSO
System.out.println(nama.toLowerCase());       // Output: budi santoso
System.out.println(nama.contains("Budi"));    // Output: true
System.out.println(nama.replace("Budi", "Andi")); // Output: Andi Santoso
System.out.println(nama.substring(0, 4));     // Output: Budi

// Membandingkan string — HARUS gunakan .equals(), bukan ==
String s1 = "halo";
String s2 = "halo";
System.out.println(s1.equals(s2));             // Output: true ✅
System.out.println(s1.equalsIgnoreCase("HALO")); // Output: true

Penting: Jangan gunakan == untuk membandingkan String di Java! == membandingkan referensi (alamat memori), bukan isi. Selalu gunakan .equals().

String Formatting

String nama = "Sari";
int umur = 20;
double ipk = 3.85;

// Cara modern: String.format() atau printf
String info = String.format("Nama: %s | Umur: %d | IPK: %.2f", nama, umur, ipk);
System.out.println(info);
// Output: Nama: Sari | Umur: 20 | IPK: 3.85

// printf langsung
System.out.printf("Halo, %s! IPK kamu %.2f%n", nama, ipk);
// Output: Halo, Sari! IPK kamu 3.85

Konstanta dengan final

final double PI = 3.14159265358979;
final int MAKS_PERCOBAAN = 3;
final String KODE_NEGARA = "ID";

// Mengubah final akan menyebabkan error kompilasi
// PI = 3.14; // ❌ Error: cannot assign a value to final variable PI

System.out.println("PI = " + PI);
// Output: PI = 3.14159265358979

Konversi Tipe Data (Type Casting)

Widening (Otomatis — Aman)

Konversi dari tipe kecil ke tipe lebih besar terjadi otomatis:

int angka = 100;
long angka_long = angka;      // int → long (otomatis)
double angka_double = angka;  // int → double (otomatis)

System.out.println(angka_double); // Output: 100.0

Narrowing (Manual — Bisa Kehilangan Data)

Konversi dari tipe besar ke tipe lebih kecil membutuhkan cast eksplisit:

double nilai = 9.99;
int nilai_int = (int) nilai;  // Desimal dipotong, bukan dibulatkan!
System.out.println(nilai_int); // Output: 9

long besar = 1_500_000_000L;
int kecil = (int) besar; // Aman jika nilai masih dalam range int
System.out.println(kecil); // Output: 1500000000

Konversi String ↔ Angka

// String → int
String str_angka = "42";
int angka = Integer.parseInt(str_angka);
System.out.println(angka + 8); // Output: 50

// String → double
String str_desimal = "3.14";
double desimal = Double.parseDouble(str_desimal);
System.out.println(desimal); // Output: 3.14

// int → String
int nilai = 100;
String str = String.valueOf(nilai);   // Cara 1
String str2 = Integer.toString(nilai); // Cara 2
String str3 = "" + nilai;              // Cara 3 (tidak disarankan)
System.out.println(str.length()); // Output: 3

Wrapper Classes

Setiap tipe primitif memiliki pasangan Wrapper Class — versi objek dari tipe tersebut:

// Fitur berguna dari Wrapper Classes
System.out.println(Integer.MAX_VALUE);    // Output: 2147483647
System.out.println(Integer.MIN_VALUE);    // Output: -2147483648
System.out.println(Integer.toBinaryString(10)); // Output: 1010
System.out.println(Integer.toHexString(255));   // Output: ff

// Autoboxing: primitif → wrapper (otomatis)
Integer obj = 42;  // int → Integer (autoboxing)

// Unboxing: wrapper → primitif (otomatis)
int val = obj;     // Integer → int (unboxing)

Pertanyaan yang Sering Diajukan

Mengapa tidak menggunakan == untuk membandingkan String di Java?

Di Java, == membandingkan referensi (alamat memori), bukan isi String. Dua String dengan isi yang sama bisa berada di lokasi memori yang berbeda. "halo" == "halo" mungkin true (karena String pool), tapi new String("halo") == new String("halo") adalah false. Selalu gunakan .equals() untuk keamanan.

Apa itu Wrapper Class dan kapan menggunakannya?

Wrapper Class adalah versi objek dari tipe primitif. Dibutuhkan saat: (1) menyimpan primitif dalam koleksi seperti ArrayList<Integer>, (2) menggunakan metode utilitas seperti Integer.parseInt(), atau (3) membutuhkan nilai yang bisa null (primitif tidak bisa null, tapi Integer bisa).

Kapan menggunakan int dan kapan long?

Gunakan int untuk nilai di bawah ~2.1 miliar (cukup untuk hampir semua kebutuhan umum). Gunakan long untuk nilai yang lebih besar — seperti timestamp dalam milidetik, ID unik bertipe numerik, atau kalkulasi finansial skala besar. Jangan lupa tambahkan suffix L saat menulis literal long: long x = 9_000_000_000L.

Apa bedanya float dan double?

float menggunakan memori lebih kecil (4 byte) dengan presisi ~7 digit desimal, sementara double menggunakan 8 byte dengan presisi ~15 digit. Di Java modern, double adalah pilihan default untuk bilangan desimal. Gunakan float hanya jika kamu perlu menghemat memori dalam jumlah besar (misalnya array dengan jutaan elemen).

Kesimpulan

Ringkasan tipe data Java:

Artikel sebelumnya: Pengenalan Java — instalasi JDK dan program pertama.

Langkah selanjutnya: Operator dan Ekspresi di Java — cara melakukan perhitungan dan perbandingan nilai di Java.