{
  "assessmentTests": {
    "java_test": {
      "name": "Java Testi",
      "desc": "Core syntax/types, methods/overloading/scope, collections/generics/control flow ve exceptions/concurrency gibi 30 senaryo sorusu — Java becerilerinizin iş ilanında strong Java yeterliliğinin ne anlama geldiğini karşılayıp karşılamadığını öğrenin.",
      "recommendation": "Java becerilerinizin profili",
      "results": {
        "beginner": {
          "name": "Başlangıç",
          "desc": "Basit Java programlarını okuyabilir ve temel kontrol akışını takip edebilirsiniz, ancak kaçırdığınız sorular == ile . equals arasındaki fark, Integer autoboxing, nullable reference'lar ve inheritance'da gizli davranış etrafında kümelenir. Bunlar sözdizimi değil, Java'nın çalışma zamanı semantiğidir ve deneme yanılma yoluyla Java öğrenen insanları tam bu noktada tuzağa düşürür. İşte önemlidirler çünkü her biri kodun makul görünen ancak tamamen farklı şey yapıyor olduğu yerdir.",
          "recommendation": "Sırasıyla üç temel şeyle başlayın: == object identity'yi karşılaştırır (reference eşitliği) ancak . equals() value eşitliğini karşılaştırır; Integer -128 ile 127 arası otomatik olarak cache'lenir ve == çalışabilir ancak dışında başarısız olur; ve null bir type'ın geçerli bir değeridir, bu da her yerde kontrol gerektiriyor. Bu üçünü oynatılabilir örneklerle adım adım işletin — Effective Java'nın Item 10 ve 14'ü başlangıç için yeterli."
        },
        "intermediate": {
          "name": "Orta Seviye",
          "desc": "Method overloading, generics ve collections'ı rahatça kullanırsınız ve rutin kod taramaları tarafından yavaşlatılmazsınız. Buradan İleri Seviyeye kadar olan boşluk çoğunlukla type system davranışlarıdır: generic type erasure hangi bilgilerin runtime'da kaybolduğu, bir ArrayList<Integer>'ın aslında nasıl Integer.valueOf() cache'i ile etkileşime girdiği, bir catch bloğunun exception hierarchy'de tam nereyi yakalaması gerektiği. Bunlar hızlı bir gözle kontrol edilebilen ancak sadece çalıştırdığınızda fark edilebilen tür hatalarıdır.",
          "recommendation": "Her bir dil özelliğinin adını bilmekten ziyade, bir satırda hangi tiplerin oluştuğuna odaklanın: type erasure generic'leri compile-time'da nasıl gerçekleştiriyor, boxing ve unboxing birçok operasyonda sessizce neler yapıyor, ve neden bir exception handler'ını değiştirmek tüm kodu değiştiriyor. Sonra method resolution order ve varargs, bu bölünme zaten her ikisini de bilen insanları tuzağa düşürür."
        },
        "advanced": {
          "name": "İleri Seviye",
          "desc": "Bu, çoğu iş ilanının 'güçlü Java' ile kastedilen seviyedir. Bir code snippet'i okur ve çalıştırmadan çıktısını tahmin edebilirsiniz, kodun neden bu şekilde davrandığını sadece davrandığını değil bilirsiniz, ve bir problem için imperative loop yerine Stream API'sini veya functional style'ı kullanırsınız, temizlik vs performans dengesiyle birlikte. Bu bandı tepeden ayıran şey, işin savunma tarafıdır: volatile'ın visibility'de ne yaptığını bilmek, concurrency deadlock'ları ve memory leaks'leri, ve bir checked exception'ın declaration kontratı.",
          "recommendation": "Diğer insanların da çalışması gereken kodun güvenli parçalarına itilmek: finally ve try-with-resources blokları ne zaman garanti verir ve ne zaman bir exception'ı maskelemek riski vardır, synchronized ve volatile arasındaki fark, bir unchecked cast'ın neden type erasure'ın ardında sessizce başarısız olabileceği. Java Concurrency in Practice ve bir runtime monitor'unun JVM flags'leri sonraki durak olacaktır."
        },
        "expert": {
          "name": "Uzman",
          "desc": "Her bölümün tepesinde puanlandı — core syntax ve types, method resolution ve scope, collections framework ve generics semantiği, exceptions ve concurrency primitives'lar. Pratik olarak, bu, size bir unfamiliar Java codebase verilmesini ve neden bir satır ne yapacak olduğunu açıklayabileceğini anlamına gelir, bu daha zor ve daha değerli beceridir. Bu seviyede dil özelliklerinin kendileri nadiren sınırlayıcı faktördür; sınırı genellikle architecture kararları veya altında yatan memory model'dir.",
          "recommendation": "Getiriler artık profiling ve architecture'da olur: bir problemi JVM'nin gerçekte ne yaptığını bilinerek önce tanılayarak optimize etmek yerine, bir algoritma değiştirmek, concurrent data structure seçimi ve garbage collection tuning. Bir rol için taranıyorsanız, Java API'larını adlandırmak yerine üretimde bulduğunuz bir thread safety hatası veya object allocation frenzisi gibi bir runtime problemi açıklayın — bu mantığı gösterir, sadece syntax kelime türünü değil."
        }
      },
      "questions": [
        {
          "question": "Bu Java kodunu çalıştırırsınız: String s1 = \"hello\"; String s2 = \"hello\"; System.out.println(s1 == s2); Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "false — == reference eşitliğini kontrol eder ve iki farklı String nesnesidir"
            },
            {
              "icon": "",
              "label": "true — string literals string pool'da intern edilir, bu nedenle her ikisi de aynı nesneye işaret eder"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — == String'ler ile kullanılamaz"
            },
            {
              "icon": "",
              "label": "true — Java otomatik olarak == ile değer eşitliğini karşılaştırır"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); sonra Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); Bu iki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "true sonra true — autobox edilmiş Integer nesneleri değerden bağımsız olarak her zaman cache'lenir"
            },
            {
              "icon": "",
              "label": "false sonra false — Integer nesnelerinde == her zaman reference karşılaştırmasıdır, bu nedenle eşit değerler asla eşleşmez"
            },
            {
              "icon": "",
              "label": "true sonra false, ama sadece 200 bir byte'ı overflow ettiği için — cache sınırının -128..127 ile ilgisi yoktur"
            },
            {
              "icon": "",
              "label": "true sonra false — -128 ile 127 arasındaki autobox edilmiş Integer değerleri cache'lenir ve paylaşılır, bu nedenle 100 aynı nesneyi yeniden kullanır, ancak 200 cache dışında kalır ve iki ayrı nesneye autobox edilir"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "Integer overflow için ArithmeticException throw eder"
            },
            {
              "icon": "",
              "label": "Integer.MAX_VALUE'yi tekrar yazdırır, çünkü Java type'ın maksimumunda clamp eder"
            },
            {
              "icon": "",
              "label": "Integer.MIN_VALUE yazdırır — int aritmetiği overflow'da throw etmek yerine sessizce wrap around eder"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — compiler overflow'u önceden tespit eder"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); Bu ne yazdırır ve neden?",
          "options": [
            {
              "icon": "",
              "label": "false — 0.1, 0.2 ve 0.3 ikili floating point'te tam olarak temsil edilemez, bu nedenle toplam bit-bit 0.3'e eşit olmayan bir rounding hatası taşır"
            },
            {
              "icon": "",
              "label": "true — Java karşılaştırmadan önce double aritmetiğini en yakın temsil edilebilir ondalığa yuvarlar"
            },
            {
              "icon": "",
              "label": "true — iki ondalık basamaklı değerler için iki double'ın toplamı her zaman exact'tır"
            },
            {
              "icon": "",
              "label": "Exception throw eder, çünkü Java'da double için == tanımlı değildir"
            }
          ]
        },
        {
          "question": "Bir class, initializer olmadan iki instance field declare eder: int count; ve Integer total; Constructor çalışmadan önce bunların default değerleri nedir?",
          "options": [
            {
              "icon": "",
              "label": "İkisi de 0'a default eder, çünkü Integer field initialization'da int'e autobox edilir"
            },
            {
              "icon": "",
              "label": "count 0'dır ve total 0'dır, ilk okunduğunda otomatik olarak box edilir"
            },
            {
              "icon": "",
              "label": "count 0'dır ve total null'dır — primitive numeric field'lar sıfıra default eder, ancak initialize edilmemiş bir wrapper reference field, diğer her object reference gibi null'a default eder"
            },
            {
              "icon": "",
              "label": "İkisi de explicitly assign edilene kadar null'a default eder, çünkü Java'da implicit numeric default yoktur"
            }
          ]
        },
        {
          "question": "Bir loop 1000 kez çalışır, her seferinde bir String result üzerinde result += \"x\"; yapar. Her iterasyonda perde arkasında gerçekte ne olur?",
          "options": [
            {
              "icon": "",
              "label": "Mevcut String nesnesinin internal character array'i yerinde extend edilir"
            },
            {
              "icon": "",
              "label": "Java concatenation'ları otomatik olarak batch eder ve sadece bir final String nesnesi allocate eder"
            },
            {
              "icon": "",
              "label": "1000 iterasyonun tamamında paylaşılan tek bir StringBuilder.append() call'ına derlenir, iterasyon başına extra nesne allocate edilmez"
            },
            {
              "icon": "",
              "label": "Yepyeni bir String nesnesi oluşturulur ve result ona işaret edecek şekilde yeniden assign edilir — önceki String nesnesi discard edilir, çünkü String immutable'dır ve += onu yerinde modify edemez"
            }
          ]
        },
        {
          "question": "İki array'i çalıştırırsınız: int[] a = new int[5]; int[] b = new int[5]; System.out.println(a == b);",
          "options": [
            {
              "icon": "",
              "label": "true — aynı boyuttur"
            },
            {
              "icon": "",
              "label": "true — aynı değerleri içerir (hepsi 0)"
            },
            {
              "icon": "",
              "label": "false — == reference eşitliğini kontrol eder ve a ile b iki farklı nesnedir"
            },
            {
              "icon": "",
              "label": "Compile-time hatası"
            }
          ]
        },
        {
          "question": "Bu inheritance'i çalıştırırsınız: class A { void test() { System.out.println(\"A\"); } } class B extends A { void test() { System.out.println(\"B\"); } } A obj = new B(); obj.test(); Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "\"A\" — obj declare type'ı A'dır"
            },
            {
              "icon": "",
              "label": "\"B\" — B override eder ve actual object B'dir, bu nedenle B'nin version çalıştırılır"
            },
            {
              "icon": "",
              "label": "\"A\" sonra \"B\" — her iki version de çalıştırılır"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — A obj B assign edemezsiniz"
            }
          ]
        },
        {
          "question": "HashMap ve null key'ler. Bu koduda ne olur: HashMap<String, Integer> map = new HashMap<>(); map.put(null, 5); System.out.println(map.get(null));",
          "options": [
            {
              "icon": "",
              "label": "NullPointerException — HashMap null key'leri desteklemez"
            },
            {
              "icon": "",
              "label": "null — null key'ler hashCode() call edemez"
            },
            {
              "icon": "",
              "label": "5 — HashMap null key'i izin verir, özel bir şekilde handled"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — String'e null assign edemezsiniz"
            }
          ]
        },
        {
          "question": "Method overloading resolution. İki method var: void test(Integer x) ve void test(int x). Bu'yi çağırırsınız: test(5); Hangisi çalıştırılır?",
          "options": [
            {
              "icon": "",
              "label": "Integer version — primitive otomatik olarak wrapper'a convert edilir"
            },
            {
              "icon": "",
              "label": "int version — primitive prefer edilir, autoboxing only needed ise"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — ambiguous"
            },
            {
              "icon": "",
              "label": "Her ikisi de çalıştırılır, bir sahte yöntem call'ı oluşturur"
            }
          ]
        },
        {
          "question": "Generic type erasure. Bu LinkedList'i çalıştırırsınız: LinkedList<String> list = new LinkedList<>(); list.add(\"hello\"); Object o = list.get(0); String s = o.toString(); Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "ClassCastException — o bir String değil Object'tir"
            },
            {
              "icon": "",
              "label": "\"hello\" — o runtime'da aslında bir String nesnesidir"
            },
            {
              "icon": "",
              "label": "null — generic type'lar runtime'da kaybolur"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — type mismatch"
            }
          ]
        },
        {
          "question": "Exception hierarchy. Bu try-catch'i çalıştırırsınız: try { Integer.parseInt(\"hello\"); } catch (Exception e) { System.out.println(\"caught\"); }. Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "İstisnai olarak yazdırılır — NumberFormatException checked exception'dır"
            },
            {
              "icon": "",
              "label": "Hiçbir şey — NumberFormatException unchecked ve Exception bunu capture etmez"
            },
            {
              "icon": "",
              "label": "\"caught\" — NumberFormatException Exception'in subclass'ıdır"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — Exception'ı catch edemezsiniz"
            }
          ]
        },
        {
          "question": "Checked vs unchecked exceptions. Method'un throw'u var: throws IOException, bu null döndürür. Birisi bunu çağırır: test(); Derlenmiş mi?",
          "options": [
            {
              "icon": "",
              "label": "Evet — IOException'ı handle etmek optional'dır"
            },
            {
              "icon": "",
              "label": "Hayır — caller throw'u handle etmelidir, try-catch veya throws"
            },
            {
              "icon": "",
              "label": "Evet — method null döndürdüğü için exception throw edemez"
            },
            {
              "icon": "",
              "label": "Hayır — Throwable'un subclass'ı hiçbir zaman caller'a throw edilmez"
            }
          ]
        },
        {
          "question": "Primitive vs reference. Bu koduda, x'i neden değiştirir: public void test(int x) { x = 10; }. Call'da primitive'in değişmez mi?",
          "options": [
            {
              "icon": "",
              "label": "Değişmez — x method'un copy'sidir, original'e değişiklik yok"
            },
            {
              "icon": "",
              "label": "Değişir — method parameter'lar pass-by-reference'dir"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — primitive'leri method'da değiştiremezsiniz"
            },
            {
              "icon": "",
              "label": "Depends on JVM — JVM'nin version'una göre değişir"
            }
          ]
        },
        {
          "question": "Final modifier. Bir final variable'ı assign edebilir misiniz: final int x; System.out.println(x); çalıştırırsınız, çöker mi?",
          "options": [
            {
              "icon": "",
              "label": "Evet, x initi verilmemiş, bu nedenle x yazdırılamaz"
            },
            {
              "icon": "",
              "label": "Hayır — final değişkenler automatically 0'a initi edilir"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — uninitialized variable'ı kullanmak izin verilmez"
            },
            {
              "icon": "",
              "label": "NullPointerException — final null olabilir"
            }
          ]
        },
        {
          "question": "Static initialization. Bu class'ı çalıştırırsınız: class Test { static int x = 5; static { x = 10; } public static void main(String[] args) { System.out.println(x); } }. Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "5 — static initializer block çalıştırılmaz"
            },
            {
              "icon": "",
              "label": "10 — static block x = 5 kuvveti verir x = 10"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — static block ikinci kez initi edemez"
            },
            {
              "icon": "",
              "label": "null — static variable başlatılmadı"
            }
          ]
        },
        {
          "question": "String immutability. Bu koduda: String s = \"hello\"; s.concat(\" world\"); System.out.println(s);. Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "\"hello world\" — concat() s'yi mutate eder"
            },
            {
              "icon": "",
              "label": "\"hello\" — concat() yeni String döndürür, bunu assign etmediğiniz"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — immutable String'leri change edemezsiniz"
            },
            {
              "icon": "",
              "label": "null — concat() başarısız oldu"
            }
          ]
        },
        {
          "question": "Variable shadowing. İç scope'ta variable'ı redeclare edebilir misiniz: { int x = 5; { int x = 10; System.out.println(x); } }. Çıktı ne olur?",
          "options": [
            {
              "icon": "",
              "label": "10 — inner x outer x shadow eder"
            },
            {
              "icon": "",
              "label": "5 — outer x kullanılır"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — duplicate variable declaration"
            },
            {
              "icon": "",
              "label": "null — shadowing tanımsız behavior oluşturur"
            }
          ]
        },
        {
          "question": "This keyword. Bir method'da this.x ve x arasındaki fark nedir: public void test() { int x = 5; System.out.println(x); }",
          "options": [
            {
              "icon": "",
              "label": "this.x field'dir, x local variable'dır"
            },
            {
              "icon": "",
              "label": "Fark yok — her ikisi de aynı variable'ı referans alır"
            },
            {
              "icon": "",
              "label": "this.x nesnesidir, x primitive'dir"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — bir method'da this kullanamazsınız"
            }
          ]
        },
        {
          "question": "Super keyword. Child'de super() çağırırsınız: class Parent { Parent(int x) {} } class Child extends Parent { Child() { super(5); } }. Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "Compile-time hatası — super() Parent constructor'ı çağıramaz"
            },
            {
              "icon": "",
              "label": "Parent constructor'ı çalıştırılır argument 5 ile"
            },
            {
              "icon": "",
              "label": "Child constructor'ı kopyalı olarak çalıştırılır"
            },
            {
              "icon": "",
              "label": "Hiçbir şey — super() optional'dır"
            }
          ]
        },
        {
          "question": "Enhanced for loop ve iterator. Bu loop'ta: for (String s : list) { list.remove(s); }. Neden ConcurrentModificationException throw edilebilir?",
          "options": [
            {
              "icon": "",
              "label": "Çünkü enhanced for loop bir Iterator kullanır ve Collection'ı loop sırasında değiştirmek iterator'ı invalidate eder"
            },
            {
              "icon": "",
              "label": "Çünkü for loop synchronize edilmemiş"
            },
            {
              "icon": "",
              "label": "Çünkü list null olabilir"
            },
            {
              "icon": "",
              "label": "Exception throw edilmez, s sadece güncellenir"
            }
          ]
        },
        {
          "question": "Autoboxing boxing conversions. ArrayList<Integer> ve primitive int. Bu koduda: ArrayList<Integer> list = new ArrayList<>(); list.add(5); int x = list.get(0);. Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "Compile-time hatası — Integer'ı int'e assign edemezsiniz"
            },
            {
              "icon": "",
              "label": "5 — Integer otomatik unbox edilir int'e"
            },
            {
              "icon": "",
              "label": "null — Integer null olabilir ve auto-unboxing NullPointerException throw eder"
            },
            {
              "icon": "",
              "label": "Hiçbir şey derlenmiyor"
            }
          ]
        },
        {
          "question": "Generics wildcards. ArrayList<? extends Number> parametre accept eden method. Buna add() çalıştırabilir misiniz: list.add(new Integer(5));",
          "options": [
            {
              "icon": "",
              "label": "Evet — Integer Number'ın subclass'ıdır"
            },
            {
              "icon": "",
              "label": "Hayır — ? extends Number'dan, ne exact type olduğu bilinmiyor, bu nedenle ekleyemezsiniz"
            },
            {
              "icon": "",
              "label": "Evet, ancak yalnızca Number'ın direct subclass'ına"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — wildcard'lar method parameter'larda illegal"
            }
          ]
        },
        {
          "question": "Raw types. Eski code: List list = new ArrayList<>(); list.add(\"hello\"); list.add(5); String s = (String) list.get(0);. Ne olur?",
          "options": [
            {
              "icon": "",
              "label": "\"hello\" — cast derlenmiş ve çalıştırılmış"
            },
            {
              "icon": "",
              "label": "Compile warning ancak aynı çalıştırılır"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — raw types illegal"
            },
            {
              "icon": "",
              "label": "ClassCastException — \"hello\" cast'a başarısız olur"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } getValue()'yi çağırmak ne döndürür?",
          "options": [
            {
              "icon": "",
              "label": "1 — try bloğunun return değeri finally çalışmadan önce zaten commit edilmiştir, bu nedenle finally onu değiştiremez"
            },
            {
              "icon": "",
              "label": "Runtime'da exception throw eder, çünkü bir method iki yerden return edemez"
            },
            {
              "icon": "",
              "label": "2 — finally içindeki bir return statement, try bloğundan zaten devam eden herhangi bir return'ü override edip yerine geçer, 1 değerini tamamen discard eder"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — finally'nin bir return statement içermesine izin verilmez"
            }
          ]
        },
        {
          "question": "Synchronized method. İki thread aynı synchronized method'a aynı anda girerse ne olur: public synchronized void test() { }",
          "options": [
            {
              "icon": "",
              "label": "Hiçbir şey — ikisi de aynı anda çalıştırılır"
            },
            {
              "icon": "",
              "label": "Biri lock alır ve diğeri wait eder — mutual exclusion"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — synchronized method legal değil"
            },
            {
              "icon": "",
              "label": "Her thread'in kendi copy'si sahip olur — no contention"
            }
          ]
        },
        {
          "question": "Stream API laziness. Bu Stream code'u: Stream.of(1,2,3) .map(x -> { System.out.println(x); return x * 2; }) .forEach(System.out::println);. Output ne olur?",
          "options": [
            {
              "icon": "",
              "label": "Hiçbir şey — Stream'ler lazy, terminal operation olmadıkça çalıştırılmaz"
            },
            {
              "icon": "",
              "label": "1,2,3 (map output) sonra 2,4,6 (forEach output) — eager evaluation"
            },
            {
              "icon": "",
              "label": "2,4,6 — sadece forEach çalıştırılır"
            },
            {
              "icon": "",
              "label": "1,2,1,3,2,4,3,6 — interleaved output"
            }
          ]
        },
        {
          "question": "Bir field volatile int counter = 0; olarak declare edilir ve birden fazla thread onun üzerinde concurrent olarak counter++ çalıştırır. volatile burada lost update'leri önler mi?",
          "options": [
            {
              "icon": "",
              "label": "Evet — volatile, increment'ler dahil field üzerindeki her operation'ı atomic yapar"
            },
            {
              "icon": "",
              "label": "Hayır — volatile sadece read'lerin thread'ler arasında en son write'ı görmesini garanti eder (visibility); counter++ birden fazla adımlı bir read-modify-write'tır ve volatile bu adımları atomic yapmak için hiçbir şey yapmaz"
            },
            {
              "icon": "",
              "label": "Evet, ancak JVM'nin 64-bit değerleri nasıl handle ettiği nedeniyle sadece int ve long field'lar için"
            },
            {
              "icon": "",
              "label": "Hayır, ve volatile ayrıca int gibi primitive type'lar için visibility garanti etmekte de başarısız olur"
            }
          ]
        },
        {
          "question": "Try-with-resources statement. Bir AutoCloseable resource'u: try (BufferedReader reader = new BufferedReader(...)) { String line = reader.readLine(); } reader.close() çalıştırılır?",
          "options": [
            {
              "icon": "",
              "label": "Hayır — try-with-resources resource'u automatically close eder"
            },
            {
              "icon": "",
              "label": "Evet — try block'ından sonra explicitly çalıştırılmalı"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — try-with-resources'da explicit close illegal"
            },
            {
              "icon": "",
              "label": "Bağlı olarak resource'un type'ına"
            }
          ]
        },
        {
          "question": "Reflection vs compile-time checking. Reflection'da bir method'u call edersem: Method method = Class.forName(\"SomeClass\").getMethod(\"test\");. Çalışırken runtime hatası meydana gelebilir mi, compile-time'da bile detected olmadan?",
          "options": [
            {
              "icon": "",
              "label": "Hayır — tüm hatalar compile-time'da caught"
            },
            {
              "icon": "",
              "label": "Evet — NoSuchMethodException, ClassNotFoundException ve diğer runtime exceptions possible"
            },
            {
              "icon": "",
              "label": "Sadece ClassNotFoundException"
            },
            {
              "icon": "",
              "label": "Compile-time hatası — reflection illegal"
            }
          ]
        }
      ],
      "optionOrderVersion": "0154f9576054ad6f"
    }
  }
}