Operator #

// ANTI-PATTERN: pembagian integer membuang desimal
int a = 10, b = 3;
double hasil = a / b;            // 3.0 — bukan 3.333...!
System.out.println(a / b);       // 3 — desimal dibuang

double rata = (1 + 2 + 3) / 3;  // 2.0 — bukan 2.0!
// 1+2+3 = 6, lalu 6/3 = 2 (integer), baru dikonversi ke double

// BENAR: cast salah satu operan ke double dulu
double hasil = (double) a / b;          // 3.3333...
double hasil = a / (double) b;          // 3.3333...
double rata  = (1 + 2 + 3) / 3.0;      // 2.0 — benar
double rata  = (double)(1 + 2 + 3) / 3; // 2.0 — benar

System.out.println( 7 % 3);   //  1
System.out.println(-7 % 3);   // -1 — negatif! (bukan 2)
System.out.println( 7 % -3);  //  1

// Jika butuh hasil selalu positif (true modulo):
int hasil = ((−7) % 3 + 3) % 3; // 2 — selalu non-negatif

int x = 5;

// Post-increment: nilai lama digunakan dulu, LALU di-increment
int a = x++;   // a = 5, kemudian x menjadi 6
System.out.println(a); // 5
System.out.println(x); // 6

// Pre-increment: di-increment dulu, LALU nilai baru digunakan
int b = ++x;   // x menjadi 7 dulu, kemudian b = 7
System.out.println(b); // 7
System.out.println(x); // 7

// ANTI-PATTERN: ++/-- dalam ekspresi kompleks — sulit dibaca
int y = 5;
int z = y++ + ++y; // membingungkan: y=5, lalu 5 + 7 = 12? atau?

// BENAR: gunakan ++/-- sebagai statement tersendiri
y++;
z = y + y;

byte b = 10;

// Ini COMPILE ERROR — int tidak bisa otomatis masuk ke byte
b = b + 1;          // ✗ ERROR: possible lossy conversion from int to byte

// Ini BENAR — += menyertakan cast implisit
b += 1;             // ✓ setara dengan b = (byte)(b + 1)

// Implikasi: compound assignment bisa menyebabkan narrowing diam-diam
byte nilai = 100;
nilai += 100;        // nilai = (byte)(100 + 100) = (byte)200 = -56! (overflow)

// && berhenti di operan kiri jika hasilnya sudah pasti false
String nama = null;
if (nama != null && nama.length() > 0) {  // ✓ aman
    System.out.println(nama);
    // jika nama null, nama.length() tidak pernah dipanggil
}

// ANTI-PATTERN: tanpa null check di kiri
if (nama.length() > 0 && nama != null) {  // ✗ NullPointerException jika nama null!

// || berhenti di operan kiri jika hasilnya sudah pasti true
int cache = -1;
int nilai = (cache != -1) || hitungNilaiMahal(); // hitungNilaiMahal() tidak dipanggil jika cache valid

// Gunakan && (short-circuit) untuk kondisi normal
// Operan kanan tidak dievaluasi jika tidak perlu
if (list != null && list.size() > 0) { }

// Gunakan & (non-short-circuit) HANYA jika operan kanan harus selalu dieksekusi
// karena punya efek samping yang dibutuhkan
if (validasiField1() & validasiField2()) {
    // kedua validasi selalu berjalan, error messages dari keduanya terkumpul
}

int a = 0b1010; // 10 dalam desimal
int b = 0b1100; // 12 dalam desimal

System.out.println(a & b);   // 0b1000 = 8  (AND)
System.out.println(a | b);   // 0b1110 = 14 (OR)
System.out.println(a ^ b);   // 0b0110 = 6  (XOR)
System.out.println(~a);      // -11          (NOT: flip semua bit + sign)

// Shift: perkalian/pembagian dengan pangkat 2 yang lebih cepat
int x = 4;
System.out.println(x << 2);  // 16  (x * 4)
System.out.println(x >> 1);  // 2   (x / 2)

// Bitmask — simpan banyak flag dalam satu int
final int FLAG_BACA   = 0b001; // 1
final int FLAG_TULIS  = 0b010; // 2
final int FLAG_EKSEKUSI = 0b100; // 4

int izin = FLAG_BACA | FLAG_TULIS; // izin = 0b011 = 3

// Cek apakah flag tertentu aktif
boolean bisaBaca  = (izin & FLAG_BACA)    != 0; // true
boolean bisaEksek = (izin & FLAG_EKSEKUSI) != 0; // false

// Tambah flag
izin |= FLAG_EKSEKUSI;   // izin = 0b111 = 7

// Hapus flag
izin &= ~FLAG_TULIS;     // izin = 0b101 = 5

// Sintaks: kondisi ? nilaiJikaTrue : nilaiJikaFalse
int maks = (a > b) ? a : b;

String status = (umur >= 18) ? "dewasa" : "anak-anak";

// Berguna untuk nilai default
String nama = (input != null) ? input : "Anonim";

// Atau gunakan ekuivalennya yang lebih bersih:
String nama = Objects.requireNonNullElse(input, "Anonim");

// BENAR: ternary untuk ekspresi sederhana satu baris
int abs = (x >= 0) ? x : -x;
String label = aktif ? "Aktif" : "Nonaktif";

// ANTI-PATTERN: ternary bersarang — sangat sulit dibaca
String kategori = (nilai >= 90) ? "A"
                : (nilai >= 80) ? "B"
                : (nilai >= 70) ? "C"
                : (nilai >= 60) ? "D" : "E"; // ✗ gunakan if-else atau switch

// BENAR: if-else untuk logika yang kompleks atau bersarang
String kategori;
if      (nilai >= 90) kategori = "A";
else if (nilai >= 80) kategori = "B";
else if (nilai >= 70) kategori = "C";
else if (nilai >= 60) kategori = "D";
else                  kategori = "E";

// Cara lama — periksa lalu cast secara terpisah
Object obj = "Halo Java";
if (obj instanceof String) {
    String s = (String) obj;  // cast manual
    System.out.println(s.length());
}

// Cara baru (Java 16+) — pattern matching: periksa + bind sekaligus
if (obj instanceof String s) {  // s otomatis bertipe String dalam blok ini
    System.out.println(s.length()); // tidak perlu cast manual
}

// Pattern matching membuat kode jauh lebih ringkas untuk polymorphism
void proses(Object bentuk) {
    if (bentuk instanceof Lingkaran c) {
        System.out.println("Jari-jari: " + c.getJariJari());
    } else if (bentuk instanceof Persegi p) {
        System.out.println("Sisi: " + p.getSisi());
    } else if (bentuk instanceof Segitiga s) {
        System.out.println("Alas: " + s.getAlas());
    }
}

// instanceof selalu false untuk null
String s = null;
System.out.println(s instanceof String); // false — tidak throw NPE

// Contoh precedence dalam praktik
int hasil = 2 + 3 * 4;       // 14 — bukan 20: * lebih tinggi dari +
int hasil = (2 + 3) * 4;     // 20 — kurung memaksa urutan

boolean cek = 5 > 3 && 2 < 4; // true: > dan < dievaluasi dulu, baru &&

// ANTI-PATTERN: mengandalkan precedence untuk ekspresi kompleks
int x = a++ * b-- + c >> 2;  // ✗ sangat sulit dibaca

// BENAR: gunakan kurung untuk memperjelas urutan yang dimaksud
int x = ((a++) * (b--) + c) >> 2; // ✓ niat jelas