{
  "assessmentTests": {
    "java_test": {
      "name": "ಜಾವಾ ಪರೀಕ್ಷೆ",
      "desc": "ಕೋರ್ ಸಿಂಟ್ಯಾಕ್ಸ್, OOP ಮೆಕ್ಯಾನಿಕ್ಸ್, ಕಲೆಕ್ಷನ್ಸ್, ಜೆನೆರಿಕ್ಸ್, ಎಕ್ಸೆಪ್ಶನ್ಸ್ ಮತ್ತು ಕನ್ಕರೆನ್ಸಿಯ ಕುರಿತು 30 ಸನ್ನಿವೇಶದ ಪ್ರಶ್ನೆಗಳು — ನಿಮ್ಮ ಜಾವಾ ಕೌಶಲ್ಯವು ಉದ್ಯೋಗದ ಜಾಹೀರಾತಿನಲ್ಲಿ ಹೇಳುವ ಜಾವಾ ಪ್ರಾವೀಣ್ಯತೆಗೆ ಸರಿಹೊಂದುತ್ತದೆಯೇ ಎಂದು ಕಂಡುಹಿಡಿಯಿರಿ.",
      "recommendation": "ನಿಮ್ಮ ಜಾವಾ ಕೌಶಲ್ಯಗಳ ವಿವರ",
      "results": {
        "beginner": {
          "name": "ಆರಂಭಿಕ",
          "desc": "ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳನ್ನು ಬರೆಯಬಲ್ಲಿರಿ, ಆದರೆ ನೀವು ತಪ್ಪಿಸಿಕೊಂಡ ಪ್ರಶ್ನೆಗಳು ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗಿಂತ ಹೆಚ್ಚಾಗಿ ಐಡೆಂಟಿಟಿ ಮತ್ತು ಡೀಫಾಲ್ಟ್‌ಗಳ ಸುತ್ತ ಕೇಂದ್ರೀಕೃತವಾಗಿವೆ — String == vs .equals, new String(\"x\") ಸ್ಟ್ರಿಂಗ್ ಪೂಲ್ ಅನ್ನು ಏಕೆ ಮರುಬಳಕೆ ಮಾಡುವುದಿಲ್ಲ, ಒಂದು ನ್ಯೂಮರಿಕ್ ಫೀಲ್ಡ್‌ನ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ ಮತ್ತು ಒಂದು ವ್ರ್ಯಾಪರ್ ಫೀಲ್ಡ್‌ನ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯದ ನಡುವಿನ ವ್ಯತ್ಯಾಸ. ಇದ್ಯಾವುದೂ ನೀವು ಜಾವಾದಲ್ಲಿ ಕೆಟ್ಟವರಾಗಿದ್ದೀರಿ ಎಂದಲ್ಲ; ಇವುಗಳು ರೆಫರೆನ್ಸ್‌ಗಳು ಮತ್ತು ಪ್ರಿಮಿಟಿವ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಕಲಿಯುವ ಬದಲು ಪ್ರಯೋಗ ಮತ್ತು ದೋಷದ ಮೂಲಕ ಭಾಷೆಯನ್ನು ಕಲಿತ ಜನರನ್ನು ಗೊಂದಲಕ್ಕೀಡುಮಾಡುವ ನಿರ್ದಿಷ್ಟ ನಿಯಮಗಳಾಗಿವೆ. ಇವು ಕೆಲಸದಲ್ಲಿ ಮುಖ್ಯವಾಗುತ್ತವೆ ಏಕೆಂದರೆ ಪ್ರತಿಯೊಂದೂ ಕೋಡ್ ಕಂಪೈಲ್ ಆಗಿ, ರನ್ ಆಗಿ, ಮತ್ತು ಸದ್ದಿಲ್ಲದೆ ತಪ್ಪು ಕೆಲಸ ಮಾಡುವ ಸ್ಥಳವಾಗಿದೆ.",
          "recommendation": "ಈ ಮೂರು ವಿಷಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ, ಈ ಕ್ರಮದಲ್ಲಿ: ಎರಡು String ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೇಲೆ == ಏಕೆ ಅಕ್ಷರಗಳ ಬದಲಿಗೆ ರೆಫರೆನ್ಸ್‌ಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ (ಮತ್ತು .equals ನೀವು ಬಹುತೇಕ ಯಾವಾಗಲೂ ಬಯಸುವಂಥದ್ದು), int ಓವರ್‌ಫ್ಲೋ ಹೇಗೆ ಎರರ್ ಬರುವ ಬದಲು ಸದ್ದಿಲ್ಲದೆ ಸುತ್ತಿಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಇನಿಶಿಯಲೈಸ್ ಆಗದ Integer ಫೀಲ್ಡ್ ಏಕೆ null ಗೆ ಡೀಫಾಲ್ಟ್ ಆಗುತ್ತದೆ ಆದರೆ int ಫೀಲ್ಡ್ 0 ಗೆ ಡೀಫಾಲ್ಟ್ ಆಗುತ್ತದೆ. ಒರಾಕಲ್‌ನ ಅಧಿಕೃತ ಜಾವಾ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು ಮತ್ತು ಬೇಲ್ಡಂಗ್ ಎರಡೂ ಈ ಮೂರನ್ನೂ ರನ್ ಮಾಡಬಹುದಾದ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವರಿಸುತ್ತವೆ."
        },
        "intermediate": {
          "name": "ಮಧ್ಯಂತರ",
          "desc": "ನೀವು ದೈನಂದಿನ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಆರಾಮವಾಗಿ ನಿಭಾಯಿಸುತ್ತೀರಿ — ಕ್ಲಾಸ್‌ಗಳು, ಕಲೆಕ್ಷನ್‌ಗಳು, ನೇರವಾದ ಕಂಟ್ರೋಲ್ ಫ್ಲೋ — ಮತ್ತು ದಿನನಿತ್ಯದ ಫೀಚರ್ ಕೆಲಸದಿಂದ ನಿಧಾನವಾಗುವುದಿಲ್ಲ. ಇಲ್ಲಿಂದ ಅಡ್ವಾನ್ಸ್ಡ್‌ ಹಂತದ ನಡುವಿನ ಅಂತರವು ಮುಖ್ಯವಾಗಿ ಜಾವಾದ ನಿಯಮಗಳು ಕನ್‌ಕರೆನ್ಸಿ ಮತ್ತು ಜೆನೆರಿಕ್ಸ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ ಏನಾಗುತ್ತದೆ ಎಂಬುದರಲ್ಲಿದೆ: ನೀವು ನಿರೀಕ್ಷಿಸಿದ ಆಬ್ಜೆಕ್ಟ್ ಬದಲಿಗೆ ಡಿಕ್ಲೇರ್ಡ್ ಟೈಪ್‌ನಿಂದ ಪರಿಹರಿಸಲಾದ ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್, ನೀವು ಮೌನವಾಗಿ ಅವಲಂಬಿಸಿದ್ದ HashMap ಇಟರೇಶನ್ ಆರ್ಡರ್, ಲೂಪ್ ಮಧ್ಯದಲ್ಲಿ ಐಟಂ ಅನ್ನು ತೆಗೆದುಹಾಕುವುದರಿಂದ ಉಂಟಾಗುವ ConcurrentModificationException. ಇವುಗಳು ತ್ವರಿತ ಓದಿನಲ್ಲಿ ಪಾಸಾಗುವ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ರನ್‌ಟೈಮ್ ಸ್ಥಿತಿಯಲ್ಲಿ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಬಗ್‌ಗಳಾಗಿವೆ.",
          "recommendation": "ಕಂಪೈಲರ್‌ನ ನಿಮ್ಮ ಕೋಡ್‌ನ ಸ್ಟ್ಯಾಟಿಕ್ ವೀಕ್ಷಣೆ ರನ್ ಆಗುವುದಕ್ಕಿಂತ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ ಎಂಬುದರ ಮೇಲೆ ಗಮನಹರಿಸಿ: ರನ್‌ಟೈಮ್ ಟೈಪ್‌ಗಿಂತ ಡಿಕ್ಲೇರ್ಡ್ ಟೈಪ್‌ನಿಂದ ಓವರ್‌ಲೋಡ್ ರೆಸಲ್ಯೂಶನ್ ಮತ್ತು ಸ್ಟ್ಯಾಟಿಕ್-ಮೆಥಡ್ ಹೈಡಿಂಗ್, HashMap ಇಟರೇಶನ್-ಆರ್ಡರ್ ಗ್ಯಾರಂಟಿ ಏಕೆ ನೀಡುವುದಿಲ್ಲ, ಮತ್ತು ಇಟರೇಟ್ ಮಾಡುವಾಗ ನೇರವಾಗಿ ಲಿಸ್ಟ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದು ConcurrentModificationException ಅನ್ನು ಏಕೆ ಎಸೆಯುತ್ತದೆ. ನಂತರ ಜೆನೆರಿಕ್ಸ್ ಎರೇಸರ್, ಏಕೆಂದರೆ ಇದು ಈಗಾಗಲೇ ಕಲೆಕ್ಷನ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ತಿಳಿದಿರುವ ಜನರನ್ನು ಗೊಂದಲಕ್ಕೀಡುಮಾಡುತ್ತದೆ."
        },
        "advanced": {
          "name": "ಮುಂದುವರಿದ",
          "desc": "ಹೆಚ್ಚಿನ ಉದ್ಯೋಗ ಪೋಸ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ “ಬಲವಾದ ಜಾವಾ” ಎಂದರೆ ಇದೇ ಮಟ್ಟ. ನೀವು ಸ್ಟ್ಯಾಟಿಕ್ ಬ್ಲಾಕ್‌ಗಳು, ಇನ್‌ಸ್ಟೆನ್ಸ್ ಬ್ಲಾಕ್‌ಗಳು ಮತ್ತು ಬಹು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳಿರುವ ಕ್ಲಾಸ್ ಅನ್ನು ಓದಿ, ಅವು ಯಾವ ನಿಖರವಾದ ಕ್ರಮದಲ್ಲಿ ರನ್ ಆಗುತ್ತವೆ ಎಂದು ಊಹಿಸಬಹುದು, ಫೈನಲಿ ಬ್ಲಾಕ್ ಟ್ರೈ ಬ್ಲಾಕ್‌ನ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಹೇಗೆ ಮೌನವಾಗಿ ತಿರಸ್ಕರಿಸಬಹುದು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ, ಮತ್ತು ಮ್ಯಾನುಯಲ್ ಫೈನಲಿ-ಕ್ಲೋಸ್ ಬದಲಿಗೆ ನೀವು ಟ್ರೈ-ವಿತ್-ರಿಸೋರ್ಸಸ್‌ಗೆ ಮೊರೆ ಹೋಗುತ್ತೀರಿ ಏಕೆಂದರೆ ಅದು ನಿಮಗೆ ನೀಡುವ ಆರ್ಡರಿಂಗ್ ಗ್ಯಾರಂಟಿ ನಿಮಗೆ ತಿಳಿದಿದೆ. ಈ ಬ್ಯಾಂಡ್ ಅನ್ನು ಟಾಪ್‌ನಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು ಕೆಲಸದ ಕನ್‌ಕರೆಂಟ್ ಮತ್ತು ಇಂಟರ್ಫೇಸ್-ಮಟ್ಟದ ಭಾಗವಾಗಿದೆ: ಸಿಂಕ್ರೊನೈಸ್ಡ್ ವಾಸ್ತವವಾಗಿ ಏನನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ, ವೊಲಟೈಲ್ ಏನು ಗ್ಯಾರಂಟಿ ನೀಡುತ್ತದೆ ಮತ್ತು ನೀಡುವುದಿಲ್ಲ, ಮತ್ತು ಡೀಫಾಲ್ಟ್-ಮೆಥಡ್ ಸಂಘರ್ಷಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.",
          "recommendation": "ಇತರ ಥ್ರೆಡ್‌ಗಳು ಮತ್ತು ಇತರ ಇಂಟರ್ಫೇಸ್‌ಗಳು ಸಹ ಸ್ಪರ್ಶಿಸುವ ಕೋಡ್ ಅನ್ನು ರಕ್ಷಿಸುವ ಭಾಗಗಳಿಗೆ ಗಮನ ಕೊಡಿ: ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್ ಲಾಕ್ ಮಾಡುವುದಕ್ಕೂ ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್ ಲಾಕ್ ಮಾಡುವುದಕ್ಕೂ ಇರುವ ವ್ಯತ್ಯಾಸ, ವೊಲಟೈಲ್ ಕೌಂಟರ್++ ಗೆ ವಿಸಿಬಿಲಿಟಿ ನೀಡಿದರೂ ಅಟಾಮಿಸಿಟಿಯನ್ನು ಏಕೆ ನೀಡುವುದಿಲ್ಲ, ಮತ್ತು ಡೀಫಾಲ್ಟ್-ಮೆಥಡ್ ಡೈಮಂಡ್ ಅನ್ನು ಕೈಯಾರೆ ಪರಿಹರಿಸಲು ಜಾವಾ ನಿಮ್ಮನ್ನು ಹೇಗೆ ಒತ್ತಾಯಿಸುತ್ತದೆ. ಜಾವಾ ಮೆಮೊರಿ ಮಾಡೆಲ್ ಕುರಿತ Baeldung ಮತ್ತು Java Concurrency in Practice ನ ವಿಷಯಗಳು ಇವೆರಡಕ್ಕೂ ಮುಂದಿನ ಸಹಜ ನಿಲುಗಡೆಯಾಗಿದೆ."
        },
        "expert": {
          "name": "ಪರಿಣತ",
          "desc": "ನೀವು ಪ್ರತಿಯೊಂದು ವಿಭಾಗದಲ್ಲಿಯೂ ಉನ್ನತ ಅಂಕಗಳನ್ನು ಗಳಿಸಿದ್ದೀರಿ — ಕೋರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಟೈಪ್‌ಗಳು, OOP ಮೆಕ್ಯಾನಿಕ್ಸ್ ಮತ್ತು ಸ್ಕೋಪ್, ಕಲೆಕ್ಷನ್‌ಗಳು ಮತ್ತು ಜೆನೆರಿಕ್ಸ್, ಮತ್ತು ಎಕ್ಸೆಪ್ಶನ್‌ಗಳು, ಕನ್‌ಕರೆನ್ಸಿ ಮತ್ತು ಇಡಿಯಮ್ಸ್. ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಇದರರ್ಥ ನಿಮಗೆ ಅಪರಿಚಿತರ ಕ್ಲಾಸ್ ಅನ್ನು ನೀಡಿದರೆ, ಕಂಪೈಲ್ ಎರರ್, ರನ್‌ಟೈಮ್ ಎಕ್ಸೆಪ್ಶನ್, ಅಥವಾ ಮೌನವಾಗಿ ತಪ್ಪಾದ ಮೌಲ್ಯ ಏಕೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ವಿವರಿಸಬಹುದು, ಸಿಂಟ್ಯಾಕ್ಸ್ ಏನು ಮಾಡಬೇಕು ಎಂದು ಹೇಳುವುದಷ್ಟೇ ಅಲ್ಲ, ಇದು ಹೆಚ್ಚು ಕಷ್ಟಕರ ಮತ್ತು ಹೆಚ್ಚು ಮೌಲ್ಯಯುತವಾದ ಕೌಶಲ್ಯವಾಗಿದೆ. ಈ ಮಟ್ಟದಲ್ಲಿ ಭಾಷೆಯೇ ವಿರಳವಾಗಿ ಸೀಮಿತಗೊಳಿಸುವ ಅಂಶವಾಗಿರುತ್ತದೆ; ಮಿತಿ ಸಾಮಾನ್ಯವಾಗಿ ಕನ್‌ಕರೆನ್ಸಿ ವಿನ್ಯಾಸ ಅಥವಾ ಅದರ ಕೆಳಗಿರುವ ಡೇಟಾದ ಆಕಾರವಾಗಿರುತ್ತದೆ.",
          "recommendation": "ಈಗ ಲಾಭಗಳು ವಿನ್ಯಾಸ ಮತ್ತು ರೋಗನಿರ್ಣಯದಲ್ಲಿವೆ: ಹ್ಯಾಂಗ್ ಅನ್ನು ಡೆಡ್‌ಲಾಕ್ ಎಂದು ಭಾವಿಸುವ ಮೊದಲು ಥ್ರೆಡ್ ಡಂಪ್ ಅನ್ನು ಓದುವುದು, ಡೀಫಾಲ್ಟ್ ಬದಲಿಗೆ ಟ್ರೇಡ್‌ಆಫ್ ಆಗಿ ಸಿಂಕ್ರೊನೈಸ್ಡ್, java.util.concurrent ಲಾಕ್‌ಗಳು ಮತ್ತು ಅಟಾಮಿಕ್ಸ್ ನಡುವೆ ಆಯ್ಕೆ ಮಾಡುವುದು, ಮತ್ತು ಆಕಸ್ಮಿಕವಾಗಿ ಬದಲಾಗಿ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಲೇಜಿಯಾಗಿ ಉಳಿಯುವ ಸ್ಟ್ರೀಮ್-ಪೈಪ್‌ಲೈನ್ ವಿನ್ಯಾಸ. ಒಂದು ಪಾತ್ರಕ್ಕಾಗಿ ನಿಮ್ಮನ್ನು ಸ್ಕ್ರೀನ್ ಮಾಡಲಾಗುತ್ತಿದ್ದರೆ, ಜಾವಾ ಫೀಚರ್‌ಗಳನ್ನು ಹೆಸರಿಸುವ ಬದಲು, ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ನೀವು ಕಂಡುಕೊಂಡ ಮಿಸ್ಡ್ ಹ್ಯಾಪನ್ಸ್-ಬಿಫೋರ್ ಎಡ್ಜ್ ಅಥವಾ ConcurrentModificationException ನಂತಹ ಕನ್‌ಕರೆನ್ಸಿ ಬಗ್ ಅನ್ನು ವಿವರಿಸಿ — ಇದು ಕೇವಲ ಶಬ್ದಕೋಶವನ್ನಲ್ಲ, ತಾರ್ಕಿಕತೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ."
        }
      },
      "questions": [
        {
          "question": "ನೀವು ಎರಡು ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುತ್ತೀರಿ: 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, ಏಕೆಂದರೆ ಜಾವಾ ಡಬಲ್ ಮೊತ್ತಗಳನ್ನು ಹತ್ತಿರದ ದಶಮಾಂಶಕ್ಕೆ ರೌಂಡ್ ಮಾಡುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "true, ಏಕೆಂದರೆ ಎರಡು-ದಶಮಾಂಶ ಮೌಲ್ಯಗಳು ಡಬಲ್‌ನಲ್ಲಿ ನಿಖರವಾಗಿ ಸೇರುತ್ತವೆ"
            },
            {
              "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 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ, ಪ್ರತಿ ಬಾರಿ ಸ್ಟ್ರಿಂಗ್ ರಿಸಲ್ಟ್ ಮೇಲೆ result += \"x\"; ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಇಟರೇಶನ್‌ನಲ್ಲಿ ತೆರೆಮರೆಯಲ್ಲಿ ನಿಜವಾಗಿ ಏನಾಗುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಟ್ರಿಂಗ್‌ನ ಕ್ಯಾರೆಕ್ಟರ್ ಅರೇಯನ್ನು ಸ್ಥಳದಲ್ಲಿಯೇ ವಿಸ್ತರಿಸಲಾಗುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಜಾವಾ ಎಲ್ಲಾ ಕನ್‌ಕ್ಯಾಟಿನೇಶನ್‌ಗಳನ್ನು ಒಂದೇ ಅಂತಿಮ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಬ್ಯಾಚ್ ಮಾಡುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಎಲ್ಲಾ 1000 ಇಟರೇಶನ್‌ಗಳಾದ್ಯಂತ ಒಂದು StringBuilder ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಲಾಗುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸಿ ರಿಸಲ್ಟ್‌ಗೆ ಅಸೈನ್ ಮಾಡಲಾಗುತ್ತದೆ"
            }
          ]
        },
        {
          "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), ಏಕೆಂದರೆ ಆಬ್ಜೆಕ್ಟ್‌ನ ರನ್‌ಟೈಮ್ ಕ್ಲಾಸ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ"
            },
            {
              "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": "ಅದು ಇನ್ನೂ “ಹಳೆಯದು”"
            },
            {
              "icon": "",
              "label": "ಒಂದು ರನ್‌ಟೈಮ್ ವಿನಾಯಿತಿಯನ್ನು (exception) ಎಸೆಯಲಾಗುತ್ತದೆ"
            }
          ]
        },
        {
          "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": "ಡೆಲಿಗೇಟ್ ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಗುರುತಿಸಲಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಮಾತ್ರ"
            }
          ]
        },
        {
          "question": "ನಿಮಗೆ ಒಂದು ಲಿಸ್ಟ್ ಬೇಕು, ಅದರಲ್ಲಿ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಮುಂಭಾಗದಲ್ಲಿ ಅತಿ ಹೆಚ್ಚಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ರಾಂಡಮ್-ಆಕ್ಸೆಸ್ ರೀಡ್‌ಗಳು ಅಪರೂಪ. ಯಾವುದು ಉತ್ತಮ ರಚನಾತ್ಮಕ ಹೊಂದಾಣಿಕೆ, ಮತ್ತು ಏಕೆ?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList, ಏಕೆಂದರೆ ಅದರ ಬ್ಯಾಕಿಂಗ್ ಅರೇ ಮುಂಭಾಗದ ಇನ್ಸರ್ಟ್‌ಗಳನ್ನು ಅತಿ ವೇಗವಾಗಿಸುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಯಾವುದಾದರೂ ಒಂದು, ಏಕೆಂದರೆ ಎರಡೂ ಒಂದೇ ಗ್ಯಾರಂಟಿಗಳೊಂದಿಗೆ ಲಿಸ್ಟ್ ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುತ್ತವೆ"
            },
            {
              "icon": "",
              "label": "LinkedList, ಏಕೆಂದರೆ ಮುಂಭಾಗದ ಇನ್ಸರ್ಷನ್ O(n) ಬದಲಿಗೆ O(1) ಆಗಿದೆ"
            },
            {
              "icon": "",
              "label": "LinkedList, ಏಕೆಂದರೆ ಅದು O(1) ರಾಂಡಮ್ ಆಕ್ಸೆಸ್ ನೀಡುತ್ತದೆ"
            }
          ]
        },
        {
          "question": "ನೀವು ಒಂದು ಪ್ಲೇನ್ HashMap ಗೆ ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಐದು ಎಂಟ್ರಿಗಳನ್ನು ಸೇರಿಸುತ್ತೀರಿ, ನಂತರ ಅದರ ಮೇಲೆ ಫಾರ್-ಈಚ್ ಲೂಪ್‌ನೊಂದಿಗೆ ಇಟರೇಟ್ ಮಾಡುತ್ತೀರಿ. ಎಂಟ್ರಿಗಳು ಯಾವ ಕ್ರಮದಲ್ಲಿ ಹೊರಬರುತ್ತವೆ?",
          "options": [
            {
              "icon": "",
              "label": "ಸೇರಿಸಿದ ಕ್ರಮ"
            },
            {
              "icon": "",
              "label": "ಯಾವುದೇ ಖಚಿತವಾದ ಕ್ರಮವಿಲ್ಲ"
            },
            {
              "icon": "",
              "label": "ಕೀ ಮೂಲಕ ವಿಂಗಡಿಸಲಾಗಿದೆ"
            },
            {
              "icon": "",
              "label": "ಸೇರಿಸಿದ ಕ್ರಮದ ಹಿಮ್ಮುಖ"
            }
          ]
        },
        {
          "question": "ಒಂದು ಪ್ಲೇನ್ java.util.HashMap ಒಂದೇ ಸಮಯದಲ್ಲಿ ಎಷ್ಟು ಶೂನ್ಯ (null) ಕೀಗಳನ್ನು ಮತ್ತು ಎಷ್ಟು ಶೂನ್ಯ (null) ಮೌಲ್ಯಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು?",
          "options": [
            {
              "icon": "",
              "label": "ಶೂನ್ಯ ಕೀಗಳಿಲ್ಲ ಮತ್ತು ಶೂನ್ಯ ಮೌಲ್ಯಗಳಿಲ್ಲ"
            },
            {
              "icon": "",
              "label": "ಒಂದು ಶೂನ್ಯ ಕೀ, ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಶೂನ್ಯ ಮೌಲ್ಯಗಳು"
            },
            {
              "icon": "",
              "label": "ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಶೂನ್ಯ ಕೀಗಳು ಅಥವಾ ಮೌಲ್ಯಗಳು"
            },
            {
              "icon": "",
              "label": "ಒಂದು ಶೂನ್ಯ ಕೀ ಮತ್ತು ಒಂದು ಶೂನ್ಯ ಮೌಲ್ಯ"
            }
          ]
        },
        {
          "question": "ನೀವು ಒಂದು ಲಿಸ್ಟ್ ಅನ್ನು ಫಾರ್-ಈಚ್ ಲೂಪ್‌ನೊಂದಿಗೆ ಇಟರೇಟ್ ಮಾಡುತ್ತೀರಿ ಮತ್ತು ಲೂಪ್ ಬಾಡಿಯ ಒಳಗಿನಿಂದ ನೇರವಾಗಿ ಲಿಸ್ಟ್ ಮೇಲೆ 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, ಜೊತೆಗೆ ಹೆಸರು ಮತ್ತು ಸ್ಟಾಕ್‌ಗಾಗಿ ಪ್ರತ್ಯೇಕ Comparatorಗಳು"
            },
            {
              "icon": "",
              "label": "ಹೆಸರಿಗಾಗಿ Comparable, ಜೊತೆಗೆ ಬೆಲೆ ಮತ್ತು ಸ್ಟಾಕ್‌ಗಾಗಿ Comparatorಗಳು"
            },
            {
              "icon": "",
              "label": "ಮೂರು ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ compareTo ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ಒಂದು Comparable"
            }
          ]
        },
        {
          "question": "ಒಂದು ಮೆಥಡ್ new FileReader(path) ಎಂದು ಕರೆಯುತ್ತದೆ, ಇದು throws IOException ಎಂದು ಡಿಕ್ಲೇರ್ ಮಾಡುತ್ತದೆ. IOException, RuntimeException ಅನ್ನು ಅಲ್ಲ, Exception ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ. ಇದನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ನೀವು ಏನು ಮಾಡಬೇಕು?",
          "options": [
            {
              "icon": "",
              "label": "ಏನೂ ಇಲ್ಲ; ಅದು ಬರೆದಂತೆಯೇ ಕಂಪೈಲ್ ಆಗುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "IOException ಅನ್ನು ಕ್ಯಾಚ್ ಮಾಡಿ ಅಥವಾ throws IOException ಎಂದು ಡಿಕ್ಲೇರ್ ಮಾಡಿ"
            },
            {
              "icon": "",
              "label": "ಕರೆಯ ಸುತ್ತಲೂ RuntimeException ಅನ್ನು ಕ್ಯಾಚ್ ಮಾಡಿ"
            },
            {
              "icon": "",
              "label": "ಮೆಥಡ್ ಅನ್ನು ಸ್ಟ್ಯಾಟಿಕ್ ಎಂದು ಡಿಕ್ಲೇರ್ ಮಾಡಿ"
            }
          ]
        },
        {
          "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": "ಇದು ಒಂದು ವಿನಾಯಿತಿಯನ್ನು (exception) ಎಸೆಯುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "ಇದು ಕಂಪೈಲ್ ಆಗುವುದಿಲ್ಲ"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, ಮತ್ತು FileNotFoundException IOException ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ. ಇದನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಏನಾಗುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "ತಲುಪಲಾಗದ ಎರಡನೇ ಕ್ಯಾಚ್‌ಗಾಗಿ ಒಂದು ಕಂಪೈಲ್ ದೋಷ"
            },
            {
              "icon": "",
              "label": "ಇದು ಕಂಪೈಲ್ ಆಗುತ್ತದೆ; FileNotFoundException ಬ್ಲಾಕ್ ಆ ಪ್ರಕಾರವನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಇದು ಕಂಪೈಲ್ ಆಗುತ್ತದೆ, ಮತ್ತು ಎರಡೂ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ಗಳು ಕ್ರಮವಾಗಿ ರನ್ ಆಗುತ್ತವೆ"
            },
            {
              "icon": "",
              "label": "ಇದು ಕಂಪೈಲ್ ಆಗುತ್ತದೆ ಆದರೆ FileNotFoundException ಮೇಲೆ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ"
            }
          ]
        },
        {
          "question": "ಒಂದು ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್ process() ಮತ್ತು ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್ configure() ಇವೆ. ಪ್ರತಿಯೊಂದು ನಿರ್ದಿಷ್ಟವಾಗಿ ಏನನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "process() ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ; configure() ಕ್ಲಾಸ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಎರಡೂ ಒಂದು ಜಾಗತಿಕ JVM-ವ್ಯಾಪಿ ಲಾಕ್ ಅನ್ನು ಲಾಕ್ ಮಾಡುತ್ತವೆ"
            },
            {
              "icon": "",
              "label": "process() ಕ್ಲಾಸ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ; configure() ಕಾಲರ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಒಳಗೆ ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲದೆ ಎರಡೂ ಏನನ್ನೂ ಲಾಕ್ ಮಾಡುವುದಿಲ್ಲ"
            }
          ]
        },
        {
          "question": "ಒಂದು ಫೀಲ್ಡ್ ಅನ್ನು volatile int counter = 0; ಎಂದು ಡಿಕ್ಲೇರ್ ಮಾಡಲಾಗಿದೆ, ಮತ್ತು ಅನೇಕ ಥ್ರೆಡ್‌ಗಳು ಅದರ ಮೇಲೆ ಏಕಕಾಲದಲ್ಲಿ counter++ ಅನ್ನು ರನ್ ಮಾಡುತ್ತವೆ. ಇಲ್ಲಿ volatile ಕಳೆದುಹೋದ ಅಪ್‌ಡೇಟ್‌ಗಳನ್ನು ತಡೆಯುತ್ತದೆಯೇ?",
          "options": [
            {
              "icon": "",
              "label": "ಹೌದು"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "ಕೇವಲ int ಮತ್ತು long ಫೀಲ್ಡ್‌ಗಳಿಗೆ ಮಾತ್ರ"
            },
            {
              "icon": "",
              "label": "ಫೀಲ್ಡ್ ಸ್ಟ್ಯಾಟಿಕ್ ಆಗಿದ್ದರೆ ಮಾತ್ರ"
            }
          ]
        },
        {
          "question": "ಇಂಟರ್ಫೇಸ್ A ಮತ್ತು ಇಂಟರ್ಫೇಸ್ B ಪ್ರತಿಯೊಂದೂ ಡೀಫಾಲ್ಟ್ ಮೆಥಡ್ describe() ಅನ್ನು ಡಿಕ್ಲೇರ್ ಮಾಡುತ್ತವೆ. ಒಂದು ಕ್ಲಾಸ್ A ಮತ್ತು B ಎರಡನ್ನೂ ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು describe() ಅನ್ನು ತಾನೇ ಓವರ್‌ರೈಡ್ ಮಾಡುವುದಿಲ್ಲ. ಏನಾಗುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "A ಯ ಆವೃತ್ತಿ ರನ್ ಆಗುತ್ತದೆ, ಏಕೆಂದರೆ A ಅನ್ನು ಮೊದಲು ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ"
            },
            {
              "icon": "",
              "label": "ಎರಡೂ ಆವೃತ್ತಿಗಳು ಒಂದರ ನಂತರ ಒಂದರಂತೆ ರನ್ ಆಗುತ್ತವೆ"
            },
            {
              "icon": "",
              "label": "ಇದು ಕಂಪೈಲ್ ಆಗುತ್ತದೆ ಆದರೆ ಕರೆದಾಗ ಒಂದು ವಿನಾಯಿತಿಯನ್ನು (exception) ಎಸೆಯುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಕ್ಲಾಸ್ describe() ಅನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡದಿದ್ದರೆ ಒಂದು ಕಂಪೈಲ್ ದೋಷ"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); ಎಂದು ಬರೆಯಲಾಗಿದೆ ಆದರೆ ಫಲಿತಾಂಶವನ್ನು .collect() ಅಥವಾ .forEach() ನಂತಹ ಟರ್ಮಿನಲ್ ಆಪರೇಷನ್‌ಗೆ ಎಂದಿಗೂ ನಿಯೋಜಿಸಲಾಗಿಲ್ಲ. ಈ ಸಾಲು ಎಕ್ಸಿಕ್ಯೂಟ್ ಆದಾಗ ನಿಜವಾಗಿ ಏನಾಗುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "ಏನೂ ಇಲ್ಲ; ಪೈಪ್‌ಲೈನ್ ಎಂದಿಗೂ ರನ್ ಆಗುವುದಿಲ್ಲ"
            },
            {
              "icon": "",
              "label": "ಪ್ರತಿ ಎಲಿಮೆಂಟ್ ತಕ್ಷಣವೇ ಫಿಲ್ಟರ್ ಮತ್ತು ಮ್ಯಾಪ್ ಆಗುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಕೇವಲ ಫಿಲ್ಟರ್ ರನ್ ಆಗುತ್ತದೆ; ಮ್ಯಾಪ್ ಟರ್ಮಿನಲ್ ಆಪರೇಷನ್‌ಗಾಗಿ ಕಾಯುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "ಇದು IllegalStateException ಅನ್ನು ಎಸೆಯುತ್ತದೆ"
            }
          ]
        }
      ],
      "optionOrderVersion": "9d7b97ef6cccf4e2"
    }
  },
  "testNames": {
    "java-test": "ಜಾವಾ ಪರೀಕ್ಷೆ"
  }
}