{
  "assessmentTests": {
    "java_test": {
      "name": "Java चाचणी",
      "desc": "मूलभूत सिंटॅक्स, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगची कार्यपद्धती, कलेक्शन्स, जेनेरिक्स, एक्सेप्शन्स आणि कॉन्करन्सी यावरील 30 परिस्थितीवर आधारित प्रश्न — नोकरीच्या जाहिरातीत Java प्रावीण्य म्हणजे जे अपेक्षित असते, ते तुमच्या Java ज्ञानात आहे का हे जाणून घ्या.",
      "recommendation": "तुमचे Java कौशल्य प्रोफाइल",
      "results": {
        "beginner": {
          "name": "नवशिके",
          "desc": "तुम्ही चालणारे क्लासेस आणि मेथड्स लिहू शकता, पण तुमचे चुकलेले प्रश्न सिंटॅक्सपेक्षा आयडेंटिटी आणि डिफॉल्ट्स यांच्याभोवती केंद्रित आहेत — String == विरुद्ध .equals, new String(\"x\") स्ट्रिंग पूल कधीच का वापरत नाही, आणि संख्यात्मक फील्डची डिफॉल्ट किंमत रॅपर फील्डच्या तुलनेत काय असते. यापैकी कशाचाही अर्थ तुम्हाला Java चांगले येत नाही असा नाही; हे असे विशिष्ट नियम आहेत जे रेफरन्स आणि प्रिमिटिव्ह्ज आतून प्रत्यक्षात कसे काम करतात हे समजून घेण्याऐवजी प्रयोग-चुकांतून भाषा शिकलेल्या लोकांना अडखळवतात. कामावर ते महत्त्वाचे ठरतात, कारण प्रत्येक ठिकाणी कोड कंपाइल होतो, चालतो आणि शांतपणे चुकीचे काम करतो.",
          "recommendation": "या क्रमाने तीन गोष्टींपासून सुरुवात करा: दोन String ऑब्जेक्ट्सवर == अक्षरांची नव्हे तर रेफरन्सेसची तुलना का करते (आणि तुम्हाला जवळजवळ नेहमी .equals हवे असते), int ओव्हरफ्लोमध्ये मूल्य एक्सेप्शन फेकण्याऐवजी शांतपणे दुसऱ्या टोकाला कसे जाते, आणि प्रारंभिक मूल्य न दिलेल्या Integer फील्डची डिफॉल्ट किंमत null आणि int फील्डची 0 का असते. Oracle ची अधिकृत Java ट्यूटोरियल्स आणि Baeldung या दोन्हींमध्ये तिन्ही मुद्दे चालवून पाहता येणाऱ्या उदाहरणांसह दिले आहेत."
        },
        "intermediate": {
          "name": "मध्यम",
          "desc": "तुम्ही रोजच्या अॅप्लिकेशन कोडमध्ये सहजतेने काम करता — क्लासेस, कलेक्शन्स, सरळ कंट्रोल फ्लो — आणि नेहमीच्या फीचरच्या कामात तुमचा वेग मंदावणार नाही. येथून प्रगत पातळीपर्यंतचे अंतर मुख्यतः Java चे नियम कॉन्करन्सी आणि जेनेरिक्सशी जेव्हा भिडतात तेव्हा काय होते यात आहे: तुम्हाला अपेक्षित असलेल्या ऑब्जेक्टऐवजी घोषित प्रकारानुसार निवडली जाणारी स्टॅटिक मेथड, तुम्ही नकळत अवलंबून राहिलेला HashMap चा इटरेशन क्रम, लूपच्या मध्यभागी एखादा आयटम काढल्यामुळे येणारा ConcurrentModificationException. असे बग झटपट वाचून पाहताना सुटतात आणि फक्त विशिष्ट रनटाइम परिस्थितीतच दिसतात.",
          "recommendation": "कंपायलरला तुमचा कोड कसा दिसतो (स्टॅटिक दृष्टिकोन) आणि प्रत्यक्षात काय चालते यातील फरकावर लक्ष केंद्रित करा: रनटाइम प्रकारऐवजी घोषित प्रकारानुसार होणारे ओव्हरलोड रिझोल्यूशन आणि स्टॅटिक-मेथड हायडिंग, HashMap इटरेशन क्रमाची हमी का देत नाही, आणि इटरेट करताना लिस्टमध्ये थेट बदल केल्यास ConcurrentModificationException का येते. त्यानंतर जेनेरिक्स इरेजर, कारण कलेक्शन्स वेगवेगळी माहीत असलेल्या लोकांनाही त्याने अडखळायला होते."
        },
        "advanced": {
          "name": "प्रगत",
          "desc": "बहुतेक नोकरीच्या जाहिरातींना \"उत्तम Java\" म्हणजे हीच पातळी अभिप्रेत असते. तुम्ही स्टॅटिक ब्लॉक्स, इन्स्टन्स ब्लॉक्स आणि अनेक कन्स्ट्रक्टर्स असलेला क्लास वाचून ते कोणत्या नेमक्या क्रमाने चालतील हे सांगू शकता, finally ब्लॉक try ब्लॉकचे रिटर्न व्हॅल्यू शांतपणे का टाकून देऊ शकतो हे तुम्हाला माहीत आहे, आणि तुम्ही मॅन्युअल finally-close ऐवजी try-with-resources वापरता कारण ते देत असलेली क्रमाची हमी तुम्हाला माहीत असते. ही पातळी आणि सर्वोच्च पातळी यांना वेगळे करणारी गोष्ट म्हणजे कामाची कॉन्करंट आणि इंटरफेस-स्तरावरील बाजू: synchronized प्रत्यक्षात कशाला लॉक करते, volatile कशाची हमी देते आणि कशाची देत नाही, आणि डिफॉल्ट-मेथडमधील संघर्ष कसे सोडवले जातात.",
          "recommendation": "अशा भागांमध्ये खोलवर जा जे इतर थ्रेड्स आणि इतर इंटरफेस ज्या कोडला स्पर्श करतात त्याचे संरक्षण करतात: synchronized इन्स्टन्स मेथड आणि synchronized स्टॅटिक मेथड कशाला लॉक करतात यातील फरक, counter++ साठी volatile दृश्यमानता देते पण अॅटॉमिसिटी का देत नाही, आणि Java तुम्हाला डिफॉल्ट-मेथड डायमंडचा संघर्ष हाताने कसा सोडवायला लावते. या दोन्हींसाठी Baeldung आणि Java Concurrency in Practice मधील Java Memory Model वरील साहित्य हा पुढचा नैसर्गिक टप्पा आहे."
        },
        "expert": {
          "name": "तज्ज्ञ",
          "desc": "तुम्ही प्रत्येक विभागात सर्वोच्च गुण मिळवले — मूलभूत सिंटॅक्स आणि प्रकार, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगची कार्यपद्धती आणि स्कोप, कलेक्शन्स आणि जेनेरिक्स, तसेच एक्सेप्शन्स, कॉन्करन्सी आणि आयडिअम्स. व्यावहारिकदृष्ट्या याचा अर्थ असा की, तुमच्या हातात एखाद्या अनोळखी व्यक्तीचा क्लास दिला, तर तुम्ही कंपाइल एरर, रनटाइम एक्सेप्शन किंवा शांतपणे चुकीचे मूल्य का येते हे समजावून सांगू शकता, फक्त सिंटॅक्सनुसार काय व्हायला हवे ते नाही, आणि हे अधिक कठीण आणि अधिक मौल्यवान कौशल्य आहे. या पातळीवर भाषा स्वतः क्वचितच मर्यादा ठरते; मर्यादा सहसा कॉन्करन्सी डिझाइन किंवा त्याखालील डेटाच्या रचनेची असते.",
          "recommendation": "आता फायदा डिझाइन आणि निदानात आहे: हँग म्हणजे डेडलॉक असे गृहीत धरण्यापूर्वी थ्रेड डंप वाचणे, synchronized, java.util.concurrent लॉक्स आणि अॅटॉमिक्स यांच्यातील निवड डिफॉल्ट म्हणून नव्हे तर तडजोड म्हणून करणे, आणि अपघाताने नव्हे तर हेतुपुरस्सर लेझी राहणारे स्ट्रीम-पाइपलाइन डिझाइन. एखाद्या भूमिकेसाठी तुमची चाचपणी होत असेल, तर Java फीचर्सची नावे सांगण्याऐवजी तुम्हाला प्रोडक्शनमध्ये आढळलेल्या एखाद्या कॉन्करन्सी बगचे वर्णन करा, जसे की सुटलेला happens-before edge किंवा ConcurrentModificationException — यातून केवळ शब्दसंग्रह नव्हे, तर तुमची विचारपद्धती दिसते."
        }
      },
      "questions": [
        {
          "question": "तुम्ही दोन String ऑब्जेक्ट्स तयार करता: String a = new String(\"cat\"); String b = new String(\"cat\"); a == b चे मूल्यमापन काय येते?",
          "options": [
            {
              "icon": "",
              "label": "true"
            },
            {
              "icon": "",
              "label": "हे JVM च्या स्ट्रिंग-पूल सेटिंगवर अवलंबून असते"
            },
            {
              "icon": "",
              "label": "कंपाइल एरर"
            },
            {
              "icon": "",
              "label": "false"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); त्यानंतर Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); या दोन ओळी काय प्रिंट करतात?",
          "options": [
            {
              "icon": "",
              "label": "true, नंतर true"
            },
            {
              "icon": "",
              "label": "false, नंतर false"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होत नाही"
            },
            {
              "icon": "",
              "label": "true, नंतर false"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); काय होते?",
          "options": [
            {
              "icon": "",
              "label": "ते ArithmeticException फेकते"
            },
            {
              "icon": "",
              "label": "ते पुन्हा Integer.MAX_VALUE प्रिंट करते"
            },
            {
              "icon": "",
              "label": "ते Integer.MIN_VALUE प्रिंट करते"
            },
            {
              "icon": "",
              "label": "कंपाइल एरर"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); हे काय प्रिंट करते आणि का?",
          "options": [
            {
              "icon": "",
              "label": "false, कारण 0.1 आणि 0.2 बायनरी फ्लोटिंग पॉइंटमध्ये अचूक नसतात"
            },
            {
              "icon": "",
              "label": "true, कारण Java double बेरजा जवळच्या दशांश संख्येपर्यंत पूर्णांकित करते"
            },
            {
              "icon": "",
              "label": "true, कारण दोन दशांश स्थानांची मूल्ये double मध्ये अचूक बेरीज होतात"
            },
            {
              "icon": "",
              "label": "अचूक नसलेल्या तुलनेसाठी ते ArithmeticException फेकते"
            }
          ]
        },
        {
          "question": "एक क्लास दोन इन्स्टन्स फील्ड्स इनिशिअलायझरशिवाय घोषित करतो: int count; आणि Integer total; कन्स्ट्रक्टर चालण्यापूर्वी त्यांची डिफॉल्ट मूल्ये काय असतात?",
          "options": [
            {
              "icon": "",
              "label": "दोन्ही 0 असतात"
            },
            {
              "icon": "",
              "label": "मूल्य दिले जाईपर्यंत दोघांनाही मूल्य नसते"
            },
            {
              "icon": "",
              "label": "count 0 असते आणि total null असते"
            },
            {
              "icon": "",
              "label": "दोन्ही null असतात"
            }
          ]
        },
        {
          "question": "एक लूप 1000 वेळा चालतो आणि प्रत्येक वेळी String असलेल्या result वर result += \"x\"; करतो. प्रत्येक इटरेशनमध्ये आतून प्रत्यक्षात काय होते?",
          "options": [
            {
              "icon": "",
              "label": "अस्तित्वात असलेल्या String चा कॅरेक्टर अॅरे जागेवरच वाढवला जातो"
            },
            {
              "icon": "",
              "label": "Java सर्व जोडण्या एकत्र करून एकच अंतिम String बनवते"
            },
            {
              "icon": "",
              "label": "सर्व 1000 इटरेशन्समध्ये एकच StringBuilder सामायिक केला जातो"
            },
            {
              "icon": "",
              "label": "एक नवीन String तयार केला जातो आणि result ला दिला जातो"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); यापैकी कोणते विधान खरे आहे?",
          "options": [
            {
              "icon": "",
              "label": "names.add(\"Ana\") कंपाइल होते आणि चालते"
            },
            {
              "icon": "",
              "label": "names.add(\"Ana\") कंपाइल होत नाही"
            },
            {
              "icon": "",
              "label": "ही लिस्ट एकाच वेळी अनेक थ्रेड्सनी लिहिण्यासाठी सुरक्षित आहे"
            },
            {
              "icon": "",
              "label": "final चा लोकल व्हेरिएबलवर काहीही परिणाम होत नाही"
            }
          ]
        },
        {
          "question": "int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a == b); System.out.println(Arrays.equals(a, b)); या दोन ओळी काय प्रिंट करतात?",
          "options": [
            {
              "icon": "",
              "label": "false, नंतर true"
            },
            {
              "icon": "",
              "label": "true, नंतर true"
            },
            {
              "icon": "",
              "label": "false, नंतर false"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होत नाही"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(\"Object\"); } void show(String s) { print(\"String\"); } Object ref = \"hello\"; show(ref); कोणता ओव्हरलोड चालतो आणि का?",
          "options": [
            {
              "icon": "",
              "label": "show(String), कारण ऑब्जेक्टचा रनटाइम क्लास String आहे"
            },
            {
              "icon": "",
              "label": "show(Object), कारण ओव्हरलोड्स घोषित प्रकारावरून निवडले जातात"
            },
            {
              "icon": "",
              "label": "एकही नाही; कॉल संदिग्ध आहे आणि कंपाइल होत नाही"
            },
            {
              "icon": "",
              "label": "दोन्ही प्रत्येकी एकदा चालतात, कारण प्रत्येक ओव्हरलोड जुळतो"
            }
          ]
        },
        {
          "question": "Base क्लासमध्ये static void greet() { print(\"Base\"); } आहे. Derived क्लास Base ला एक्स्टेंड करतो आणि तोही static void greet() { print(\"Derived\"); } घोषित करतो. तुम्ही लिहिता: Base ref = new Derived(); ref.greet(); काय प्रिंट होते?",
          "options": [
            {
              "icon": "",
              "label": "Derived"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होत नाही"
            },
            {
              "icon": "",
              "label": "मूळ"
            },
            {
              "icon": "",
              "label": "Base, नंतर Derived"
            }
          ]
        },
        {
          "question": "एका मेथडमध्ये तुम्ही int count = 0; लिहिता, मग दुसऱ्या मेथडला दिलेल्या लॅम्ब्डाच्या आतून count चा संदर्भ घेण्याचा प्रयत्न करता. हे कंपाइल होण्यासाठी count बद्दल काय खरे असले पाहिजे?",
          "options": [
            {
              "icon": "",
              "label": "ते final किंवा प्रभावीपणे final असले पाहिजे"
            },
            {
              "icon": "",
              "label": "काहीही नाही; कोणतेही लोकल व्हेरिएबल चालते"
            },
            {
              "icon": "",
              "label": "ते volatile घोषित केलेले असले पाहिजे"
            },
            {
              "icon": "",
              "label": "ते फील्ड असले पाहिजे, लोकल व्हेरिएबल नाही"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(\"new\"); } ही मेथड StringBuilder original = new StringBuilder(\"old\"); rename(original); अशी बोलावली जाते. कॉलनंतर original काय असते?",
          "options": [
            {
              "icon": "",
              "label": "ते \"new\" असते"
            },
            {
              "icon": "",
              "label": "ते null असते"
            },
            {
              "icon": "",
              "label": "ते अजूनही \"old\" असते"
            },
            {
              "icon": "",
              "label": "रनटाइम एक्सेप्शन फेकले जाते"
            }
          ]
        },
        {
          "question": "एका क्लासमध्ये स्टॅटिक इनिशिअलायझर ब्लॉक, इन्स्टन्स इनिशिअलायझर ब्लॉक आणि कन्स्ट्रक्टर आहे, याच सोर्स क्रमाने. तुम्ही या क्लासचे दोन ऑब्जेक्ट्स एकापाठोपाठ एक तयार करता. हे कोणत्या क्रमाने चालतात?",
          "options": [
            {
              "icon": "",
              "label": "स्टॅटिक ब्लॉक एकदा; त्यानंतर प्रत्येक ऑब्जेक्टसाठी इन्स्टन्स ब्लॉक, मग कन्स्ट्रक्टर"
            },
            {
              "icon": "",
              "label": "तिन्ही प्रत्येक ऑब्जेक्टसाठी सोर्स क्रमाने चालतात"
            },
            {
              "icon": "",
              "label": "प्रत्येक ऑब्जेक्टसाठी कन्स्ट्रक्टर, मग इन्स्टन्स ब्लॉक; स्टॅटिक ब्लॉक शेवटी एकदा"
            },
            {
              "icon": "",
              "label": "प्रत्येक ऑब्जेक्टसाठी स्टॅटिक ब्लॉक एकदा, मग इन्स्टन्स ब्लॉक, मग कन्स्ट्रक्टर"
            }
          ]
        },
        {
          "question": "एका क्लासमध्ये void log(String s) आणि void log(String... args) आहेत. तुम्ही log(\"hi\") बोलावता. कोणती चालते?",
          "options": [
            {
              "icon": "",
              "label": "log(String... args)"
            },
            {
              "icon": "",
              "label": "कंपाइल एरर: कॉल संदिग्ध आहे"
            },
            {
              "icon": "",
              "label": "log(String s)"
            },
            {
              "icon": "",
              "label": "जो ओव्हरलोड आधी घोषित केलेला असेल तो"
            }
          ]
        },
        {
          "question": "एका कन्स्ट्रक्टरची पहिली ओळ याच क्लासमधील दुसऱ्या कन्स्ट्रक्टरकडे काम सोपवण्यासाठी this(0); बोलावते. हे कुठे येण्याची परवानगी आहे?",
          "options": [
            {
              "icon": "",
              "label": "कन्स्ट्रक्टर परत येण्यापूर्वी, बॉडीमध्ये कुठेही"
            },
            {
              "icon": "",
              "label": "फक्त कन्स्ट्रक्टरचे पहिले स्टेटमेंट म्हणून"
            },
            {
              "icon": "",
              "label": "फक्त कन्स्ट्रक्टरचे शेवटचे स्टेटमेंट म्हणून"
            },
            {
              "icon": "",
              "label": "फक्त delegate कीवर्ड असलेल्या कन्स्ट्रक्टरमध्ये"
            }
          ]
        },
        {
          "question": "तुम्हाला अशी लिस्ट हवी आहे ज्यात सुरुवातीला घटक अतिशय वारंवार घातले जातील आणि रँडम-अॅक्सेस रीड्स क्वचित असतील. रचनेच्या दृष्टीने कोणता पर्याय अधिक योग्य आहे आणि का?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList, कारण त्याच्या मागील अॅरेमुळे सुरुवातीला घालणे सर्वात वेगवान होते"
            },
            {
              "icon": "",
              "label": "दोन्हींपैकी कोणतीही, कारण दोन्ही List समान हमींसह अंमलात आणतात"
            },
            {
              "icon": "",
              "label": "LinkedList, कारण सुरुवातीला घालणे O(n) ऐवजी O(1) असते"
            },
            {
              "icon": "",
              "label": "LinkedList, कारण ते O(1) रँडम अॅक्सेस देते"
            }
          ]
        },
        {
          "question": "तुम्ही एका साध्या HashMap मध्ये पाच एंट्री विशिष्ट क्रमाने घालता, मग for-each लूपने त्यावर इटरेट करता. एंट्री कोणत्या क्रमाने बाहेर येतात?",
          "options": [
            {
              "icon": "",
              "label": "घालण्याचा क्रम"
            },
            {
              "icon": "",
              "label": "कोणत्याही क्रमाची हमी नाही"
            },
            {
              "icon": "",
              "label": "कीनुसार क्रमबद्ध"
            },
            {
              "icon": "",
              "label": "घालण्याचा उलटा क्रम"
            }
          ]
        },
        {
          "question": "साधा java.util.HashMap एका वेळी किती null की आणि किती null मूल्ये ठेवू शकतो?",
          "options": [
            {
              "icon": "",
              "label": "एकही null की नाही आणि एकही null मूल्य नाही"
            },
            {
              "icon": "",
              "label": "एक null की, कितीही null मूल्ये"
            },
            {
              "icon": "",
              "label": "कितीही null की किंवा मूल्ये"
            },
            {
              "icon": "",
              "label": "एक null की आणि एक null मूल्य"
            }
          ]
        },
        {
          "question": "तुम्ही for-each लूपने एका List वर इटरेट करता आणि लूपच्या बॉडीतून काही, पण सर्व नाही, घटकांसाठी लिस्टवर थेट list.remove(item) बोलावता. काय होते?",
          "options": [
            {
              "icon": "",
              "label": "ते नेमके अपेक्षित घटक काढून टाकते"
            },
            {
              "icon": "",
              "label": "ते घटक काढते, पण लूप संपल्यानंतरच"
            },
            {
              "icon": "",
              "label": "ते IndexOutOfBoundsException फेकते"
            },
            {
              "icon": "",
              "label": "ते ConcurrentModificationException फेकते"
            }
          ]
        },
        {
          "question": "रनटाइमला, List<String> list दिलेली असताना, रिफ्लेक्शन किंवा instanceof द्वारे तुम्ही तिच्या जेनेरिक टाइप पॅरामीटरबद्दल प्रत्यक्षात काय ठरवू शकता?",
          "options": [
            {
              "icon": "",
              "label": "list.getElementType() String.class परत करते"
            },
            {
              "icon": "",
              "label": "instanceof List<String> घटकाचा प्रकार तपासते"
            },
            {
              "icon": "",
              "label": "JVM ते मेटाडेटा म्हणून ठेवते, जो getGenericType() द्वारे वाचता येतो"
            },
            {
              "icon": "",
              "label": "घटकाच्या प्रकाराबद्दल काहीही नाही"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(\"Weekday\"); break; case 6: print(\"Saturday\"); case 7: print(\"Sunday\"); break; default: print(\"?\"); } day 6 असल्यास काय प्रिंट होते?",
          "options": [
            {
              "icon": "",
              "label": "फक्त Saturday"
            },
            {
              "icon": "",
              "label": "फक्त Sunday"
            },
            {
              "icon": "",
              "label": "Saturday, Sunday, नंतर ?"
            },
            {
              "icon": "",
              "label": "Saturday, नंतर Sunday"
            }
          ]
        },
        {
          "question": "एका Product क्लासला किमतीनुसार एक स्पष्ट \"नैसर्गिक\" क्रमवारी हवी आहे, तसेच कोडबेसमध्ये वेगवेगळ्या ठिकाणी नावानुसार किंवा स्टॉक पातळीनुसारही क्रमवारी लावता यायला हवी. कोणता संयोग योग्य डिझाइन आहे?",
          "options": [
            {
              "icon": "",
              "label": "Comparable<Product> तीन वेगवेगळ्या वेळा इम्प्लिमेंट करा"
            },
            {
              "icon": "",
              "label": "किमतीसाठी Comparable, तसेच नाव आणि स्टॉकसाठी वेगळे Comparators"
            },
            {
              "icon": "",
              "label": "नावासाठी Comparable, तसेच किंमत आणि स्टॉकसाठी Comparators"
            },
            {
              "icon": "",
              "label": "तीन ओव्हरलोड केलेल्या compareTo मेथड्ससह एक Comparable"
            }
          ]
        },
        {
          "question": "एक मेथड new FileReader(path) बोलावते, जो throws IOException घोषित करतो. IOException हे Exception ला एक्स्टेंड करते, RuntimeException ला नाही. हे कंपाइल होण्यासाठी तुम्ही काय केले पाहिजे?",
          "options": [
            {
              "icon": "",
              "label": "काहीही नाही; ते जसे लिहिले आहे तसे कंपाइल होते"
            },
            {
              "icon": "",
              "label": "IOException कॅच करा किंवा throws IOException घोषित करा"
            },
            {
              "icon": "",
              "label": "कॉलभोवती RuntimeException कॅच करा"
            },
            {
              "icon": "",
              "label": "मेथड static घोषित करा"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(\"A\"); Resource b = new Resource(\"B\")) { ... } मध्ये AutoCloseable अंमलात आणणारी दोन रिसोर्सेस वापरली आहेत. try ब्लॉक सामान्यपणे संपला, तर ती कोणत्या क्रमाने बंद केली जातात?",
          "options": [
            {
              "icon": "",
              "label": "घोषणेच्या क्रमाने, आधी A मग B"
            },
            {
              "icon": "",
              "label": "आधी B, मग A"
            },
            {
              "icon": "",
              "label": "दोन्ही एकाच वेळी"
            },
            {
              "icon": "",
              "label": "फक्त B आपोआप बंद होते"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } getValue() बोलावल्यावर काय परत मिळते?",
          "options": [
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "ते एक्सेप्शन फेकते"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होत नाही"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, आणि FileNotFoundException हे IOException ला एक्स्टेंड करते. हे कंपाइल करण्याचा प्रयत्न केल्यावर काय होते?",
          "options": [
            {
              "icon": "",
              "label": "पोहोचता न येणाऱ्या दुसऱ्या catch साठी कंपाइल एरर"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होते; FileNotFoundException ब्लॉक त्या प्रकाराला हाताळतो"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होते आणि दोन्ही catch ब्लॉक क्रमाने चालतात"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होते, पण FileNotFoundException आल्यावर रनटाइमला अयशस्वी होते"
            }
          ]
        },
        {
          "question": "एका क्लासमध्ये synchronized इन्स्टन्स मेथड process() आणि synchronized स्टॅटिक मेथड configure() आहे. त्यापैकी प्रत्येक नेमके कशाला लॉक करते?",
          "options": [
            {
              "icon": "",
              "label": "process() इन्स्टन्सला लॉक करते; configure() Class ऑब्जेक्टला लॉक करते"
            },
            {
              "icon": "",
              "label": "दोन्ही एकच JVM-व्यापी ग्लोबल लॉक घेतात"
            },
            {
              "icon": "",
              "label": "process() Class ऑब्जेक्टला लॉक करते; configure() कॉल करणाऱ्या इन्स्टन्सला लॉक करते"
            },
            {
              "icon": "",
              "label": "आत synchronized ब्लॉक असल्याशिवाय दोन्हीपैकी एकही काहीही लॉक करत नाही"
            }
          ]
        },
        {
          "question": "एक फील्ड volatile int counter = 0; असे घोषित केले आहे, आणि अनेक थ्रेड्स त्यावर एकाच वेळी counter++ चालवतात. volatile येथे हरवलेले अपडेट्स टाळते का?",
          "options": [
            {
              "icon": "",
              "label": "होय"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "फक्त int आणि long फील्ड्ससाठी"
            },
            {
              "icon": "",
              "label": "फक्त फील्ड static असेल तरच"
            }
          ]
        },
        {
          "question": "इंटरफेस A आणि इंटरफेस B प्रत्येकी एक डिफॉल्ट मेथड describe() घोषित करतात. एक क्लास A आणि B दोन्ही अंमलात आणतो आणि स्वतः describe() ओव्हरराइड करत नाही. काय होते?",
          "options": [
            {
              "icon": "",
              "label": "A ची आवृत्ती चालते, कारण A आधी नमूद केलेले आहे"
            },
            {
              "icon": "",
              "label": "दोन्ही आवृत्त्या एकापाठोपाठ एक चालतात"
            },
            {
              "icon": "",
              "label": "ते कंपाइल होते, पण बोलावल्यावर एक्सेप्शन फेकते"
            },
            {
              "icon": "",
              "label": "क्लासने describe() ओव्हरराइड केल्याशिवाय कंपाइल एरर येतो"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); असे लिहिले आहे, पण त्याचा निकाल .collect() किंवा .forEach() सारख्या टर्मिनल ऑपरेशनला कधीच दिला जात नाही. ही ओळ चालवल्यावर प्रत्यक्षात काय होते?",
          "options": [
            {
              "icon": "",
              "label": "काहीही नाही; पाइपलाइन कधीच चालत नाही"
            },
            {
              "icon": "",
              "label": "प्रत्येक घटक लगेच फिल्टर आणि मॅप केला जातो"
            },
            {
              "icon": "",
              "label": "फक्त filter चालते; map टर्मिनल ऑपरेशनची वाट पाहते"
            },
            {
              "icon": "",
              "label": "ते IllegalStateException फेकते"
            }
          ]
        }
      ],
      "optionOrderVersion": "9d7b97ef6cccf4e2"
    }
  },
  "testNames": {
    "java-test": "Java चाचणी"
  }
}