{
  "assessmentTests": {
    "java_test": {
      "name": "Tes Java",
      "desc": "30 pertanyaan skenario tentang sintaks inti, mekanika OOP, collections, generics, pengecualian dan konkurensi — temukan apakah Java Anda sesuai dengan apa yang dimaksud lowongan kerja dengan profisiensi Java.",
      "recommendation": "Profil keterampilan Java Anda",
      "results": {
        "beginner": {
          "name": "Pemula",
          "desc": "Anda dapat menulis class dan method yang berfungsi, tetapi pertanyaan yang Anda lewatkan berkumpul di sekitar identity dan defaults daripada sintaks — String == vs .equals, mengapa new String(\"x\") tidak pernah menggunakan kembali string pool, apa default untuk numeric field versus wrapper field. Ini bukan tentang buruk di Java; ini adalah aturan khusus yang menjebak orang yang belajar bahasa dengan trial dan error daripada dari cara reference dan primitif bekerja di bawah hood. Ini penting di pekerjaan karena masing-masing adalah tempat di mana code compile, run, dan diam-diam melakukan hal yang salah.",
          "recommendation": "Mulai dengan tiga hal, dalam urutan ini: mengapa == pada dua String objects membandingkan reference bukan character (dan .equals adalah yang hampir selalu Anda inginkan), bagaimana int overflow membungkus diam-diam daripada melempar exception, dan mengapa uninitialized Integer field default ke null sementara int field default ke 0. Tutorial Java resmi Oracle dan Baeldung keduanya mencakup ketiga-tiganya dengan contoh yang dapat dijalankan."
        },
        "intermediate": {
          "name": "Menengah",
          "desc": "Anda menangani everyday application code dengan nyaman — class, collections, control flow yang straightforward — dan tidak akan diperlambat oleh routine feature work. Gap antara di sini dan Advanced sebagian besar tentang apa yang terjadi ketika aturan Java berinteraksi dengan concurrency dan generics: static method yang resolved oleh declared type daripada object yang Anda harapkan, HashMap iteration order yang Anda diam-diam andalkan, ConcurrentModificationException dari menghapus item mid-loop. Ini adalah jenis bug yang lolos dari quick read-through dan hanya muncul di bawah kondisi runtime tertentu.",
          "recommendation": "Fokus pada bagaimana static view dari compiler tentang code Anda berbeda dengan apa yang berjalan: overload resolution dan static-method hiding oleh declared type daripada runtime type, mengapa HashMap tidak memberikan iteration-order guarantee, dan mengapa memodifikasi list langsung saat iterating melempar ConcurrentModificationException. Kemudian generics erasure, karena itu menjebak orang yang sudah tahu collections secara individual."
        },
        "advanced": {
          "name": "Lanjutan",
          "desc": "Ini adalah level yang paling dimaksud posting lowongan dengan \"Java kuat.\" Anda membaca class dengan static blocks, instance blocks dan multiple constructors dan dapat memprediksi exact order mereka berjalan, Anda tahu mengapa finally block dapat diam-diam membuang return value dari try block, dan Anda mengambil try-with-resources daripada manual finally-close karena Anda tahu ordering guarantee yang diberikannya. Apa yang memisahkan band ini dari top adalah sisi concurrent dan interface-level dari pekerjaan: apa yang benar-benar locked oleh synchronized, apa yang dilakukan volatile dan tidak dilakukan, dan bagaimana default-method conflicts diresolusi.",
          "recommendation": "Dorong ke bagian yang melindungi code yang threads lain dan interfaces lain juga sentuh: perbedaan antara apa yang synchronized instance method lock versus synchronized static method, mengapa volatile memberikan visibility tetapi tidak atomicity untuk counter++, dan bagaimana Java memaksa Anda untuk resolve default-method diamond dengan tangan. Materi Baeldung dan Java Concurrency in Practice tentang Java Memory Model adalah natural next stop untuk keduanya."
        },
        "expert": {
          "name": "Ahli",
          "desc": "Anda mencetak di top setiap section — core syntax dan types, OOP mechanics dan scope, collections dan generics, dan exceptions, concurrency dan idioms. Secara praktis, itu berarti Anda dapat diserahkan stranger's class dan jelaskan mengapa compile error, runtime exception, atau silently wrong value terjadi, bukan hanya apa yang syntax katakan seharusnya dilakukan, yang lebih sulit dan skill lebih berharga. Di level ini language itu sendiri jarang menjadi limiting factor; limit biasanya concurrency design atau bentuk dari data di bawahnya.",
          "recommendation": "Returns sekarang dalam design dan diagnosis: membaca thread dump sebelum asumsikan hang adalah deadlock, memilih antara synchronized, java.util.concurrent locks dan atomics sebagai tradeoff daripada default, dan stream-pipeline design yang tetap lazy on purpose daripada by accident. Jika Anda di-screen untuk role, jelaskan concurrency bug seperti missed happens-before edge atau ConcurrentModificationException yang Anda temukan dalam production daripada naming Java features — ini menunjukkan reasoning, bukan hanya vocabulary."
        }
      },
      "questions": [
        {
          "question": "Anda membuat dua String objects: String a = new String(\"cat\"); String b = new String(\"cat\"); Apa yang dievaluasi a == b?",
          "options": [
            {
              "icon": "",
              "label": "true — String literals dengan karakter yang sama selalu merupakan object yang sama"
            },
            {
              "icon": "",
              "label": "true — new String(...) menggunakan kembali string pool, jadi text yang identik selalu share satu object"
            },
            {
              "icon": "",
              "label": "Compile error — == tidak dapat digunakan untuk membandingkan String objects"
            },
            {
              "icon": "",
              "label": "false — new String(...) selalu mengalokasikan object baru di heap, jadi == membandingkan dua reference berbeda meskipun .equals(b) akan mengembalikan true"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); kemudian Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); Apa yang dicetak oleh kedua baris?",
          "options": [
            {
              "icon": "",
              "label": "true kemudian true — autoboxed Integer objects selalu di-cache terlepas dari value"
            },
            {
              "icon": "",
              "label": "false kemudian false — == pada Integer objects selalu reference comparison, jadi equal values tidak pernah cocok"
            },
            {
              "icon": "",
              "label": "true kemudian false, tetapi hanya karena 200 overflow byte — cache boundary tidak terkait dengan -128..127"
            },
            {
              "icon": "",
              "label": "true kemudian false — autoboxed Integer values dari -128 hingga 127 di-cache dan di-share, jadi 100 menggunakan kembali satu object, tetapi 200 jatuh di luar cache dan autobox ke dua object terpisah"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); Apa yang terjadi?",
          "options": [
            {
              "icon": "",
              "label": "Ini melempar ArithmeticException untuk integer overflow"
            },
            {
              "icon": "",
              "label": "Ini mencetak Integer.MAX_VALUE lagi, karena Java clamps pada maximum type"
            },
            {
              "icon": "",
              "label": "Ini mencetak Integer.MIN_VALUE — int arithmetic membungkus diam-diam pada overflow daripada melempar"
            },
            {
              "icon": "",
              "label": "Compile error — compiler mendeteksi overflow terlebih dahulu"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); Apa yang dicetak ini, dan mengapa?",
          "options": [
            {
              "icon": "",
              "label": "false — 0.1, 0.2 dan 0.3 tidak dapat direpresentasikan dengan tepat dalam binary floating point, jadi jumlah membawa rounding error yang membuatnya tidak bit-for-bit sama dengan 0.3"
            },
            {
              "icon": "",
              "label": "true — Java rounds double arithmetic ke nearest representable decimal sebelum membandingkan"
            },
            {
              "icon": "",
              "label": "true — addition dari dua double selalu exact untuk values dengan dua digit desimal"
            },
            {
              "icon": "",
              "label": "Ini melempar exception, karena == tidak didefinisikan untuk double dalam Java"
            }
          ]
        },
        {
          "question": "Class mendeklarasikan dua instance fields tanpa initializer: int count; dan Integer total; Sebelum constructor berjalan, apa default values mereka?",
          "options": [
            {
              "icon": "",
              "label": "Keduanya default ke 0, karena Integer autobox ke int pada field initialization"
            },
            {
              "icon": "",
              "label": "count adalah 0 dan total adalah 0, boxed secara otomatis kali pertama dibaca"
            },
            {
              "icon": "",
              "label": "count adalah 0 dan total adalah null — primitive numeric fields default ke zero, tetapi uninitialized wrapper reference field default ke null seperti object reference lainnya"
            },
            {
              "icon": "",
              "label": "Keduanya default ke null sampai explicitly assigned, karena Java tidak memiliki implicit numeric defaults"
            }
          ]
        },
        {
          "question": "Loop berjalan 1000 kali, setiap kali melakukan result += \"x\"; pada String result. Apa yang benar-benar terjadi di bawah hood setiap iteration?",
          "options": [
            {
              "icon": "",
              "label": "Internal character array dari existing String object diperluas in place"
            },
            {
              "icon": "",
              "label": "Java secara otomatis membatching concatenations dan hanya mengalokasikan satu final String object"
            },
            {
              "icon": "",
              "label": "Compile ke single StringBuilder.append() call yang di-share di seluruh 1000 iterations, tanpa extra object dialokasikan per iteration"
            },
            {
              "icon": "",
              "label": "Brand new String object dibuat dan result di-reassign untuk point di atasnya — previous String object discarded, karena String adalah immutable dan += tidak dapat memodifikasinya in place"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); Mana dari ini yang true?",
          "options": [
            {
              "icon": "",
              "label": "names.add(\"Ana\") compile dan berfungsi fine — final hanya mencegah reassigning names reference itu sendiri, bukan mutating object yang dipointnya"
            },
            {
              "icon": "",
              "label": "names.add(\"Ana\") adalah compile error, karena final membuat list itu sendiri unmodifiable"
            },
            {
              "icon": "",
              "label": "List adalah thread-safe untuk concurrent writes karena dideklarasikan final"
            },
            {
              "icon": "",
              "label": "final pada local variable tidak memiliki effect kecuali type juga dideklarasikan immutable"
            }
          ]
        },
        {
          "question": "int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a == b); System.out.println(Arrays.equals(a, b)); Apa yang dicetak oleh kedua baris?",
          "options": [
            {
              "icon": "",
              "label": "false kemudian true — == membandingkan array references (dua different array objects), sementara Arrays.equals membandingkan elements"
            },
            {
              "icon": "",
              "label": "true kemudian true — arrays dengan identical contents adalah same object dalam Java"
            },
            {
              "icon": "",
              "label": "false kemudian false — Arrays.equals hanya bekerja untuk object arrays, bukan primitive int arrays"
            },
            {
              "icon": "",
              "label": "true kemudian false — == pada arrays membandingkan contents, dan Arrays.equals adalah redundant"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(\"Object\"); } void show(String s) { print(\"String\"); } Object ref = \"hello\"; show(ref); Overload mana yang berjalan, dan mengapa?",
          "options": [
            {
              "icon": "",
              "label": "show(String) berjalan, karena Java menginspeksi actual runtime class dari object sebelum memilih overload"
            },
            {
              "icon": "",
              "label": "show(Object) berjalan — overload resolution diputuskan pada compile time menggunakan declared type dari variable, bukan actual runtime type dari object yang direferensikan"
            },
            {
              "icon": "",
              "label": "Compile error — Object tidak dapat dilewatkan di mana more specific overload ada"
            },
            {
              "icon": "",
              "label": "Kedua method berjalan, sekali masing-masing, karena Java resolves overloads dengan trying setiap match"
            }
          ]
        },
        {
          "question": "Class Base memiliki static void greet() { print(\"Base\"); }. Class Derived extends Base dan juga mendeklarasikan static void greet() { print(\"Derived\"); }. Anda menulis: Base ref = new Derived(); ref.greet(); Apa yang dicetak?",
          "options": [
            {
              "icon": "",
              "label": "Derived — static methods override seperti instance methods, mengikuti actual object's runtime type"
            },
            {
              "icon": "",
              "label": "Compile error — static methods tidak dapat dipanggil melalui instance reference"
            },
            {
              "icon": "",
              "label": "Base — static methods tidak polymorphic; memanggil satu melalui reference diresolusi oleh reference's declared type pada compile time, bukan object's actual type"
            },
            {
              "icon": "",
              "label": "Kedua Base dan Derived cetak, karena call resolves ke both hidden dan hiding versions"
            }
          ]
        },
        {
          "question": "Di dalam method, Anda menulis int count = 0; kemudian coba reference count dari dalam lambda yang dilewatkan ke method lain. Apa yang harus true tentang count agar ini compile?",
          "options": [
            {
              "icon": "",
              "label": "count harus effectively final — tidak pernah di-reassign di mana pun setelah initial value — karena lambda menangkap snapshot, bukan live reference ke mutable local variable"
            },
            {
              "icon": "",
              "label": "Tidak ada — any local variable dapat freely dibaca dan di-reassign dari dalam lambda"
            },
            {
              "icon": "",
              "label": "count harus dideklarasikan volatile jadi lambda selalu melihat latest value-nya"
            },
            {
              "icon": "",
              "label": "count harus field, bukan local variable — lambdas tidak dapat menangkap locals sama sekali"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(\"new\"); } dipanggil sebagai StringBuilder original = new StringBuilder(\"old\"); rename(original); Apa original setelah call?",
          "options": [
            {
              "icon": "",
              "label": "Menjadi \"new\" — objects dilewatkan by reference dalam Java, jadi reassigning parameter mengubah caller's variable juga"
            },
            {
              "icon": "",
              "label": "Menjadi \"new\" hanya untuk mutable types seperti StringBuilder, tetapi bukan untuk immutable types"
            },
            {
              "icon": "",
              "label": "Tetap \"old\" — Java melewatkan reference itu sendiri by value, jadi reassigning parameter di dalam method hanya me-repoint local copy dari reference, meninggalkan caller's original untouched"
            },
            {
              "icon": "",
              "label": "Melempar runtime exception, karena sb di-reassign di dalam method"
            }
          ]
        },
        {
          "question": "Class memiliki static initializer block, instance initializer block, dan constructor, dalam source order itu. Anda membuat dua objects dari class ini satu demi satu. Dalam urutan apa ini berjalan?",
          "options": [
            {
              "icon": "",
              "label": "Static block berjalan exactly once, kali pertama class di-load; kemudian untuk setiap object, instance block berjalan dan kemudian constructor body berjalan"
            },
            {
              "icon": "",
              "label": "Ketiganya berjalan fresh, dalam source order, untuk setiap single object yang dibuat"
            },
            {
              "icon": "",
              "label": "Constructor berjalan first untuk setiap object, kemudian instance block, kemudian static block once di very end"
            },
            {
              "icon": "",
              "label": "Static block berjalan once per object, right sebelum instance block"
            }
          ]
        },
        {
          "question": "Class memiliki void log(String s) dan void log(String... args). Anda memanggil log(\"hi\"). Mana satu yang berjalan?",
          "options": [
            {
              "icon": "",
              "label": "log(String... args) — varargs overloads selalu di-prefer ketika keduanya applicable"
            },
            {
              "icon": "",
              "label": "Compile error — call adalah ambiguous antara dua overloads"
            },
            {
              "icon": "",
              "label": "log(String s) — ketika fixed-arity overload cocok exactly, Java selalu prefer-nya atas varargs overload, yang hanya digunakan sebagai last resort"
            },
            {
              "icon": "",
              "label": "Whichever dideklarasikan first dalam source file berjalan"
            }
          ]
        },
        {
          "question": "Baris pertama dari constructor memanggil this(0); untuk delegate ke another constructor dalam class yang sama. Di mana ini diizinkan untuk muncul?",
          "options": [
            {
              "icon": "",
              "label": "Di mana pun dalam constructor body, selama berjalan sebelum object dikembalikan"
            },
            {
              "icon": "",
              "label": "Hanya sebagai very first statement dari constructor — this() (atau super()) harus first line, dan constructor tidak dapat memanggil both this() dan super()"
            },
            {
              "icon": "",
              "label": "Hanya sebagai last statement, setelah semua field initialization complete"
            },
            {
              "icon": "",
              "label": "Hanya dalam constructors ditandai secara eksplisit sebagai delegating, menggunakan delegate keyword"
            }
          ]
        },
        {
          "question": "Anda membutuhkan list yang akan memiliki elements dimasukkan di front extremely sering, dan random-access reads jarang. Mana kombinasi yang structural fit lebih baik, dan mengapa?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList — contiguous backing array-nya membuat setiap operation, termasuk front-insertion, lebih cepat daripada linked structure"
            },
            {
              "icon": "",
              "label": "Keduanya perform identically, karena keduanya mengimplementasikan List interface dengan time guarantees yang sama"
            },
            {
              "icon": "",
              "label": "LinkedList — inserting di front adalah O(1) karena hanya relink node, sementara ArrayList harus shift setiap existing element naik satu, membuat front-insertion O(n)"
            },
            {
              "icon": "",
              "label": "LinkedList, karena supports random access dalam O(1) sementara ArrayList tidak"
            }
          ]
        },
        {
          "question": "Anda insert lima entries ke dalam plain HashMap dalam specific order, kemudian iterate atasnya dengan for-each loop. Urutan apa entries keluar?",
          "options": [
            {
              "icon": "",
              "label": "Urutan yang sama entries diinsert, karena Java maps selalu preserve insertion order"
            },
            {
              "icon": "",
              "label": "Tidak ada guaranteed order sama sekali — HashMap's iteration order bergantung pada hash bucket placement, bukan insertion order, dan bahkan dapat berubah antara runs; LinkedHashMap adalah apa yang preserve insertion order"
            },
            {
              "icon": "",
              "label": "Sorted oleh key secara otomatis, cara yang sama TreeMap behaves"
            },
            {
              "icon": "",
              "label": "Reverse dari insertion order, karena HashMap secara internal menggunakan stack"
            }
          ]
        },
        {
          "question": "Berapa banyak null keys yang dapat plain java.util.HashMap tahan pada sekali, dan berapa banyak null values?",
          "options": [
            {
              "icon": "",
              "label": "Tidak ada null keys dan tidak ada null values yang pernah diizinkan dalam any Map implementation"
            },
            {
              "icon": "",
              "label": "Satu null key paling banyak, dan any number dari null values — HashMap memungkinkan single null key, tidak seperti Hashtable yang tidak memungkinkan keduanya"
            },
            {
              "icon": "",
              "label": "Unlimited null keys dan unlimited null values, karena null diperlakukan seperti any other key"
            },
            {
              "icon": "",
              "label": "Satu null key dan satu null value maximum, keduanya di-cap di satu"
            }
          ]
        },
        {
          "question": "Anda iterate List dengan for-each loop dan panggil list.remove(item) langsung pada list dari dalam loop body, pada beberapa tetapi tidak semua elements. Apa yang terjadi?",
          "options": [
            {
              "icon": "",
              "label": "Ini bekerja correctly dan menghapus exactly intended elements"
            },
            {
              "icon": "",
              "label": "Ini diam-diam melompati element setelah yang dihapus, tetapi otherwise menyelesaikan tanpa error"
            },
            {
              "icon": "",
              "label": "Ini melempar IndexOutOfBoundsException sekali loop mencapai old size dari list"
            },
            {
              "icon": "",
              "label": "Ini melempar ConcurrentModificationException — memodifikasi list's structure langsung saat implicit iterator berjalan dideteksi dan ditolak; Iterator.remove() harus digunakan sebagai gantinya"
            }
          ]
        },
        {
          "question": "Pada runtime, given List<String> list, apa yang dapat Anda benar-benar tentukan tentang generic type parameter-nya via reflection atau instanceof?",
          "options": [
            {
              "icon": "",
              "label": "Anda dapat memanggil list.getElementType() untuk retrieve String.class pada runtime"
            },
            {
              "icon": "",
              "label": "instanceof List<String> compile dan correctly memeriksa element type"
            },
            {
              "icon": "",
              "label": "JVM menyimpan type parameter sebagai hidden metadata accessible via list.getGenericType()"
            },
            {
              "icon": "",
              "label": "Tidak ada — generic type information dihapus pada compile time, jadi pada runtime object hanya List, dan tidak ada cara untuk recover apakah dideklarasikan List<String> atau List<Integer>"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(\"Weekday\"); break; case 6: print(\"Saturday\"); case 7: print(\"Sunday\"); break; default: print(\"?\"); } Jika day adalah 6, apa yang dicetak?",
          "options": [
            {
              "icon": "",
              "label": "Hanya Saturday — setiap case block dalam switch selalu berhenti setelah sendiri print statement"
            },
            {
              "icon": "",
              "label": "Hanya Sunday — matching dimulai pada case 6 tetapi hanya last matching label sebelum break executes"
            },
            {
              "icon": "",
              "label": "Tidak ada yang cetak, karena day 6 tidak memiliki matching case dengan sendiri break langsung di bawahnya"
            },
            {
              "icon": "",
              "label": "Saturday kemudian Sunday — case 6 tidak memiliki break, jadi execution falls through ke next case's code sebelum hit following break"
            }
          ]
        },
        {
          "question": "Product class membutuhkan single, obvious \"natural\" sort order oleh price, plus kemampuan untuk juga sort oleh name atau oleh stock level dalam different places dalam codebase. Kombinasi mana yang design paling tepat?",
          "options": [
            {
              "icon": "",
              "label": "Implementasikan Comparable<Product> tiga kali terpisah, satu per ordering, dan biarkan caller memilih mana compareTo yang berjalan"
            },
            {
              "icon": "",
              "label": "Implementasikan Comparable<Product> untuk natural price ordering, dan tulis separate Comparator<Product> instances untuk name dan stock-level orderings yang digunakan di tempat lain"
            },
            {
              "icon": "",
              "label": "Gunakan hanya Comparator untuk setiap ordering, termasuk price, karena Comparable tidak memiliki advantage di sini"
            },
            {
              "icon": "",
              "label": "Gunakan hanya Comparable dengan menambahkan tiga overloaded compareTo methods, satu per ordering"
            }
          ]
        },
        {
          "question": "Method memanggil new FileReader(path), yang mendeklarasikan throws IOException. IOException extends Exception, bukan RuntimeException. Apa yang harus Anda lakukan agar ini compile?",
          "options": [
            {
              "icon": "",
              "label": "Tidak ada — compiler hanya enforce ini untuk exceptions yang extend RuntimeException"
            },
            {
              "icon": "",
              "label": "Baik tangkap IOException dalam try/catch atau deklarasikan throws IOException pada method Anda sendiri — checked exceptions harus ditangani atau di-propagate secara eksplisit, tidak seperti unchecked RuntimeException subclasses"
            },
            {
              "icon": "",
              "label": "Bungkus call dalam try/catch untuk RuntimeException, karena IOException secara otomatis unchecked dalam modern Java"
            },
            {
              "icon": "",
              "label": "Deklarasikan method sebagai static — static methods exempt dari checked exception handling"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(\"A\"); Resource b = new Resource(\"B\")) { ... } menggunakan dua resources mengimplementasikan AutoCloseable. Jika try block selesai normally, dalam urutan apa mereka ditutup?",
          "options": [
            {
              "icon": "",
              "label": "A ditutup first, kemudian B, matching declaration order"
            },
            {
              "icon": "",
              "label": "B ditutup first, kemudian A — try-with-resources menutup resources dalam reverse dari order mereka dideklarasikan"
            },
            {
              "icon": "",
              "label": "Keduanya ditutup simultaneously, karena try-with-resources parallelizes cleanup"
            },
            {
              "icon": "",
              "label": "Hanya B ditutup secara otomatis — A masih harus ditutup manually dalam finally block"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } Apa yang mengembalikan calling getValue()?",
          "options": [
            {
              "icon": "",
              "label": "1 — try block's return value sudah committed sebelum finally berjalan, jadi finally tidak dapat mengubahnya"
            },
            {
              "icon": "",
              "label": "Ini melempar exception pada runtime, karena method tidak dapat return dari dua places"
            },
            {
              "icon": "",
              "label": "2 — return statement di dalam finally override dan replace any return already in progress dari try block, membuang value 1 sepenuhnya"
            },
            {
              "icon": "",
              "label": "Compile error — finally tidak diizinkan untuk contain return statement"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, dan FileNotFoundException extends IOException. Apa yang terjadi ketika Anda coba compile ini?",
          "options": [
            {
              "icon": "",
              "label": "Compile error — FileNotFoundException catch block adalah unreachable karena earlier, more general IOException catch block sudah cocok setiap FileNotFoundException"
            },
            {
              "icon": "",
              "label": "Compile fine, dan more specific FileNotFoundException block berjalan kapan pun exact type itu dilempar"
            },
            {
              "icon": "",
              "label": "Compile fine, dan kedua catch blocks berjalan in order untuk FileNotFoundException"
            },
            {
              "icon": "",
              "label": "Fine pada compile time tetapi melempar runtime error kali pertama FileNotFoundException benar-benar terjadi"
            }
          ]
        },
        {
          "question": "Class memiliki synchronized instance method process() dan synchronized static method configure(). Apa, specifically, yang masing-masing lock?",
          "options": [
            {
              "icon": "",
              "label": "process() lock monitor dari specific object instance dipanggil pada, sementara configure() lock monitor dari Class object itu sendiri — di-share oleh setiap instance"
            },
            {
              "icon": "",
              "label": "Keduanya lock same single global lock untuk entire JVM, regardless dari instance atau class"
            },
            {
              "icon": "",
              "label": "process() lock Class object, dan configure() lock whichever instance yang happen memanggil itu"
            },
            {
              "icon": "",
              "label": "Tidak satupun benar-benar lock apa pun kecuali synchronized block juga digunakan di dalam method body"
            }
          ]
        },
        {
          "question": "Field dideklarasikan volatile int counter = 0;, dan multiple threads menjalankan counter++ pada itu concurrently. Apakah volatile mencegah lost updates di sini?",
          "options": [
            {
              "icon": "",
              "label": "Ya — volatile membuat setiap operation pada field atomic, termasuk increments"
            },
            {
              "icon": "",
              "label": "Tidak — volatile hanya menjamin bahwa reads melihat latest write di seluruh threads (visibility); counter++ adalah read-modify-write dengan multiple steps, dan volatile tidak melakukan apa pun untuk membuat steps itu atomic"
            },
            {
              "icon": "",
              "label": "Ya, tetapi hanya untuk int dan long fields khususnya, karena bagaimana JVM menangani 64-bit values"
            },
            {
              "icon": "",
              "label": "Tidak, dan volatile juga gagal untuk menjamin visibility untuk primitive types seperti int"
            }
          ]
        },
        {
          "question": "Interface A dan interface B masing-masing mendeklarasikan default method describe(). Class mengimplementasikan both A dan B dan tidak override describe() itu sendiri. Apa yang terjadi?",
          "options": [
            {
              "icon": "",
              "label": "Compiler memilih interface A's version secara otomatis, karena terdaftar first dalam implements clause"
            },
            {
              "icon": "",
              "label": "Kedua versions berjalan, satu setelah yang lain, kapan pun describe() dipanggil"
            },
            {
              "icon": "",
              "label": "Fine pada compile time, tetapi melempar AmbiguousMethodException kali pertama describe() dipanggil"
            },
            {
              "icon": "",
              "label": "Compile error — ketika dua interfaces berkontribusi same default method, implementing class harus override itu itu sendiri untuk resolve ambiguity, karena Java tidak akan guess mana satu yang Anda maksudkan"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); ditulis tetapi result tidak pernah di-assign ke terminal operation seperti .collect() atau .forEach(). Apa yang benar-benar terjadi ketika baris ini execute?",
          "options": [
            {
              "icon": "",
              "label": "Tidak ada yang terjadi pada list's elements sama sekali — filter dan map adalah lazy intermediate operations yang hanya build up pipeline description; tanpa terminal operation, tidak ada dari pipeline itu yang benar-benar berjalan"
            },
            {
              "icon": "",
              "label": "Setiap element di-filter dan di-map secara immediate, exactly seolah-olah terminal operation dipanggil"
            },
            {
              "icon": "",
              "label": "Hanya filter berjalan secara immediate; map di-defer sampai terminal operation muncul"
            },
            {
              "icon": "",
              "label": "Ini melempar IllegalStateException, karena stream pipeline memerlukan terminal operation agar compile"
            }
          ]
        }
      ],
      "optionOrderVersion": "0154f9576054ad6f"
    }
  }
}