Pada pertemuan sebelumnya kita sudah menyiapkan JDK 25, menulis program pertama, serta mengenal variabel dan tipe data. Pada pertemuan ini kita belajar bagaimana komputer mengolah data: operator, ekspresi, konversi tipe data, class Math, dan pengolahan String.

Pendahuluan

Tujuan Pembelajaran

Setelah pertemuan ini, kamu diharapkan mampu:

Menggunakan operator aritmatika, assignment, perbandingan, dan logika pada Java.
Memahami urutan prioritas operator (operator precedence) dan jebakan pembagian bilangan bulat.
Melakukan konversi tipe data (casting dan parsing) dengan benar.
Memakai class Math untuk perhitungan matematis.
Mengolah String menggunakan method bawaan, formatted(), dan text block.

Alokasi Waktu Pertemuan Ini

Pertemuan ini berdurasi 3 jam:

Sesi	Topik	Durasi
Materi 1	Review pertemuan sebelumnya	10 menit
Materi 2	Operator aritmatika & ekspresi	20 menit
Materi 3	Operator assignment, increment & decrement	10 menit
Materi 4	Operator perbandingan & logika	15 menit
Materi 5	Konversi tipe data (casting & parsing)	15 menit
Materi 6	Class Math	10 menit
Materi 7	Dasar pengolahan String	25 menit
Materi 8	Studi kasus: kalkulator belanja	15 menit
Total Materi		2 jam
Latihan	Latihan Mandiri	1 jam
Total		3 jam

Review Singkat

Sebelum lanjut, pastikan kamu masih ingat hal-hal berikut:

Struktur dasar program: public class Main dan public static void main(String[] args).
Cara mendeklarasikan variabel: tipeData namaVariabel = nilai;.
System.out.println, print, dan printf untuk output.
Scanner untuk input, beserta jebakan nextLine() setelah nextInt().

Jebakan Locale pada Scanner: Scanner membaca angka pecahan sesuai pengaturan bahasa (locale) komputer. Jika komputermu memakai locale Indonesia, nextDouble() mengharapkan koma (2500,5) dan akan error jika kamu mengetik titik (2500.5). Agar konsisten, tambahkan input.useLocale(Locale.US); setelah membuat Scanner (dan import java.util.Locale;).

Operator Aritmatika dan Ekspresi

Ekspresi adalah gabungan nilai, variabel, dan operator yang menghasilkan sebuah nilai baru.

Operator	Fungsi	Contoh	Hasil
`+`	Penjumlahan	`17 + 5`	`22`
`-`	Pengurangan	`17 - 5`	`12`
`*`	Perkalian	`17 * 5`	`85`
`/`	Pembagian	`17 / 5`	`3` (bilangan bulat)
`%`	Modulus (sisa bagi)	`17 % 5`	`2`

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

        System.out.println(a + b);       // 22
        System.out.println(a - b);       // 12
        System.out.println(a * b);       // 85
        System.out.println(a / b);       // 3   -> pembagian bilangan bulat
        System.out.println(a % b);       // 2   -> sisa bagi
        System.out.println(17.0 / 5);    // 3.4 -> salah satu operand pecahan
    }
}

Pembagian Bilangan Bulat

Jika kedua operand bertipe bilangan bulat, hasil pembagian juga bilangan bulat (bagian desimal dibuang). Ini adalah sumber logical error yang sangat sering terjadi.

1
2
3

System.out.println(7 / 2);      // 3
System.out.println(7 / 2.0);    // 3.5
System.out.println(1 / 2);      // 0

Operator % sangat berguna, misalnya untuk menentukan ganjil/genap (n % 2 == 0) atau mengambil digit terakhir (n % 10).

Urutan Prioritas Operator

Java mengikuti aturan matematika: dikerjakan dari prioritas tertinggi, dan jika sama maka dari kiri ke kanan.

Prioritas	Operator
1 (tertinggi)	`( )` kurung
2	`++` `--` `!` (unary)
3	`*` `/` `%`
4	`+` `-`
5	`<` `<=` `>` `>=`
6	`==` `!=`
7	`&&`
8	`\	\	`
9 (terendah)	`=` `+=` `-=` `*=` `/=` `%=`

