Komentar #

// Inisialisasi batas maksimal percobaan login
int maxPercobaan = 3;

int hitungan = 0;
hitungan++; // increment setelah setiap percobaan gagal

// Gunakan epsilon untuk menghindari kesalahan floating-point
double epsilon = 1e-9;
if (Math.abs(a - b) < epsilon) {
    // Anggap sama jika selisihnya sangat kecil
}

// ANTI-PATTERN: mengomentari hal yang sudah jelas dari kode
int i = 0;          // set i ke 0
i++;                // tambahkan 1 ke i
list.clear();       // kosongkan list

// BENAR: komentari alasan (why), bukan mekanisme (what)
int percobaan = 0;
percobaan++;        // setiap gagal, counter naik sebelum cek batas

list.clear();       // reset state sebelum memproses batch berikutnya
                    // jangan hapus ini — diperlukan agar tidak ada data stale

// Timeout dikurangi 500ms karena ada network overhead di environment staging
int timeoutMs = 4500;

/*
 * Algoritma ini menggunakan pendekatan sliding window untuk menemukan
 * substring terpanjang tanpa karakter berulang. Kompleksitas waktu O(n)
 * karena setiap karakter diproses paling banyak dua kali.
 */
public int panjangSubstringUnik(String s) {
    Map<Character, Integer> posisi = new HashMap<>();
    int maks = 0, kiri = 0;

    for (int kanan = 0; kanan < s.length(); kanan++) {
        char c = s.charAt(kanan);
        if (posisi.containsKey(c) && posisi.get(c) >= kiri) {
            kiri = posisi.get(c) + 1;
        }
        posisi.put(c, kanan);
        maks = Math.max(maks, kanan - kiri + 1);
    }
    return maks;
}

/*
// Kode lama — dinonaktifkan sementara selama migrasi ke API v2
Response resp = apiV1.kirimRequest(payload);
prosesResponseV1(resp);
*/

// Kode baru
Response resp = apiV2.kirimRequest(payload);
prosesResponseV2(resp);

/**
 * Kalimat pertama adalah ringkasan — ditampilkan di indeks dan tooltip IDE.
 * Kalimat berikutnya adalah deskripsi detail yang bisa sepanjang apapun.
 * Gunakan HTML dasar untuk formatting: {@code kode}, <b>bold</b>, <ul><li>list</li></ul>.
 *
 * <p>Paragraf baru dimulai dengan tag &lt;p&gt;.</p>
 *
 * @param  namaParam  deskripsi parameter (tanpa tipe, sudah ada di signature)
 * @return            apa yang dikembalikan dan kondisi kapan bernilai null
 * @throws NamaException  kondisi yang menyebabkan exception ini dilempar
 * @see    KelasLain#metodeLain()  referensi silang ke dokumentasi lain
 * @since  2.0  versi pertama fitur ini tersedia
 * @deprecated  gunakan {@link #metodoBaru()} sejak versi 3.0
 */

/**
 * Representasi rekening bank dengan dukungan operasi setor dan tarik tunai.
 *
 * <p>Semua operasi yang mengubah saldo bersifat thread-safe karena menggunakan
 * {@code synchronized}. Namun, urutan operasi antar thread tetap tidak dijamin
 * tanpa sinkronisasi eksternal.</p>
 *
 * <pre>{@code
 * Rekening rek = new Rekening("BCA-001", 500_000);
 * rek.setor(100_000);
 * rek.tarik(50_000);
 * System.out.println(rek.getSaldo()); // 550000.0
 * }</pre>
 *
 * @author  Uni Badri
 * @version 1.2
 * @since   1.0
 * @see     TransaksiService
 */
public class Rekening {
    // ...
}

/**
 * Mentransfer sejumlah dana dari rekening ini ke rekening tujuan.
 *
 * <p>Transfer hanya dilakukan jika saldo rekening sumber mencukupi.
 * Kedua operasi (debit dan kredit) dilakukan secara atomik — tidak ada
 * keadaan di mana debit berhasil tetapi kredit gagal.</p>
 *
 * @param  tujuan  rekening penerima; tidak boleh {@code null} dan tidak
 *                 boleh sama dengan rekening ini sendiri
 * @param  jumlah  jumlah yang ditransfer; harus lebih besar dari nol
 * @return         {@code true} jika transfer berhasil,
 *                 {@code false} jika saldo tidak mencukupi
 * @throws IllegalArgumentException  jika {@code tujuan} null, sama dengan
 *                                   rekening ini, atau {@code jumlah} &lt;= 0
 * @throws RekeningTerkunciException jika salah satu rekening sedang terkunci
 * @since  1.1
 */
public boolean transfer(Rekening tujuan, double jumlah) {
    if (tujuan == null || tujuan == this) {
        throw new IllegalArgumentException("Rekening tujuan tidak valid");
    }
    if (jumlah <= 0) {
        throw new IllegalArgumentException("Jumlah transfer harus positif");
    }
    if (saldo < jumlah) {
        return false;
    }
    this.saldo  -= jumlah;
    tujuan.saldo += jumlah;
    return true;
}

public class KonfigurasiKoneksi {

    /**
     * Jumlah maksimal percobaan koneksi ulang sebelum menyerah.
     * Nilai ini dikalibrasi berdasarkan SLA layanan downstream — jangan
     * dinaikkan tanpa koordinasi dengan tim infrastruktur.
     */
    public static final int MAKS_RETRY = 5;

    /**
     * Timeout koneksi dalam milidetik.
     *
     * @see #MAKS_RETRY
     */
    public static final int TIMEOUT_MS = 3000;