1
2
3

int hasil1 = 2 + 3 * 4;       // 14
int hasil2 = (2 + 3) * 4;     // 20
int hasil3 = 20 / 4 * 2;      // 10 (kiri ke kanan)

Tips: jika ragu, gunakan tanda kurung agar maksud kodenya jelas.

Overflow pada Bilangan Bulat

Setiap tipe data memiliki batas. Jika hasil melebihi batas, nilainya “berputar” tanpa pesan error.

1
2
3

int maks = Integer.MAX_VALUE;                 // 2147483647
System.out.println(maks + 1);                 // -2147483648 (overflow!)
System.out.println(Math.addExact(maks, 1));   // ArithmeticException: integer overflow

Math.addExact(), subtractExact(), dan multiplyExact() akan melempar exception saat overflow sehingga kesalahan tidak terjadi diam-diam. Untuk bilangan yang lebih besar gunakan tipe long.

Pecahan Tidak Selalu Presisi

Tipe double menyimpan pecahan dalam bentuk biner sehingga bisa menghasilkan selisih sangat kecil:

1
2
3

System.out.println(0.1 + 0.2);    // 0.30000000000000004
System.out.println(1.0 / 0);      // Infinity  (double tidak error saat dibagi nol)
System.out.println(1 / 0);        // ArithmeticException: / by zero (int error)

Untuk perhitungan uang yang presisi pada aplikasi nyata, gunakan class BigDecimal (akan kamu temui pada pembelajaran lanjutan).

Operator Assignment, Increment, dan Decrement

Operator assignment gabungan menyingkat penulisan:

Operator	Sama dengan	Contoh
`+=`	`x = x + n`	`skor += 10;`
`-=`	`x = x - n`	`nyawa -= 1;`
`*=`	`x = x * n`	`harga *= 2;`
`/=`	`x = x / n`	`total /= 4;`
`%=`	`x = x % n`	`sisa %= 7;`

Operator ++ dan -- menambah atau mengurangi nilai variabel sebesar 1.

int x = 5;
x++;                 // x = 6
x--;                 // x = 5

int y = x++;         // y = 5, lalu x menjadi 6  (postfix: ambil nilai dulu, baru tambah)
int z = ++x;         // x menjadi 7, lalu z = 7  (prefix: tambah dulu, baru ambil nilai)
System.out.println(x + " " + y + " " + z);   // 7 5 7

Saran: gunakan x++ sebagai pernyataan tersendiri agar kode mudah dibaca, dan hindari mencampurnya dalam ekspresi yang rumit.

Operator Perbandingan dan Logika

Operator Perbandingan

Menghasilkan nilai boolean (true atau false).

Operator	Arti	Contoh	Hasil
`==`	Sama dengan	`5 == 5`	`true`
`!=`	Tidak sama dengan	`5 != 3`	`true`
`>`	Lebih besar	`5 > 8`	`false`
`<`	Lebih kecil	`5 < 8`	`true`
`>=`	Lebih besar atau sama	`5 >= 5`	`true`
`<=`	Lebih kecil atau sama	`6 <= 5`	`false`

Awas: = adalah assignment (mengisi nilai), sedangkan == adalah perbandingan. Selain itu, jangan membandingkan String dengan ==. Gunakan .equals() (dibahas pada bagian String).

Operator Logika

Operator	Nama	Arti
`&&`	AND	`true` jika kedua kondisi `true`
`\	\	`	OR	`true` jika salah satu kondisi `true`
`!`	NOT	Membalik nilai boolean

int umur = 20;
boolean punyaKtp = true;

boolean boleh = umur >= 17 && punyaKtp;     // true
boolean diskon = umur < 12 || umur > 60;    // false
boolean bukanRemaja = !(umur >= 13 && umur <= 19);   // true

A	B	A && B	A \	\
true	true	true	true	false
true	false	false	true	false
false	true	false	true	true
false	false	false	false	true

Short-circuit

Operator && dan || berhenti mengevaluasi begitu hasilnya sudah pasti. Ini bisa dimanfaatkan untuk menghindari error:

1
2
3

int pembagi = 0;
boolean aman = pembagi != 0 && 10 / pembagi > 2;   // 10 / 0 tidak pernah dievaluasi
System.out.println(aman);                          // false, tanpa exception

Konversi Tipe Data

Casting

Java mengenal dua jenis konversi antar tipe numerik:

1. Widening (otomatis): dari tipe kecil ke tipe besar, aman tanpa kehilangan data.

1	byte → short → int → long → float → double

1
2
3

int angka = 10;
double hasil = angka;       // 10.0
long besar = angka;         // 10

2. Narrowing (manual): dari tipe besar ke tipe kecil, harus ditulis eksplisit dan data bisa hilang.

double pi = 3.99;
int bulat = (int) pi;       // 3 (dipotong, BUKAN dibulatkan)

int besar = 130;
byte kecil = (byte) besar;  // -126 (nilai melebihi batas byte, hasilnya berputar)

Casting sering dipakai untuk memperbaiki pembagian bilangan bulat:

int jumlah = 7;
int orang = 2;

System.out.println(jumlah / orang);                 // 3
System.out.println((double) jumlah / orang);        // 3.5  (cast dulu, baru bagi)
System.out.println((double) (jumlah / orang));      // 3.0  (SALAH: dibagi dulu, baru cast)

Konversi Angka dan Karakter

char huruf = 'A';
System.out.println(huruf + 1);          // 66  (char + int menjadi int)
System.out.println((char) (huruf + 1)); // B
System.out.println((int) 'a');          // 97

Parsing: String ke Angka dan Sebaliknya

int umur = Integer.parseInt("21");
double tinggi = Double.parseDouble("170.5");
String teks = String.valueOf(42);           // "42"
String teks2 = Integer.toString(42);        // "42"
String gabung = "Nilai: " + 42;             // "Nilai: 42"

Integer.parseInt("dua puluh");              // NumberFormatException

Literal Angka dan `var`

int juta = 1_000_000;        // underscore memudahkan pembacaan
int biner = 0b1010;          // 10
int heksa = 0xFF;            // 255
long besar = 9_000_000_000L;
float f = 3.14f;

Sejak Java 10, kompiler dapat menebak tipe variabel lokal dengan var:

1
2
3

var nama = "Zulma";          // String
var umur = 21;               // int
var tinggi = 170.5;          // double

Aturan var: hanya untuk variabel lokal, wajib langsung diberi nilai, dan tipenya tetap (tidak dinamis seperti JavaScript). Untuk pemula, sebaiknya tetap tulis tipe secara eksplisit agar terbiasa dengan tipe data.

Class Math

Class Math tersedia otomatis (tanpa import) dan berisi banyak method matematika.

Method	Fungsi	Contoh	Hasil
`Math.abs(x)`	Nilai mutlak	`Math.abs(-7)`	`7`
`Math.max(a, b)`	Nilai terbesar	`Math.max(3, 9)`	`9`
`Math.min(a, b)`	Nilai terkecil	`Math.min(3, 9)`	`3`
`Math.pow(a, b)`	Pangkat	`Math.pow(2, 10)`	`1024.0`
`Math.sqrt(x)`	Akar kuadrat	`Math.sqrt(144)`	`12.0`
`Math.cbrt(x)`	Akar pangkat tiga	`Math.cbrt(27)`	`3.0`
`Math.round(x)`	Pembulatan terdekat	`Math.round(2.5)`	`3`
`Math.floor(x)`	Pembulatan ke bawah	`Math.floor(-2.5)`	`-3.0`
`Math.ceil(x)`	Pembulatan ke atas	`Math.ceil(2.1)`	`3.0`
`Math.clamp(v, min, max)`	Membatasi nilai dalam rentang (Java 21+)	`Math.clamp(150, 0, 100)`	`100`
`Math.PI`	Konstanta π		`3.141592653589793`