    /**
     * Nomor rekening dalam format {@code BANK-XXXX} di mana XXXX adalah
     * empat digit angka. Contoh: {@code "BCA-0042"}.
     * Tidak boleh {@code null} atau kosong setelah konstruksi objek.
     */
    private String nomorRekening;
}

/**
 * @param  namaParam deskripsi  — untuk setiap parameter metode/konstruktor
 * @return deskripsi            — tipe dan kondisi return value; tidak untuk void
 * @throws NamaException alasan — kondisi yang menyebabkan exception; bisa lebih dari satu
 * @see    Kelas#metode()       — referensi silang ke kelas/metode lain
 * @see    <a href="url">teks</a> — referensi ke URL eksternal
 * @since  versi                — versi pertama tersedia
 * @deprecated alasan           — penanda bahwa API sudah usang + alternatifnya
 * @author nama                 — penulis (biasanya di level kelas)
 * @version versi               — versi kelas (biasanya di level kelas)
 */

/**
 * Contoh tag inline:
 *
 * {@code kodeJava}        — menampilkan teks sebagai kode monospace, di-escape HTML
 * {@link Kelas#metode()}  — hyperlink ke dokumentasi elemen lain
 * {@linkplain Kelas teks} — seperti @link tapi tampilan teksnya bisa dikustomisasi
 * {@value KONSTANTA}      — menyisipkan nilai konstanta static final
 * {@inheritDoc}           — mewarisi Javadoc dari metode yang di-override
 */

/**
 * Menghitung diskon berdasarkan jumlah pembelian.
 *
 * @param  jumlah total pembelian dalam rupiah
 * @return persentase diskon antara 0.0 dan 1.0
 * @deprecated Gunakan {@link #hitungDiskonV2(double, String)} sejak versi 2.0.
 *             Metode ini tidak mempertimbangkan kategori produk dan akan
 *             dihapus pada versi 3.0.
 */
@Deprecated(since = "2.0", forRemoval = true)
public double hitungDiskon(double jumlah) {
    return jumlah > 1_000_000 ? 0.15 : 0.05;
}

/**
 * Menghitung diskon berdasarkan jumlah pembelian dan kategori produk.
 *
 * @param  jumlah    total pembelian dalam rupiah
 * @param  kategori  kategori produk: "elektronik", "fashion", atau "makanan"
 * @return persentase diskon antara 0.0 dan 1.0
 * @since  2.0
 */
public double hitungDiskonV2(double jumlah, String kategori) {
    // implementasi baru
}

# Generate dokumentasi untuk semua file di direktori src/
javadoc -d docs -sourcepath src -subpackages com.example

# Generate dengan encoding dan judul
javadoc \
  -d docs \
  -encoding UTF-8 \
  -docencoding UTF-8 \
  -charset UTF-8 \
  -windowtitle "MyApp API Documentation" \
  -doctitle "MyApp v1.0 API" \
  -sourcepath src \
  -subpackages com.example

# Buka hasilnya di browser
open docs/index.html   # macOS
xdg-open docs/index.html  # Linux

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-javadoc-plugin</artifactId>
    <version>3.6.3</version>
    <configuration>
        <encoding>UTF-8</encoding>
        <show>protected</show>
    </configuration>
</plugin>

# Generate via Maven
mvn javadoc:javadoc

# Hasil ada di target/site/apidocs/index.html

// ✗ ANTI-PATTERN 1: komentar yang mengulangi kode
// Tambahkan pajak ke total
total = total + pajak;

// Cek apakah stok habis
if (stok == 0) {

// ✗ ANTI-PATTERN 2: komentar yang sudah usang dan menyesatkan
// Mengembalikan nama depan pengguna
public String getNamaPengguna() {
    return namaDepan + " " + namaBelakang; // ternyata mengembalikan nama lengkap
}

// ✗ ANTI-PATTERN 3: kode yang dikomentari tanpa penjelasan
// if (debug) logger.info("nilai: " + nilai);
// return prosesLama(input);
// validasiTambahan(x);

// ✗ ANTI-PATTERN 4: komentar TODO yang tidak pernah diselesaikan
// TODO: perbaiki ini nanti
// TODO: handle edge case
// FIXME: ini sering crash

// ✗ ANTI-PATTERN 5: komentar yang menjelaskan "apa" bukan "mengapa"
i = i + 1; // tambah 1 ke i

// ✓ BENAR: komentari keputusan desain dan konteks yang tidak terlihat dari kode
// Gunakan LinkedList bukan ArrayList karena operasi utama di sini adalah
// insert di posisi tengah — O(1) untuk LinkedList vs O(n) untuk ArrayList
List<Tugas> antrian = new LinkedList<>();

// Delay 200ms diperlukan untuk memberi waktu service downstream
// menyelesaikan commit sebelum kita query. Tanpa ini, data bisa stale.
// Lihat tiket INFRA-4421 untuk konteks lengkap.
Thread.sleep(200);

// Validasi harga negatif tidak dilakukan di sini karena sudah divalidasi
// di lapisan API sebelum sampai ke service ini. Jika harga negatif lolos,
// itu adalah bug di lapisan API, bukan di sini.
this.harga = harga;

/**
 * Mencari produk berdasarkan kata kunci dengan pagination.
 *
 * @param  keyword  kata kunci pencarian; tidak boleh null, boleh kosong
 * @param  halaman  nomor halaman dimulai dari 0 (bukan 1)
 * @param  ukuran   jumlah item per halaman; maksimal 100
 * @return          halaman hasil pencarian; tidak pernah null,
 *                  list kosong jika tidak ada hasil
 */
public Page<Produk> cari(String keyword, int halaman, int ukuran) {
    // ...
}