public class Main {
    public static void main(String[] args) {
        double jariJari = 7;
        double luas = Math.PI * Math.pow(jariJari, 2);
        System.out.printf("Luas lingkaran: %.2f%n", luas);          // 153.94

        double sisiA = 3, sisiB = 4;
        double sisiC = Math.sqrt(Math.pow(sisiA, 2) + Math.pow(sisiB, 2));
        System.out.println("Sisi miring: " + sisiC);                 // 5.0

        int nilaiAkhir = Math.clamp(115, 0, 100);                    // dibatasi maksimal 100
        System.out.println(nilaiAkhir);                              // 100
    }
}

Math.round(double) mengembalikan long, sedangkan Math.round(float) mengembalikan int. Gunakan casting (int) bila perlu.

Dasar Pengolahan String

String adalah objek yang menyimpan rangkaian karakter dan bersifat immutable (tidak dapat diubah). Setiap method yang “mengubah” String sebenarnya menghasilkan String baru.

1	String kata = "Belajar Java";

Method	Fungsi	Hasil untuk `kata`
`length()`	Panjang String	`12`
`charAt(0)`	Karakter pada indeks ke-0	`'B'`
`substring(0, 7)`	Potong indeks 0 sampai sebelum 7	`"Belajar"`
`substring(8)`	Potong dari indeks 8 sampai akhir	`"Java"`
`indexOf("Java")`	Posisi pertama kemunculan (`-1` jika tidak ada)	`8`
`toUpperCase()` / `toLowerCase()`	Ubah huruf besar/kecil	`"BELAJAR JAVA"`
`contains("Java")`	Apakah memuat teks	`true`
`startsWith("Bel")` / `endsWith("va")`	Awalan / akhiran	`true` / `true`
`replace("Java", "Python")`	Ganti teks	`"Belajar Python"`
`strip()`	Hapus spasi di awal/akhir
`isEmpty()` / `isBlank()`	Kosong / kosong atau hanya spasi	`false`
`repeat(3)`	Ulangi String	`"Belajar JavaBelajar JavaBelajar Java"`

Indeks String dimulai dari 0: karakter pertama berada di indeks 0, dan karakter terakhir di indeks length() - 1.

Membandingkan String

String a = "java";
String b = new String("java");

System.out.println(a == b);                  // false (membandingkan alamat objek)
System.out.println(a.equals(b));             // true  (membandingkan isi)
System.out.println("JAVA".equalsIgnoreCase(a)); // true
System.out.println("apel".compareTo("bola"));   // negatif ("apel" lebih dulu secara alfabet)

Aturan emas: bandingkan isi String selalu dengan .equals(), bukan ==.

Format String dan Text Block

String nama = "Zulma";
int umur = 21;

String sapa = "Halo, " + nama + "! Umurmu " + umur + " tahun.";   // concatenation
String sapa2 = "Halo, %s! Umurmu %d tahun.".formatted(nama, umur); // formatted() sejak Java 15

Text block (Java 15+) memudahkan penulisan teks beberapa baris tanpa \n:

String struk = """
        ===== TOKO ZULMA =====
        Barang : Buku Tulis
        Harga  : Rp 5.000
        ======================
        """;
System.out.print(struk);

Spasi indentasi dihitung relatif terhadap posisi penutup """, sehingga hasil cetaknya tetap rata kiri.

StringBuilder

Karena String immutable, menggabungkan teks berulang kali di dalam perulangan kurang efisien. Gunakan StringBuilder:

StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append(" ");
sb.append(25);
System.out.println(sb.toString());              // Java 25
System.out.println(sb.reverse().toString());    // 52 avaJ

Studi Kasus: Kalkulator Belanja

Program berikut menggabungkan konsep input, operator, konstanta, casting, dan format output.

import java.util.Locale;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        final double PPN = 0.11;
        Scanner input = new Scanner(System.in);
        input.useLocale(Locale.US);

        System.out.print("Nama barang   : ");
        String barang = input.nextLine();
        System.out.print("Harga satuan  : ");
        double harga = input.nextDouble();
        System.out.print("Jumlah beli   : ");
        int jumlah = input.nextInt();
        System.out.print("Diskon (%)    : ");
        double diskonPersen = input.nextDouble();

        double subtotal = harga * jumlah;
        double diskon = subtotal * diskonPersen / 100;
        double kenaPajak = subtotal - diskon;
        double pajak = kenaPajak * PPN;
        double total = kenaPajak + pajak;

        System.out.println("=".repeat(32));
        System.out.printf("Barang   : %s x%d%n", barang, jumlah);
        System.out.printf("Subtotal : Rp %,.2f%n", subtotal);
        System.out.printf("Diskon   : Rp %,.2f%n", diskon);
        System.out.printf("PPN 11%%  : Rp %,.2f%n", pajak);
        System.out.printf("TOTAL    : Rp %,.2f%n", total);
        System.out.println("=".repeat(32));

        input.close();
    }
}

Catatan: pada printf, untuk mencetak karakter persen gunakan %%. Flag , pada %,.2f menambahkan pemisah ribuan.

Latihan

Kerjakan latihan berikut untuk mengetes pemahamanmu. Total durasi latihan adalah 60 menit.

No	Latihan	Estimasi
1	Kalkulator Dua Bilangan	10 menit
2	Konversi Detik ke Jam:Menit:Detik	10 menit
3	Prediksi Output (Tracing)	10 menit
4	Pengolahan String	10 menit
5	Struk Belanja dengan Diskon & Pajak	15 menit
6	Debugging Logical Error	5 menit
	Total	60 menit

Latihan 1: Kalkulator Dua Bilangan (estimasi 10 menit)

Buat program yang meminta dua bilangan bulat, lalu menampilkan hasil +, -, *, / (hasil pecahan 2 angka di belakang koma), dan %. Contoh:

Bilangan 1 : 17
Bilangan 2 : 5
17 + 5 = 22
17 - 5 = 12
17 * 5 = 85
17 / 5 = 3.40
17 % 5 = 2

Latihan 2: Konversi Detik (estimasi 10 menit)

Buat program yang meminta total detik, lalu mengubahnya menjadi format jam, menit, dan detik. Gunakan operator / dan %.

1 2	Total detik : 3725 Hasil : 1 jam 2 menit 5 detik

Latihan 3: Prediksi Output (estimasi 10 menit)

Tanpa menjalankan program, tuliskan output dari tiap potongan kode berikut. Setelah itu, jalankan di IDE dan cocokkan jawabanmu.

// a
int a = 10, b = 3;
System.out.println(a / b + " " + a % b + " " + (double) a / b);

// b
int x = 5;
int y = x++ + ++x;
System.out.println(x + " " + y);

// c
System.out.println(1 + 2 + "3" + 4 + 5);

// d
System.out.println('A' + 'B');
System.out.println("" + 'A' + 'B');

// e
boolean hasil = (5 > 3) && !(2 > 4) || (10 / 2 == 3);
System.out.println(hasil);

Latihan 4: Pengolahan String (estimasi 10 menit)

Buat program yang meminta nama lengkap (misalnya zulma aulia putri), lalu tampilkan:

Nama dalam huruf kapital semua.
Jumlah karakter (tanpa menghitung spasi di awal/akhir).
Karakter pertama dan karakter terakhir.
Apakah nama memuat kata "aulia" (true/false).
Nama dengan spasi diganti tanda garis bawah (_).

Latihan 5: Diskon dan Pajak (estimasi 15 menit)

Kembangkan studi kasus kalkulator belanja menjadi program yang:

Menerima 3 jenis barang (nama, harga, jumlah) satu per satu.
Menghitung subtotal tiap barang dan total keseluruhan.
Memberi diskon 10% pada total, lalu menambah PPN 11%.
Mencetak struk menggunakan text block atau printf yang rapi, dengan pemisah ribuan.

Latihan 6: Debugging Logical Error (estimasi 5 menit)

Kode berikut seharusnya menghitung rata-rata tiga nilai (hasil: 83.33), namun hasilnya salah. Temukan dua kesalahannya dan perbaiki.

int n1 = 80, n2 = 85, n3 = 85;
double rata = n1 + n2 + n3 / 3;
System.out.println("Rata-rata: " + rata);

int total = n1 + n2 + n3;
double rata2 = total / 3;
System.out.println("Rata-rata: " + rata2);

Catatan: pada Latihan 3, jelaskan juga mengapa hasil (c) dan (d) bisa berbeda dari dugaan awalmu.