diff --git a/index.html b/index.html
new file mode 100644
index 0000000..50bdbdc
--- /dev/null
+++ b/index.html
@@ -0,0 +1,3348 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ultimate Java Interview Cracker</title>
+    <style>
+        :root {
+            --primary: #6366f1;
+            --primary-dark: #4f46e5;
+            --bg-dark: #0f172a;
+            --bg-card: #1e293b;
+            --text-main: #f8fafc;
+            --text-muted: #94a3b8;
+            --accent: #22d3ee;
+            --success: #10b981;
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
+
+        body {
+            background-color: var(--bg-dark);
+            color: var(--text-main);
+            height: 100vh;
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+        }
+
+        /* --- Welcome Overlay --- */
+        #welcome-screen {
+            position: fixed;
+            top: 0; left: 0; width: 100%; height: 100%;
+            background: linear-gradient(135deg, #0f172a 0%, #1e1b4b 100%);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            flex-direction: column;
+            z-index: 1000;
+            transition: opacity 0.8s ease;
+        }
+        .welcome-content h1 { font-size: 3rem; margin-bottom: 20px; background: linear-gradient(to right, #818cf8, #22d3ee); -webkit-background-clip: text; color: transparent; }
+        .welcome-btn {
+            padding: 15px 40px;
+            font-size: 1.2rem;
+            background: var(--primary);
+            color: white;
+            border: none;
+            border-radius: 50px;
+            cursor: pointer;
+            transition: transform 0.2s, box-shadow 0.2s;
+            box-shadow: 0 0 20px rgba(99, 102, 241, 0.5);
+        }
+        .welcome-btn:hover { transform: scale(1.05); box-shadow: 0 0 30px rgba(99, 102, 241, 0.8); }
+
+        /* --- Main Layout --- */
+        header {
+            height: 70px;
+            background: var(--bg-card);
+            border-bottom: 1px solid #334155;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 0 2rem;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        }
+
+        .logo { font-weight: bold; font-size: 1.5rem; color: var(--accent); }
+
+        /* Controls Area */
+        .controls { display: flex; align-items: center; gap: 20px; }
+        
+        /* Toggle Switch */
+        .toggle-container { display: flex; align-items: center; gap: 10px; font-size: 0.9rem; }
+        .switch { position: relative; display: inline-block; width: 50px; height: 26px; }
+        .switch input { opacity: 0; width: 0; height: 0; }
+        .slider { position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0; background-color: #334155; transition: .4s; border-radius: 34px; }
+        .slider:before { position: absolute; content: ""; height: 20px; width: 20px; left: 3px; bottom: 3px; background-color: white; transition: .4s; border-radius: 50%; }
+        input:checked + .slider { background-color: var(--success); }
+        input:checked + .slider:before { transform: translateX(24px); }
+
+        /* --- Workspace --- */
+        .container { display: flex; height: calc(100vh - 70px); }
+
+        /* Sidebar */
+        .sidebar {
+            width: 350px;
+            background: #162032;
+            border-right: 1px solid #334155;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .search-box {
+            padding: 15px;
+            position: sticky;
+            top: 0;
+            background: #162032;
+            z-index: 10;
+        }
+        .search-box input {
+            width: 100%;
+            padding: 10px;
+            border-radius: 8px;
+            border: 1px solid #334155;
+            background: #0f172a;
+            color: white;
+            outline: none;
+        }
+
+        .question-list { list-style: none; }
+        .question-item {
+            padding: 15px 20px;
+            border-bottom: 1px solid #1e293b;
+            cursor: pointer;
+            transition: background 0.2s;
+            font-size: 0.95rem;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .question-item:hover { background: #1e293b; }
+        .question-item.active { background: rgba(99, 102, 241, 0.1); border-left: 4px solid var(--primary); }
+        .question-item .status { width: 10px; height: 10px; border-radius: 50%; background: #334155; }
+        .question-item.completed .status { background: var(--success); box-shadow: 0 0 5px var(--success); }
+
+        /* Main Content */
+        .content-area {
+            flex: 1;
+            padding: 40px;
+            overflow-y: auto;
+            background: radial-gradient(circle at top right, #1e293b 0%, #0f172a 40%);
+        }
+
+        #empty-state {
+            height: 100%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            flex-direction: column;
+            color: var(--text-muted);
+        }
+
+        .answer-card {
+            background: rgba(30, 41, 59, 0.7);
+            backdrop-filter: blur(10px);
+            border: 1px solid #334155;
+            border-radius: 16px;
+            padding: 30px;
+            max-width: 900px;
+            margin: 0 auto;
+            display: none; /* Hidden by default */
+            animation: slideIn 0.3s ease-out;
+        }
+
+        @keyframes slideIn { from { opacity: 0; transform: translateY(20px); } to { opacity: 1; transform: translateY(0); } }
+
+        .answer-card h2 { color: var(--accent); margin-bottom: 20px; font-size: 2rem; }
+        
+        .section-title {
+            text-transform: uppercase;
+            font-size: 0.75rem;
+            letter-spacing: 1px;
+            color: var(--text-muted);
+            margin-top: 20px;
+            margin-bottom: 10px;
+            font-weight: bold;
+        }
+
+        .explanation { font-size: 1.1rem; line-height: 1.7; color: #cbd5e1; margin-bottom: 20px; }
+        
+        .strategy-box {
+            background: linear-gradient(135deg, rgba(16, 185, 129, 0.1) 0%, rgba(6, 78, 59, 0.1) 100%);
+            border: 1px solid rgba(16, 185, 129, 0.2);
+            border-radius: 10px;
+            padding: 20px;
+            margin-top: 30px;
+        }
+        .strategy-box h3 { color: var(--success); font-size: 1rem; margin-bottom: 10px; display: flex; align-items: center; gap: 8px; }
+        
+        .code-block {
+            background: #000;
+            padding: 15px;
+            border-radius: 8px;
+            font-family: 'Courier New', Courier, monospace;
+            color: #a5f3fc;
+            margin: 15px 0;
+            border-left: 4px solid var(--accent);
+        }
+
+        /* --- Progress Bar --- */
+        .progress-container {
+            position: absolute;
+            bottom: 0;
+            left: 0;
+            width: 100%;
+            height: 4px;
+            background: #1e293b;
+        }
+        .progress-bar {
+            height: 100%;
+            background: linear-gradient(90deg, var(--primary), var(--accent));
+            width: 0%;
+            transition: width 0.3s ease;
+        }
+        .progress-text {
+            position: absolute;
+            right: 20px;
+            top: 25px;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+        /* --- Paste this at the bottom of your CSS --- */
+
+/* Mobile "App-Like" View */
+@media (max-width: 768px) {
+    .container {
+        position: relative;
+        overflow: hidden;
+    }
+
+    /* Sidebar takes full screen on mobile */
+    .sidebar {
+        width: 100%;
+        height: calc(100vh - 70px);
+        position: absolute;
+        z-index: 10;
+        transition: transform 0.3s ease-in-out;
+        transform: translateX(0); /* Visible by default */
+        border-right: none;
+    }
+
+    /* Content Area takes full screen on mobile but is hidden initially */
+    .content-area {
+        width: 100%;
+        height: calc(100vh - 70px);
+        position: absolute;
+        z-index: 20;
+        top: 0;
+        left: 0;
+        transform: translateX(100%); /* Hidden to the right by default */
+        transition: transform 0.3s ease-in-out;
+        padding: 20px;
+        background: var(--bg-dark); /* Solid background to cover list */
+    }
+
+    /* Active State: When reading an answer */
+    body.reading-mode .sidebar {
+        transform: translateX(-100%); /* Move list to left */
+    }
+    body.reading-mode .content-area {
+        transform: translateX(0); /* Bring answer to center */
+    }
+
+    /* Back Button Styling */
+    .back-btn {
+        display: flex !important; /* Visible only on mobile */
+        align-items: center;
+        gap: 8px;
+        margin-bottom: 20px;
+        background: #334155;
+        border: none;
+        padding: 10px 20px;
+        border-radius: 8px;
+        color: white;
+        font-weight: bold;
+        cursor: pointer;
+    }
+
+    /* Adjust fonts for phone */
+    .welcome-content h1 { font-size: 2rem; }
+    .answer-card h2 { font-size: 1.5rem; }
+    header { padding: 0 1rem; }
+    .logo { font-size: 1.2rem; }
+    .toggle-container span { font-size: 0.8rem; }
+}
+
+/* Hide back button on desktop */
+.back-btn {
+    display: none;
+}
+
+    </style>
+</head>
+<body>
+
+    <div id="welcome-screen">
+        <div class="welcome-content" style="text-align: center;">
+            <h1>Java Interview Mastery</h1>
+            <p style="color: #94a3b8; font-size: 1.2rem; margin-bottom: 40px; max-width: 600px;">
+                Master the easy questions, control the flow, and guide the interviewer exactly where you want them to go.
+            </p>
+            <button class="welcome-btn" onclick="startApp()">Let's Crack It</button>
+        </div>
+    </div>
+
+    <header>
+        <div class="logo">DevPrep <span style="font-size:0.8rem; color:#64748b">v1.0</span></div>
+        <div class="progress-text">Progress: <span id="progress-val">0</span>%</div>
+        <div class="controls">
+            <div class="toggle-container">
+                <span>English</span>
+                <label class="switch">
+                    <input type="checkbox" id="langToggle">
+                    <span class="slider"></span>
+                </label>
+                <span style="color: var(--success); font-weight: bold;">Hinglish</span>
+            </div>
+        </div>
+        <div class="progress-container">
+            <div class="progress-bar" id="progressBar"></div>
+        </div>
+    </header>
+
+    <div class="container">
+        <div class="sidebar">
+            <div class="search-box">
+                <input type="text" placeholder="Search questions..." id="searchInput" onkeyup="filterQuestions()">
+            </div>
+            <ul class="question-list" id="questionList">
+                </ul>
+        </div>
+
+        <div class="content-area">
+    <button class="back-btn" onclick="goBack()">
+        ← Back to Questions
+    </button>
+
+    <div id="empty-state">
+        <div style="font-size: 4rem; margin-bottom: 20px;">🚀</div>
+        <h2>Select a question</h2>
+        <p>Tap a question to reveal the answer.</p>
+    </div>
+    
+    <div id="answer-display" class="answer-card">
+        </div>
+</div>
+    </div>
+
+<script>
+    // --- Data Source ---
+    // Note: I have fully written out the first 10. 
+    // The architecture handles the rest—you just need to add the strings.
+    const questionsDB = [
+        {
+            id: 1,
+            title: "What is Functional Interface?",
+            eng: `A Functional Interface is an interface that contains exactly one abstract method. It can have any number of default or static methods, but only one abstract method. <br><br>Examples include <code>Runnable</code>, <code>Callable</code>, and <code>Comparator</code>. We use the <code>@FunctionalInterface</code> annotation to ensure this rule is followed.`,
+            hinglish: `Functional Interface wo interface hai jisme sirf <strong>ek hi abstract method</strong> hota hai. Isme default ya static methods kitne bhi ho sakte hain, par abstract method bas ek hi allowed hai.<br><br>Simple example: <code>Runnable</code> ya <code>Callable</code>. Hum <code>@FunctionalInterface</code> annotation use karte hain taaki galti se koi dusra method add na kar de.`,
+            strategy: `Use this to lead into **Streams**. Say: "The main reason these are so popular now is because they are the foundation of **Lambda Expressions** and the **Streams API** introduced in Java 8."`
+        },
+        {
+            id: 2,
+            title: "Whether Java is Interpreted or Compiled language?",
+            eng: `Java is a hybrid language; it is <strong>both</strong> compiled and interpreted. <br><br>First, the source code (.java) is **compiled** by javac into Bytecode (.class). Then, the JVM (Java Virtual Machine) **interprets** this bytecode and executes it on the specific hardware. JIT (Just In Time) compilers are used to optimize this interpretation speed.`,
+            hinglish: `Java actually <strong>dono</strong> hai. Pehle hum code ko **compile** karte hain (.class file banati hai jo bytecode hoti hai). <br><br>Fir jab hum run karte hain, to JVM us bytecode ko **interpret** karta hai machine code mein. Isliye hum kehte hain: "Write Once, Run Anywhere".`,
+            strategy: `End with: "The component responsible for executing this is the JVM, which relies on the **Classloader** to load these files." (This prompts the Classloader question).`
+        },
+        {
+            id: 3,
+            title: "What is Singleton class?",
+            eng: `A Singleton class is a class that allows only <strong>one instance</strong> to be created throughout the application's lifecycle. <br><br>We achieve this by making the constructor <code>private</code> and providing a static method (usually <code>getInstance()</code>) to return the single instance. It's often used for database connections or configuration settings.`,
+            hinglish: `Singleton class ka matlab hai ki pure application mein us class ka bas <strong>ek hi object</strong> ban sakta hai. <br><br>Iske liye hum constructor ko <code>private</code> bana dete hain taaki koi <code>new</code> keyword use na kar sake, aur ek static method dete hain jo wahi purana object return karta hai.`,
+            strategy: `Mention: "However, creating a perfect Singleton is tricky because of **Multithreading** and **Serialization** issues." (This baits the interviewer to ask about breaking Singletons).`
+        },
+        {
+            id: 4,
+            title: "What is the difference between throw vs throws?",
+            eng: `<code>throw</code> is used to explicitly throw an exception within a method body. <br><code>throws</code> is used in the method signature to declare that this method <em>might</em> throw an exception, so the caller must handle it.<br><br>Think of <code>throw</code> as an action (I am throwing this now) and <code>throws</code> as a warning (Watch out, this might happen).`,
+            hinglish: `<code>throw</code> hum tab use karte hain jab humein manually code ke andar se exception fekna ho. <br><code>throws</code> hum method ke naam ke aage likhte hain ye batane ke liye ki "Bhai, ye method exception de sakta hai, ise handle kar lena".`,
+            strategy: `Connect to Checked/Unchecked: "We usually use 'throws' for **Checked Exceptions** to enforce handling at compile time."`
+        },
+        {
+            id: 5,
+            title: "What is Object class?",
+            eng: `The Object class is the **root** or parent of all classes in Java. Every class directly or indirectly inherits from the Object class. <br><br>It provides common methods like <code>toString()</code>, <code>equals()</code>, <code>hashCode()</code>, and <code>wait()/notify()</code> that are available to every Java object.`,
+            hinglish: `Object class Java mein sabhi classes ka **Baap (Parent)** hai. Har class automatically Object class ko extend karti hai. <br><br>Isliye har object ke paas kuch common methods hote hain jaise <code>toString()</code> aur <code>equals()</code>.`,
+            strategy: `Pivot to Hashcode: "The most critical contract we override from the Object class is between **equals() and hashCode()**."`
+        },
+        {
+            id: 6,
+            title: "What is the difference between Mutable vs Immutable?",
+            eng: `<strong>Mutable</strong> objects can be changed after creation (like <code>StringBuilder</code> or standard getters/setters). <br><strong>Immutable</strong> objects cannot be modified once created. If you try to change them, a new object is created (like <code>String</code>). Immutable objects are great for thread safety.`,
+            hinglish: `<strong>Mutable</strong> wo objects hain jinki value banne ke baad change ho sakti hai. <br><strong>Immutable</strong> wo hain jo ek baar ban gaye to change nahi ho sakte (jaise <code>String</code>). Agar change karoge to naya object ban jayega.`,
+            strategy: `Lead to String: "The most famous example of immutability in Java is the **String class**, but there is a specific reason why it was made immutable."`
+        },
+        {
+            id: 7,
+            title: "What is HQL (Hibernate Query Language)?",
+            eng: `HQL is an object-oriented query language, similar to SQL, but instead of operating on tables and columns, it operates on **Classes and Properties**. <br><br>It is database independent. You write the query once using class names, and Hibernate translates it to the specific SQL for Oracle, MySQL, etc.`,
+            hinglish: `HQL SQL jaisa hi hai, bas fark ye hai ki SQL database ke tables pe chalta hai, aur HQL humari Java **Classes aur objects** pe chalta hai. <br><br>Fayda ye hai ki agar database change bhi ho jaye, to HQL query change nahi karni padti.`,
+            strategy: `Contrast: "While HQL is powerful, for complex performance tuning, we sometimes still need native SQL or the **Criteria API**."`
+        },
+        {
+            id: 8,
+            title: "How to create Immutable class in Java?",
+            eng: `To create an immutable class: <br>1. Declare the class as <code>final</code> so it can't be extended.<br>2. Make all fields <code>private</code> and <code>final</code>.<br>3. Do NOT provide Setter methods.<br>4. Initialize fields via constructor only.<br>5. If a field holds a mutable object, return a clone/copy in the getter, not the original.`,
+            hinglish: `Immutable class banane ke liye 5 rules hain: <br>1. Class ko <code>final</code> banao (koi inherit na kare).<br>2. Variables ko <code>private final</code> banao.<br>3. Setters mat banao.<br>4. Constructor ke through value set karo.<br>5. Agar koi list ya object field hai, to getter mein uski copy return karo, original nahi.`,
+            strategy: `Mention HashMap: "We do this heavily when creating keys for **HashMaps**, to prevent data loss."`
+        },
+        {
+            id: 9,
+            title: "What is final keyword?",
+            eng: `The <code>final</code> keyword helps restrict usage: <br>1. **Variable:** Value cannot be changed (constant).<br>2. **Method:** Cannot be Overridden by child classes.<br>3. **Class:** Cannot be Inherited (extended).`,
+            hinglish: `<code>final</code> ka matlab hai "Bas, ye final hai": <br>1. **Variable:** Value change nahi hogi.<br>2. **Method:** Child class isko change (override) nahi kar sakti.<br>3. **Class:** Iska koi child nahi ban sakta (inheritance band).`,
+            strategy: `Differentiation: "It is often confused with **finally** (exception handling) and **finalize** (garbage collection), but they are totally different."`
+        },
+        {
+            id: 10,
+            title: "What is static keyword?",
+            eng: `<code>static</code> implies that a member belongs to the **Class** rather than a specific instance (object). <br><br>Static variables are shared among all objects. Static methods can be called without creating an object of the class. They are loaded into memory only once.`,
+            hinglish: `<code>static</code> ka matlab hai wo chiz **Class ki hai**, object ki nahi. <br><br>Static variable ki value sab objects ke liye same rehti hai. Static method ko call karne ke liye <code>new Class()</code> karne ki zarurat nahi padti, direct ClassName se call kar sakte hain.`,
+            strategy: `Memory Tip: "Since static members belong to the class, they are stored in a special memory area called **Metaspace** (formerly PermGen)." (Leads to Memory/Metaspace questions).`
+        },  
+        {
+            id: 11,
+            title: "What is the difference between method Overloading and Overriding?",
+            eng: `<strong>Method Overloading</strong> happens within the same class. It occurs when two methods have the same name but different parameters (different type or number of arguments). It is an example of <em>Compile-time Polymorphism</em>.<br><br><strong>Method Overriding</strong> happens between a Parent and Child class (Inheritance). The method signature (name and parameters) must be exactly the same. The child class gives its own specific implementation. It is <em>Runtime Polymorphism</em>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Overloading:</em> Think of a 'Payment' system. You can <code>pay(Cash)</code>, <code>pay(CreditCard)</code>, or <code>pay(UPI, MobileNumber)</code>. The action is the same (Pay), but the inputs differ.<br>
+            <em>Overriding:</em> Think of a Father and Son. The Father has a method <code>drive()</code> (drives a vintage Scooter). The Son inherits this but overrides <code>drive()</code> to drive a Sports Car. The action is the same, but the implementation changed in the next generation.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Overloading:</em> A Search bar. You can <code>search("Shoes")</code> or <code>search("Shoes", "Nike")</code>.<br>
+            <em>Overriding:</em> A 'Notification' system. The generic method is <code>sendAlert()</code>. The 'EmailService' subclass sends an Email, while the 'SMSService' subclass sends a Text.`,
+            hinglish: `<strong>Overloading</strong> ka matlab hai ek hi class mein same naam ke methods hona, bas unke parameters alag hone chahiye. Ye <em>Compile-time</em> pe decide hota hai.<br><br><strong>Overriding</strong> tab hota hai jab Child class Parent class ke method ko badal deti hai (Inheritance). Naam aur parameters bilkul same hone chahiye. Ye <em>Runtime</em> pe decide hota hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Overloading:</em> Socho Amazon Pay. Method same hai 'Pay', par kabhi aap <code>pay(Card)</code> karte ho, kabhi <code>pay(UPI)</code>. Input alag hai, kaam wahi hai.<br>
+            <em>Overriding:</em> Socho Baap aur Beta. Papa ke paas method tha <code>drive()</code> (wo purana Scooter chalate the). Bete ne wo method inherit kiya par usne <code>drive()</code> ko override karke Sports Car chalana shuru kar diya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Overloading:</em> Restaurant Menu. <code>order("Pizza")</code> ya fir <code>order("Pizza", "Extra Cheese")</code>.<br>
+            <em>Overriding:</em> Bank Interest. RBI ne rule banaya <code>getInterest()</code>. SBI ne use override karke 5% diya, aur HDFC ne override karke 6% diya.`,
+            strategy: `Lead with: "The key difference is when the binding happens. Overloading is static binding, while Overriding is dynamic binding." Then pause. This often leads them to ask "What are Covariant return types?" or "Can we override static methods?"`
+        },
+        {
+            id: 12,
+            title: "What is @SpringBootApplication annotation?",
+            eng: `This is the most essential annotation in a Spring Boot application. It is actually a combination of three distinct annotations: <br>1. <strong>@Configuration:</strong> Marks the class as a source of bean definitions.<br>2. <strong>@EnableAutoConfiguration:</strong> Tells Spring Boot to start adding beans based on classpath settings (e.g., if it sees 'spring-web', it sets up Tomcat automatically).<br>3. <strong>@ComponentScan:</strong> Tells Spring to look for other components, configurations, and services in the current package and sub-packages.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            Think of the <strong>Power Button</strong> on your smartphone. When you press it, it doesn't just turn on the screen; it boots the OS, initializes the network, checks the battery, and loads the UI. One button triggers a complex chain of setup events.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            A <strong>Swiss Army Knife</strong>. It looks like one tool, but inside it includes a knife, a screwdriver, and a bottle opener. Similarly, <code>@SpringBootApplication</code> looks like one annotation but packs three powerful configurations inside.`,
+            hinglish: `Ye Spring Boot ka sabse main annotation hai. Asal mein ye 3 annotations ka mixture hai: <br>1. <strong>@Configuration:</strong> Ye batata hai ki yahan beans define kiye gaye hain.<br>2. <strong>@EnableAutoConfiguration:</strong> Ye Spring Boot ka magic hai. Agar aapne dependencies mein 'Hibernate' dala hai, to ye apne aap database connect kar lega.<br>3. <strong>@ComponentScan:</strong> Ye Spring ko bolta hai ki "Jao, is package ke andar dhoondo ki kaunsi classes hain jinhe load karna hai".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            Phone ka <strong>Power Button</strong>. Jab aap use dabate hain, wo sirf screen on nahi karta, wo background mein OS load karta hai, network dhoondta hai, SIM check karta hai. Ek button, hazaron kaam.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Swiss Army Knife</strong> (Multi-tool). Dikhta ek chaku hai, par usme penchkas (screwdriver) aur opener bhi hota hai. Waise hi ye annotation dikhta ek hai, par kaam 3 karta hai.`,
+            strategy: `Close with: "This annotation is what makes Spring Boot 'opinionated'. It assumes defaults so we don't have to write XML configuration." This invites questions about "How to exclude specific auto-configurations?"`
+        },
+        {
+            id: 13,
+            title: "What is the difference between Checked and Unchecked exception?",
+            eng: `<strong>Checked Exceptions</strong> are checked at <em>Compile-time</em>. The Java compiler forces you to handle them (using try-catch or throws). If you don't, the code won't compile. These represent anticipated problems (e.g., File missing, SQL error).<br><br><strong>Unchecked Exceptions</strong> occur at <em>Runtime</em>. The compiler ignores them. They usually happen due to bad programming logic (e.g., NullPointer, ArrayIndexOfBounds). You aren't forced to handle them, but you should fix the logic.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Checked:</em> <strong>Passport Check at Airport.</strong> You cannot board the plane (compile/run) unless you show the passport. The authorities force you to handle this requirement before proceeding.<br>
+            <em>Unchecked:</em> <strong>Tire Puncture.</strong> This happens suddenly while driving (Runtime). No one checks your tires every 5 minutes, but if it happens, you have to stop and fix it.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Checked:</em> <strong>Exam Hall Ticket.</strong> The invigilator checks this before you enter. No ticket, no exam.<br>
+            <em>Unchecked:</em> <strong>Pen running out of ink.</strong> This happens while writing the exam. You didn't plan for it, but now you must handle it (borrow a pen) or fail.`,
+            hinglish: `<strong>Checked Exceptions</strong> wo hoti hain jo Compiler pakad leta hai. Code compile hi nahi hoga jab tak aap <code>try-catch</code> nahi lagate. Ye wo problems hain jo hum expect karte hain (jaise File nahi mili).<br><br><strong>Unchecked Exceptions</strong> wo hain jo <em>Runtime</em> pe aati hain. Compiler inhe ignore karta hai. Ye usually programmer ki galti se hoti hain (jaise kisi null cheez ko use karna).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Checked:</em> <strong>Airport Security.</strong> Plane mein baithne se pehle checking hoti hi hai. Agar Boarding Pass nahi hai, to aage nahi ja sakte. Ye mandatory hai.<br>
+            <em>Unchecked:</em> <strong>Tyre Puncture.</strong> Ye gadi chalate waqt achanak hota hai. Koi pehle se check nahi kar sakta ki raste mein keel hai ya nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Checked:</em> <strong>Exam Admit Card.</strong> Teacher pehle check karega. Nahi hai to entry band.<br>
+            <em>Unchecked:</em> <strong>Pen ki siyahi (ink) khatam hona.</strong> Ye likhte-likhte achanak ho jata hai. Iska pehle se koi warning nahi milta.`,
+            strategy: `Mention: "In modern Spring Boot development, we often use Global Exception Handlers (@ControllerAdvice) to manage these cleanly." This guides them to ask about Exception Handling in Spring.`
+        },
+        {
+            id: 14,
+            title: "What is N+1 problem?",
+            eng: `The N+1 problem is a performance issue in ORM tools like Hibernate. It happens when you fetch a list of Parent entities, and then for <em>each</em> parent, Hibernate executes a separate query to fetch its Child entities.<br><br>If you have 1 Parent query and 100 records (N=100), Hibernate executes 1 query for the list + 100 queries for the details. Total 101 queries. This kills database performance.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            Imagine you are a <strong>Pizza Delivery Driver</strong>. You have 10 pizzas for 10 houses in the same neighborhood.<br>
+            <em>N+1 way:</em> You drive to the store, pick up Pizza 1, deliver it. Drive back to the store, pick up Pizza 2, deliver it. You do this 10 times. (Very slow).<br>
+            <em>Optimized way:</em> You pick up all 10 pizzas at once and deliver them in one go.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Teacher grading papers.</strong><br>
+            <em>N+1 way:</em> Teacher calls Student 1, checks copy, sends him back. Calls Student 2, checks copy, sends back.<br>
+            <em>Optimized way:</em> Teacher collects all copies at once (1 query) and checks them continuously.`,
+            hinglish: `N+1 problem Hibernate ki sabse badi performance issue hai. Ye tab hoti hai jab aap ek List nikalte ho, aur fir har item ke liye Hibernate database se dubara data maangta hai.<br><br>Agar aapne 100 Students nikale (1 query), aur har Student ka Address maanga, to Hibernate 100 alag queries chalayega Address ke liye. Total 101 queries ho jayengi. Database slow ho jayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            Socho aap <strong>Pizza Delivery Boy</strong> ho. 10 gharon mein pizza dena hai.<br>
+            <em>N+1 tarika:</em> Aap dukan gaye, 1 pizza uthaya, deliver kiya. Wapas dukan gaye, dusra uthaya, deliver kiya. Bahut time lagega.<br>
+            <em>Sahi tarika (Join Fetch):</em> Sare 10 pizza ek saath utha liye aur line se sabko de diye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Kirana Store wala.</strong><br>
+            <em>N+1 tarika:</em> Aapne chini maangi, wo godown gaya lekar aaya. Fir aapne chawal maanga, wo fir godown gaya. <br>
+            <em>Sahi tarika:</em> Aapne list di, wo ek baar godown gaya aur sab lekar aa gaya.`,
+            strategy: `End with: "We solve this using 'Join Fetch' in HQL or Entity Graphs." This proves you know the solution, not just the problem.`
+        },
+        {
+            id: 15,
+            title: "What is Serialization?",
+            eng: `Serialization is the process of converting a Java object into a byte stream (a sequence of 0s and 1s). This is done so the object can be saved to a file, stored in a database, or sent over a network.<br><br>Deserialization is the reverse process: recreating the Java object from the byte stream. To make a class serializable, it must implement the <code>Serializable</code> marker interface.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>IKEA Furniture.</strong> When you buy a table, it is "Serialized" (dismantled) into a flat box so it can be shipped easily. When you reach home, you "Deserialize" it by assembling it back into a table.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Freezing Food.</strong> You cook pasta (Object). To store it for later, you freeze it (Serialization). It changes state to a solid block. Later, you microwave it (Deserialization) to bring it back to its original edible state.`,
+            hinglish: `Serialization ka matlab hai Java ke Object ko 'Byte Stream' (0 aur 1 ki series) mein convert karna. Ye hum tab karte hain jab humein Object ko file mein save karna ho ya internet pe bhejna ho.<br><br>Deserialization iska ulta hai—wapas bytes se Object banana. Iske liye humein <code>Serializable</code> interface implement karna padta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>IKEA ka Furniture.</strong> Jab aap table kharidte ho, wo usse khol kar (dismantle karke) box mein pack kar dete hain (Serialization) taaki wo car mein fit aa jaye. Ghar aakar aap use wapas jod lete ho (Deserialization).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Khana Freeze karna.</strong> Aapne khana banaya (Object). Use lambe samay tak rakhne ke liye Freeze kar diya (state change kar di). Jab khana ho, to Garam (Deserialize) kiya aur wo wapas waisa hi ho gaya.`,
+            strategy: `Mention: "If we don't want to save a specific field, like a password, we use the **transient** keyword." This almost guarantees the next question will be about the transient keyword.`
+        },
+        {
+            id: 16,
+            title: "What is Marker interface?",
+            eng: `A Marker Interface is an interface that has <strong>no methods and no constants</strong>. It is empty. It basically acts as a "tag" or a "signal" to the JVM or Compiler that the class implementing it belongs to a special category.<br><br>Common examples are <code>Serializable</code>, <code>Cloneable</code>, and <code>Remote</code>. However, since Java 5, Annotations are preferred over Marker Interfaces.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>'Fragile' Sticker on a Box.</strong> The sticker doesn't do anything itself (it has no methods). But it tells the courier guy (JVM), "Handle this box with care."<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>VIP Wristband in a Club.</strong> The wristband doesn't give you muscles. But when the bouncer (JVM) sees it, he lets you enter the VIP area. It just marks you as special.`,
+            hinglish: `Marker Interface wo interface hai jiske andar <strong>kuch nahi hota</strong>—na koi method, na koi variable. Ye khaali hota hai. Ye bas JVM ko ek "Signal" dene ke liye use hota hai ki "Bhai, ye class special hai".<br><br>Example: <code>Serializable</code>, <code>Cloneable</code>. Aajkal hum iski jagah Annotations use karte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Box pe 'Fragile' ka sticker.</strong> Sticker khud kuch nahi karta. Par delivery boy (JVM) jab sticker dekhta hai, to samajh jata hai ki is dabbe ko aaram se uthana hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Club ka VIP Band.</strong> Haath mein band hone se aap badal nahi jate, par Guard (JVM) jab wo band dekhta hai to aapko VIP treatment deta hai.`,
+            strategy: `Say: "It represents a 'Is-A' relationship without adding behavior. But now in Spring, we prefer using Annotations like @Component to mark classes."`
+        },
+        {
+            id: 17,
+            title: "Why do we need Interface and Abstract Class in Java?",
+            eng: `<strong>Interface</strong> is used for "Capabilities" (What can you do?). It provides 100% abstraction (before Java 8). It allows Multiple Inheritance. Use it when unrelated classes need to do the same thing (e.g., Plane and Bird both <code>Flyable</code>).<br><br><strong>Abstract Class</strong> is used for "Identity" (What are you?). It can hold common state (variables) and behavior for child classes. Use it when classes are closely related (e.g., Dog and Cat both extend <code>Animal</code>).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Interface (USB Port):</em> A Mouse, Keyboard, and Printer are totally different, but they all fit into a USB port. They agree to a common "contract" of connection.<br>
+            <em>Abstract Class (Vehicle):</em> Car and Truck are both Vehicles. They share common engine logic, wheels logic, but implement 'loadCapacity' differently.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Interface (Remote Control):</em> Sony, LG, and Samsung remotes look different, but buttons (Volume Up, Power) work the same way. That's an interface.<br>
+            <em>Abstract Class (Employee):</em> Manager and Developer are both Employees. They share 'Name' and 'ID' (common code), but 'CalculateBonus()' is different.`,
+            hinglish: `<strong>Interface</strong> batata hai ki aap "Kya kar sakte ho" (Capabilities). Example: Udna (Flyable). Kabootar bhi udta hai, Plane bhi. Dono ka rishta nahi hai par capability same hai.<br><br><strong>Abstract Class</strong> batata hai ki aap "Kya ho" (Identity). Example: Animal. Kutta aur Billi dono janwar hain, unka khoon, saans lene ka tarika (common code) same hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Interface (USB Port):</em> Mouse, Keyboard, Printer sab alag hain, par sab USB port mein lag jate hain. Kyunki unhone USB ka contract sign kiya hai.<br>
+            <em>Abstract Class (Gadi/Vehicle):</em> Car aur Truck dono gadi hain. Dono mein Engine, Steering (common chizein) hoti hain jo dubara banane ki zarurat nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Interface (Bijli ka Plug):</em> Aap usme TV lagao ya Press, socket ko farak nahi padta. Interface standard hai.<br>
+            <em>Abstract Class (Insaan):</em> Hum sab Insaan hain. Sabke paas dil aur dimaag (common code) hai. Par 'Kaam' sab alag karte hain (Abstract method).`,
+            strategy: `Pivot: "With Java 8, Interfaces can now have Default methods, which blurs the line between them. This allows us to evolve interfaces without breaking existing code."`
+        },
+        {
+            id: 18,
+            title: "Can we have concrete methods in Java interface?",
+            eng: `Historically, No. But since <strong>Java 8</strong>, Yes! We can have <code>default</code> and <code>static</code> methods in interfaces.<br><br>This was introduced to support backward compatibility. Imagine if Java added a new abstract method to the <code>Collection</code> interface; every single class in the world implementing Collection would break. By making it a <code>default</code> method (like <code>stream()</code>), old code keeps working while new code gets the feature.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Mobile OS Update.</strong> When Apple releases a new iOS update, your old phone gets new features (like a new Calculator app) automatically without you buying new hardware. That's a 'default' method added to your existing device.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Standard Car Features.</strong> Earlier, AC was a luxury. Now, every car model (Class) gets AC as a 'default' feature from the manufacturer (Interface). You don't have to install it yourself.`,
+            hinglish: `Pehle (Java 7 tak) mana tha. Par <strong>Java 8</strong> ke baad "Haan". Hum <code>default</code> aur <code>static</code> methods bana sakte hain.<br><br>Ye isliye kiya gaya taaki purana code kharab na ho. Agar Java walon ne <code>Collection</code> interface mein naya method dala hota, to sari purani classes error deti. <code>default</code> method se sabko naya feature mil gaya bina code tode.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Phone Update.</strong> Jab naya Android update aata hai, to purane phone mein bhi naye features aa jate hain bina phone badle. Ye 'default method' jaisa hai—sabko free mein mil gaya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Society ke Rules.</strong> Society ne naya rule banaya "Sabke ghar Free WiFi". Jinhone khud lagwaya hai (Override) wo apna use karein, jinke paas nahi hai wo society ka default wala use karein.`,
+            strategy: `Warning: "However, we cannot override the methods of the Object class (like toString) as default methods in an interface. That's a strict rule."`
+        },
+        {
+            id: 19,
+            title: "What is Encapsulation?",
+            eng: `Encapsulation is the mechanism of wrapping data (variables) and code (methods) together as a single unit. It is primarily used for <strong>Data Hiding</strong> and Security.<br><br>We achieve this by making variables <code>private</code> and providing <code>public</code> Getter/Setter methods. This gives us control. For example, in the setter, we can add logic to prevent negative numbers for age.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Capsule Medicine.</strong> The medicine powder (variables) is hidden inside a plastic shell (class). You consume the capsule (public method), but you cannot touch the chemicals directly.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Car Engine.</strong> The complex engine wires (private data) are hidden under the hood. You only interact with the Steering Wheel and Pedals (public methods). You can't directly pour petrol into the cylinders while driving.<br><br>
+            <strong>Real Life Example 3:</strong><br>
+            <strong>ATM Machine.</strong> Cash is inside the box. You cannot grab it directly. You must use the keypad (public interface) to validate your PIN before the machine gives you money.`,
+            hinglish: `Encapsulation ka matlab hai data (variables) aur code (methods) ko ek box mein band karna. Iska main maqsad hai <strong>Suraksha (Security)</strong>.<br><br>Hum variables ko <code>private</code> bana dete hain taaki koi bahar se direct change na kar sake. Sirf <code>public</code> methods ke through hi access milega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Dawayi ka Capsule.</strong> Asli dawai (chemical) ek plastic cover ke andar hoti hai. Aap capsule khate ho, chemical ko haath nahi lagate. Chemical safe rehta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>ATM Machine.</strong> Paise machine ke andar hain (Private data). Aap seedha haath daal ke paise nahi nikal sakte. Aapko button dabane padenge (Public method) aur PIN daalna padega.<br><br>
+            <strong>Real Life Example 3:</strong><br>
+            <strong>School Bag.</strong> Aapka lunch box aur books bag ke andar (Private) hain. Zip band hai. Koi bahar se nahi dekh sakta jab tak aap khol ke na dikhao (Getter method).`,
+            strategy: `Say: "It also helps in making a class 'Read-Only' or 'Write-Only' by omitting getters or setters. It creates a controlled environment for data."`
+        },
+        {
+            id: 20,
+            title: "What is Abstraction?",
+            eng: `Abstraction means <strong>hiding the internal complexity</strong> and showing only the essential functionality to the user. It focuses on "What it does" rather than "How it does it".<br><br>In Java, we achieve abstraction using <strong>Abstract Classes</strong> (0-100% abstraction) and <strong>Interfaces</strong> (100% abstraction). It reduces complexity for the end-user.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Driving a Car.</strong> You know that pressing the accelerator increases speed. You don't need to know how the fuel injects, how the pistons move, or how the combustion happens. The complexity is abstracted away.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Coffee Machine.</strong> You press the "Cappuccino" button. You get coffee. You don't care about the boiler pressure, water temperature, or grinding mechanism inside. You just want the result.<br><br>
+            <strong>Real Life Example 3:</strong><br>
+            <strong>Sending an Email.</strong> You type and hit Send. You don't know TCP/IP protocols, DNS lookups, or server routing. That complexity is hidden.`,
+            hinglish: `Abstraction ka matlab hai "Faltu ki details chupana aur sirf kaam ki cheez dikhana". User ko bas result se matlab hai, process se nahi.<br><br>Java mein hum ye <strong>Abstract Class</strong> aur <strong>Interface</strong> se karte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Car chalana.</strong> Aap accelerator dabate ho gadi bhagti hai. Aapko ye janne ki zarurat nahi ki engine mein petrol kaise jala ya piston kaise ghuma. Wo detail chupi hui hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Bijli ka Switch.</strong> Aap switch on karte ho, light jalti hai. Piche taar kaise jude hain, power plant se bijli kaise aayi, ye sab aapse chupa hua hai.<br><br>
+            <strong>Real Life Example 3:</strong><br>
+            <strong>Google Search.</strong> Aapne type kiya aur enter mara. Google ke servers ne kaise dhoonda, ye complex logic aapse hidden hai. Aapko bas answer mila.`,
+            strategy: `Differentiate: "While Encapsulation hides data (security), Abstraction hides complexity (design). They often go hand-in-hand."`
+        },
+        {
+            id: 21,
+            title: "What is Inheritance?",
+            eng: `Inheritance is a fundamental OOP concept where one class (Child/Subclass) acquires the properties and behaviors of another class (Parent/Superclass). It promotes **Code Reusability** and creates an **"Is-A"** relationship.<br><br>We use the <code>extends</code> keyword for classes and <code>implements</code> for interfaces. It allows us to write common code once in the parent and use it everywhere in child classes.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Genetics (DNA).</strong> You inherit features like eye color or height from your parents. You didn't invent them; you reused their genetic code. You are a "Child" class extending the "Parent" class.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Mobile Phones.</strong> 'iPhone 15' inherits features from 'iPhone 14' (like the OS structure, face ID logic) and adds new features (Titanium body). It extends the previous version rather than building from scratch.`,
+            hinglish: `Inheritance ka matlab hai "Viraasat". Jab ek Child class apne Parent class ki properties aur methods ko copy/use kar leti hai. Iska main fayda hai **Code Reusability**—ek baar likho, baar baar use karo.<br><br>Hum <code>extends</code> keyword use karte hain. Ye **"Is-A"** rishta banata hai (e.g., Dog IS-A Animal).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>DNA/Khandaan.</strong> Aapki aankhon ka rang ya height aapke mata-pita se milti hai. Aapne wo khud nahi banaya, aapne bas unka code (DNA) inherit kiya hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Gadi ke Models.</strong> Maruti Swift ka naya model purane model ke engine aur design ko inherit karta hai, aur bas naye features (jaise sunroof) add karta hai. Pura wheel dubara invent nahi karte.`,
+            strategy: `Lead with: "While it enables reusability, overuse of inheritance creates **Tight Coupling**. That's why we often prefer **Composition over Inheritance**." (This is a pro-level statement).`
+        },
+        {
+            id: 22,
+            title: "Can static methods be abstract in Java?",
+            eng: `**No, absolutely not.**<br><br>Reason 1: **Logic Clashes.** Abstract methods *must* be overridden by the child class to provide functionality. Static methods belong to the class and *cannot* be overridden (they are hidden, not overridden).<br>Reason 2: **Invocation.** Static methods are called using the Class Name without creating an object. If a method is abstract, it has no body code. If you call <code>ClassName.abstractStaticMethod()</code>, there is no code to execute! It would crash immediately.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Blueprint vs Actual House.</strong> An abstract method is like a "Place for a door" on a blueprint. You can't open that door until the house is built. Static means "The Architect's Office". You can't say "Open the door in the Architect's office" if the door exists only on paper.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ghosts.</strong> Abstract methods are like ghosts—they have no body. Static methods are physical billboards. You cannot have a billboard that is invisible (no body).`,
+            hinglish: `**Nahi, bilkul nahi.**<br><br>Wajah 1: Abstract method wo hota hai jise Child class ko override karna PADTA hai. Par Static method ko override nahi kiya ja sakta (wo class se juda hota hai).<br>Wajah 2: Static method ko hum bina object banaye call karte hain. Agar method abstract hai (matlab khali hai), aur humne use call kar diya, to run kya hoga? Kuch hai hi nahi wahan! Isliye Java iski permission nahi deta.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Khayali Pulao.</strong> Abstract method ek 'Khayali Pulao' hai (sirf socha hai, bana nahi). Static method ek 'Dukan' hai. Aap khayali pulao dukan pe nahi bech sakte.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Adha-adhura Niyam.</strong> Sarkar ne rule banaya "Tax pay karo" (Static rule), par ye nahi bataya kaise (Abstract). Aisa rule lagu nahi ho sakta.`,
+            strategy: `Pivot to Overriding: "Since we can't override static methods, if we declare a static method with the same name in a child class, it is called **Method Hiding**, not Overriding."`
+        },
+        {
+            id: 23,
+            title: "What is @Override annotation in Java?",
+            eng: `The <code>@Override</code> annotation is a safety check provided by the compiler. It tells the compiler: "I intend to override a method from the parent class."<br><br>If you make a mistake (like a typo in the method name or wrong parameter types), the compiler will throw an error immediately. Without this annotation, the compiler might think you are creating a *new* method instead of overriding, leading to bugs that are hard to find.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Spell Checker.</strong> Writing code without <code>@Override</code> is like writing an essay without spell-check. If you type "Helo" instead of "Hello", no one warns you until you read it later. <code>@Override</code> is the red line that warns you instantly.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>GPS Navigation.</strong> If you miss a turn, GPS says "Rerouting". If you didn't have GPS (Annotation), you would keep driving on the wrong road thinking you are going correctly.`,
+            hinglish: `<code>@Override</code> ek safety guard hai. Ye Compiler ko batata hai ki "Main Parent class ka method change karne wala hoon".<br><br>Agar aapne spelling mistake kar di (jaise <code>run()</code> ki jagah <code>runn()</code> likh diya), to Compiler turant error dega. Agar ye annotation nahi lagaya, to Compiler sochega ki aapne koi naya method banaya hai, aur code galat chalega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Form bharna.</strong> Agar form mein 'Name' ki jagah galti se 'Nmae' likh diya, to computer error dega. <code>@Override</code> wahi error checker hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Signature Match.</strong> Bank mein check pe sign karte waqt agar sign match nahi hua to cashier rok deta hai. Ye annotation wahi cashier hai jo check karta hai ki aap sahi method copy kar rahe ho ya nahi.`,
+            strategy: `Say: "It is considered a best practice to always use it. It prevents 'Accidental Overloading' where you meant to override but changed the arguments by mistake."`
+        },
+        {
+            id: 24,
+            title: "What are the new features of Java 8?",
+            eng: `Java 8 was the biggest update in Java history. It shifted Java from purely OOP to **Functional Programming**. Key features include:<br>1. **Lambda Expressions:** Anonymous functions (coding with less boilerplate).<br>2. **Streams API:** For processing collections efficiently.<br>3. **Optional Class:** To handle NullPointerExceptions.<br>4. **Default & Static methods** in Interfaces.<br>5. **Date & Time API:** A new, immutable API (LocalDate).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Smartphones (Touchscreen era).</strong> Before Java 8 (Keypad phones), doing things took many clicks. Java 8 (iPhone/Android) introduced shortcuts and swipes (Lambdas) that made life fast and smooth.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ordering Food.</strong> Old Java: Go to shop, order, wait, eat. (Imperative). Java 8: Use Swiggy/Zomato. Just click "Reorder". (Declarative/Functional).`,
+            hinglish: `Java 8 Java ke itihas ka sabse bada update tha. Isne Java ko modern banaya. Main features hain:<br>1. **Lambda Expressions:** Code chota karne ka tarika.<br>2. **Streams API:** List aur data ko filter/map karne ka naya tarika.<br>3. **Optional Class:** Null error se bachne ke liye.<br>4. **Default Methods:** Interface ke andar body wala method.<br>5. **New Date Time API:** Purana Date class kharab tha, ye naya aur acha hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Manual vs Automatic Car.</strong> Java 7 Manual car thi—gear khud badlo (loop khud likho). Java 8 Automatic car hai—bas accelerator dabao (Stream API use karo), baki gadi khud karegi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Telegram vs Postcard.</strong> Pehle chitti likhte the (Boilerplate code). Ab WhatsApp pe emoji bhejte hain (Lambda expression). Kaam wahi hai, par fast hai.`,
+            strategy: `The interviewer WILL ask about one of these next. Guide them: "My personal favorite is the **Streams API** because it drastically reduced the lines of code I write for loop operations."`
+        },
+        {
+            id: 25,
+            title: "What is Streams API?",
+            eng: `Streams API is used to process collections of objects (like Lists or Sets) in a functional and declarative way. It allows operations like **Filter, Map, Reduce, and Sort**.<br><br>Unlike a Collection (which stores data), a Stream does not store data; it moves data from a source through a pipeline of computational operations. It supports parallel processing easily.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Water Purification System (RO).</strong> The water tank is the Collection (Source). The pipes are the Stream. The filters (sediment, carbon, UV) are the operations (filter/map). The clean water in your glass is the result (collect). The water flows through; the pipe doesn't hold it.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Assembly Line.</strong> A car factory. Raw metal (Source) moves on a conveyor belt (Stream). Robots paint it (Map), check quality (Filter), and assemble it. Finally, a car comes out.`,
+            hinglish: `Streams API Lists ya data ko process karne ka ek modern tarika hai. Isme hum loops (for-loop) nahi lagate, balki functions use karte hain jaise Filter (chhatna), Map (badalna), aur Collect (jama karna).<br><br>Stream data store nahi karta, bas data ko ek pipeline se guzaarta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Falo ka Juice nikalna.</strong> Tokri mein Fal hain (Collection). Aapne unhe machine mein daala (Stream). Machine ne chilka hataya (Filter), juice banaya (Map), aur glass mein bhara (Collect).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Security Check.</strong> Airport pe line (Stream) lagi hai. Guard ne ticket check kiya (Filter), bag scan kiya (Map), aur aap plane mein gaye (Terminal operation).`,
+            strategy: `Mention: "Streams have intermediate operations (lazy) and terminal operations (eager). Nothing happens until a terminal operation like .collect() or .count() is called."`
+        },
+        {
+            id: 26,
+            title: "What is Optional class?",
+            eng: `<code>Optional</code> is a container object used to contain not-null objects. It was introduced to avoid the infamous **NullPointerException**.<br><br>Instead of returning <code>null</code>, a method returns an <code>Optional</code>. The caller is forced to check if the value is present using methods like <code>isPresent()</code>, <code>orElse()</code>, or <code>ifPresent()</code>. It makes the code more readable and safe.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Courier Delivery Box.</strong> When you order something, you get a box. The box might contain the item (Present) or it might be empty (Empty). You check the box first. You don't blindly grab air expecting an item.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Lottery Ticket.</strong> A ticket is an Optional container. It *might* have a prize (Value), or it *might* have nothing (Null). You verify it before going to the bank.`,
+            hinglish: `<code>Optional</code> ek dabba (container) hai jo <code>NullPointerException</code> se bachane ke liye banaya gaya hai.<br><br>Agar koi method null return karne wala hai, to hum use Optional return karwate hain. Ye programmer ko majboor karta hai check karne ke liye ki "Bhai, andar maal hai ya nahi?".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Gift Box.</strong> Aapko kisi ne gift diya. Wo khali bhi ho sakta hai. Optional ek band dabba hai. Aap pehle check karte ho (isPresent) fir nikalte ho. Direct haath nahi dalte.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>ATM Cash.</strong> ATM machine ek Optional hai. Ho sakta hai cash ho, ho sakta hai cash na ho. Aapko <code>orElse()</code> sochna padta hai (agar cash nahi mila to main bank jaunga).`,
+            strategy: `Say: "I use .orElseThrow() heavily in Service layers when finding entities by ID. It cleanly throws a custom 'ResourceNotFoundException' if the data isn't there."`
+        },
+        {
+            id: 27,
+            title: "What is the difference between Comparable and Comparator?",
+            eng: `Both are interfaces used for sorting objects.<br><br><strong>Comparable (java.lang):</strong> Used for **Natural Ordering**. The class implements it itself (e.g., Student implements Comparable) and overrides <code>compareTo()</code>. It modifies the original class. You can only have one logic (e.g., sort by ID).<br><br><strong>Comparator (java.util):</strong> Used for **Custom Ordering**. You create a separate class (e.g., NameSorter, AgeSorter) that implements Comparator and overrides <code>compare()</code>. It doesn't modify the original class. You can have multiple sorting logics.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Comparable:</em> <strong>Height.</strong> Humans are naturally comparable by height. It's an internal property.<br>
+            <em>Comparator:</em> <strong>Exam Rank.</strong> A teacher sorts students by Marks, another teacher by Attendance. The logic is external to the student.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Comparable:</em> <strong>Dictionary.</strong> Words are always sorted A-Z internally.<br>
+            <em>Comparator:</em> <strong>Spotify Playlist.</strong> You can sort songs by 'Artist', 'Date Added', or 'Duration'. These are external sorters.`,
+            hinglish: `Dono sorting ke liye use hote hain.<br><br><strong>Comparable:</strong> Ye **Default Sorting** hai. Class khud apne aapko compare karti hai. Jaise Student class mein humne likh diya ki hamesha ID se sort hoga. (Method: <code>compareTo</code>).<br><br><strong>Comparator:</strong> Ye **Custom Sorting** hai. Agar humein kabhi Naam se, kabhi Age se sort karna ho, to hum alag se Comparator banate hain. Original class ko chedne ki zarurat nahi. (Method: <code>compare</code>).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Comparable:</em> <strong>School Line.</strong> Bacche hamesha Height wise khade hote hain (Default rule).<br>
+            <em>Comparator:</em> <strong>Cricket Team Selection.</strong> Kabhi Batting average pe sort karte hain, kabhi Bowling speed pe. Ye selector ki marzi hai (External logic).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Comparable:</em> <strong>Calendar.</strong> Dates hamesha purane se naye kram mein hoti hain.<br>
+            <em>Comparator:</em> <strong>Online Shopping.</strong> Filter lagana—Price: Low to High, ya Rating: High to Low. Ye Comparator hai.`,
+            strategy: `Tip: "In Java 8, Comparator became very powerful. We can now chain them like \`Comparator.comparing(Student::getAge).thenComparing(Student::getName)\`."`
+        },
+        {
+            id: 28,
+            title: "What is the difference between Eager Loading and Lazy Loading?",
+            eng: `This refers to how related data is fetched from the database (Hibernate/JPA).<br><br><strong>Eager Loading:</strong> Fetches the main data AND all related data immediately in one go. (e.g., Load User + Load all his Orders). Can be slow if too much data is loaded.<br><strong>Lazy Loading:</strong> Fetches only the main data. The related data is fetched <em>on-demand</em> only when you specifically ask for it (call the getter method). This is the default and is more efficient.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Eager:</em> <strong>Thali Meal.</strong> You get Roti, Sabji, Dal, Rice, Salad all at once on the plate, whether you eat it or not.<br>
+            <em>Lazy:</em> <strong>Buffet System.</strong> You take a plate. If you want Rice, you go get it. If you want Sweet, you go get it. You fetch only what is needed.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Eager:</em> <strong>Downloading a Game.</strong> You wait for 50GB to download completely before playing.<br>
+            <em>Lazy:</em> <strong>Streaming Netflix.</strong> It loads the first 5 minutes. As you watch, it loads the next part. It doesn't download the whole movie instantly.`,
+            hinglish: `Ye database se data nikalne ka tareeka hai.<br><br><strong>Eager Loading:</strong> Sab kuch ek saath utha laao. Agar User nikala, to uske Orders, Address, History sab saath mein aayega. Ye bhari pad sakta hai.<br><strong>Lazy Loading:</strong> Sirf main data laao. Baki cheezein tab laana jab zarurat ho (jab getter method call ho). Ye default hota hai aur fast hota hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Eager:</em> <strong>Shadi ki Plate.</strong> Pura khana (Starter, Main Course, Dessert) ek saath plate mein bhar liya.<br>
+            <em>Lazy:</em> <strong>Restaurant Order.</strong> Pehle Starter mangaya. Khaya. Fir man kiya to Main Course mangaya. Zarurat ke hisaab se.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Eager:</em> <strong>Exam se pehle ratta marna.</strong> Puri book padh li, chahe question aaye ya na aaye.<br>
+            <em>Lazy:</em> <strong>Open Book Exam.</strong> Jab question dekha, tab book mein wo page khola aur padha.`,
+            strategy: `Warning: "Lazy loading can lead to the **LazyInitializationException** if we try to access the data after the session is closed. We solve this using 'Open Session In View' or 'Join Fetch'."`
+        },
+        {
+            id: 29,
+            title: "Explain final, finally {} and finalize()?",
+            eng: `These three look similar but are totally different.<br><br>1. **final (Keyword):** Used to apply restrictions. A final variable is a constant. A final method cannot be overridden. A final class cannot be inherited.<br>2. **finally (Block):** Used in Exception Handling. The code inside this block *always* executes, whether an exception occurs or not. Used for cleanup (closing connections).<br>3. **finalize() (Method):** Used by Garbage Collector. It is called just before an object is destroyed to perform cleanup. (Deprecated in Java 9).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>final:</em> **Permanent Marker.** Once written, cannot be erased/changed.<br>
+            <em>finally:</em> **Paying the Bill.** Whether food was good or bad (Exception), you *must* pay the bill before leaving.<br>
+            <em>finalize:</em> **Last Will/Testament.** Before a person dies (Garbage collection), they write a will to distribute assets.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>final:</em> **Full Stop.** The sentence ends here. No more additions.<br>
+            <em>finally:</em> **Closing Shop.** Whether sales were high or low, you pull down the shutter at night.<br>
+            <em>finalize:</em> **Death Row Last Meal.** The final request granted before execution.`,
+            hinglish: `Ye teeno bilkul alag hain:<br><br>1. **final (Keyword):** Rok lagane ke liye. Final variable change nahi hota. Final class ka child nahi banta.<br>2. **finally (Block):** Try-Catch ke saath lagta hai. Iska code *hamesha* chalta hai, chahe error aaye ya na aaye. (Jaise database close karna).<br>3. **finalize() (Method):** Ye Garbage Collector call karta hai object ko delete karne se theek pehle. (Ab Java 9 se ye band/deprecated ho gaya hai).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>final:</em> **Patthar ki lakeer.** Jo likh diya wo badlega nahi.<br>
+            <em>finally:</em> **Haath dhona.** Khana kaisa bhi ho, khane ke baad haath dhona hi padta hai.<br>
+            <em>finalize:</em> **Aakhri Ichha.** Marne se pehle (delete hone se pehle) jo aakhri kaam kiya jaye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>final:</em> **Laminate karwana.** Certificate laminate ho gaya, ab usme change nahi kar sakte.<br>
+            <em>finally:</em> **Seat Belt.** Gadi start ho ya thuk jaye, seat belt pehenna zaruri hai.<br>
+            <em>finalize:</em> **Retirement Party.** Jane se pehle ki vidai.`,
+            strategy: `Trap: "Note that 'finally' block will NOT execute if we call System.exit(0) or if the JVM crashes."`
+        },
+        {
+            id: 30,
+            title: "What are the new Java 9 features?",
+            eng: `Java 9 introduced the **Module System (Jigsaw)**, which allows dividing the JDK into smaller modules. This solved the "Jar Hell" problem and made Java applications lighter.<br><br>Other features:<br>1. **JShell:** A REPL tool (run code immediately without creating class/main method).<br>2. **Factory Methods for Collections:** <code>List.of()</code>, <code>Set.of()</code>, <code>Map.of()</code> for creating immutable collections easily.<br>3. **Private methods in Interfaces.**<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Modules (Kitchen Sections).</strong> Before, the kitchen was one mess. Now, we have specific cabinets: Spices Module, Utensils Module, Fridge Module. You only open what you need.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>JShell (Scratchpad).</strong> Before, to test 2+2, you wrote a whole exam paper (Class/Main). Now JShell is like a rough notebook where you just write 2+2 and get 4.`,
+            hinglish: `Java 9 ka sabse bada feature tha **Modules (Project Jigsaw)**. Isne Java ko chote-chote tukdon mein baant diya taaki application heavy na ho.<br><br>Aur features:<br>1. **JShell:** Code test karne ke liye turant run karna (bina class banaye).<br>2. **Factory Methods:** <code>List.of("A", "B")</code> likhna aasan ho gaya. Pehle 4 line likhni padti thi.<br>3. **Private Methods in Interface:** Interface ke andar code reuse karne ke liye private methods.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Modules (IKEA Furniture).</strong> Pura sofa ek saath lane ki jagah, alag-alag tukdon mein laaye aur jahan zarurat thi wahan fit kiya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>JShell (Calculator).</strong> Pehle ganit karne ke liye formula likhna padta tha, ab calculator pe sidha button dabao aur result dekho.`,
+            strategy: `Say: "I rarely use Modules in standard web apps, but I use \`List.of()\` and \`Map.of()\` every single day because they are immutable and cleaner."`
+        },
+        {
+            id: 31,
+            title: "What are the new Java 10 features?",
+            eng: `The main highlight of Java 10 is **Local Variable Type Inference (var)**.<br><br>You can now declare local variables using the <code>var</code> keyword without specifying the type explicitly. The compiler infers the type from the right, hand side.<br>Example: <code>var name = "John";</code> (Compiler knows it is String).<br><br>It reduces verbosity, especially with complex generic types like <code>Map&lt;String, List&lt;User&gt;&gt;</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Packing Boxes.</strong> Instead of labeling a box "Kitchen-Cutlery-Spoons", you just use a transparent box (var). You look inside, see spoons, and know what it is automatically.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Nicknames.</strong> Instead of calling someone "Doctor Professor Sheldon Cooper" (Explicit Type), you just call them "Shelly" (var). Everyone knows who you are referring to based on context.`,
+            hinglish: `Java 10 ka hero feature hai **'var' keyword**.<br><br>Ab humein variable ka type likhne ki zarurat nahi. Compiler khud samajh jata hai.<br>Example: <code>var x = 10;</code> (Compiler samajh gaya ye int hai).<br>Ye tab bahut kaam aata hai jab type ka naam bahut lamba ho.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Transparent Dabba.</strong> Dabbey pe 'Chini' likhne ki zarurat nahi agar dabba transparent hai. Andar safed dane dikh rahe hain to wo chini hi hogi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Context.</strong> Agar main haath mein cricket bat pakda hoon, to mujhe bolne ki zarurat nahi "I am a Batsman". Log dekh ke (Infer karke) samajh jate hain.`,
+            strategy: `Clarify: "Remember, 'var' only works for **Local Variables** inside methods. We cannot use it for class fields or method parameters."`
+        },
+        {
+            id: 32,
+            title: "Why multiple inheritance is not allowed in Java?",
+            eng: `It is not allowed to avoid the **Diamond Problem** (Ambiguity).<br><br>Imagine Class B and Class C both extend Class A and override a method <code>run()</code>. Now, if Class D extends both B and C, and you call <code>D.run()</code>, which one should it execute? B's version or C's version? This confusion causes bugs.<br>Java solved this by removing multiple inheritance of classes and using **Interfaces** instead.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Two Bosses.</strong> You have two bosses. Boss A says "Write code in Java". Boss B says "Write code in Python". Who do you listen to? You get confused (Ambiguity).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Driving Directions.</strong> Mom says "Turn Left". Dad says "Turn Right". You are the child class. You crash because you don't know whose instruction to follow.`,
+            hinglish: `Ye **Diamond Problem** (Confusion) se bachne ke liye ban hai.<br><br>Socho Class B aur Class C dono ke paas <code>show()</code> method hai. Agar Class D in dono ko extend kare aur <code>D.show()</code> call kare, to wo kiska method chalayega? B ka ya C ka? Compiler confuse ho jayega.<br>Isliye Java ne kaha "Ek time pe ek hi Baap (Parent) hoga".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Do Boss.</strong> Aapke do manager hain. Ek ne bola "Aaj chutti lelo", dusre ne bola "Aaj overtime karo". Aap confuse ho jaoge (Ambiguity).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Double Role.</strong> Agar ek actor ko ek hi scene mein Hero aur Villain dono ka role play karna ho, to wo kaise karega? Conflict ho jayega.`,
+            strategy: `Pivot: "However, Java DOES allow multiple inheritance of **Interfaces**, because interfaces don't have method bodies (historically), so there was no ambiguity about implementation."`
+        },
+        {
+            id: 33,
+            title: "What is Hibernate Criteria API?",
+            eng: `Criteria API is a way to create queries programmatically (using Java code) rather than writing string-based queries like HQL or SQL.<br><br>It is purely object-oriented and type-safe. It helps in writing **Dynamic Queries** (e.g., search filters where parameters are optional). If the user selects a date, we add a date condition; if not, we don't.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Building a Custom Sandwich.</strong> You don't pick a pre-made sandwich (HQL). You stand at the counter and say "Add Cheese", "Add Tomato", "No Onion". You build the query step-by-step dynamically.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Online Shopping Filters.</strong> You select "Brand: Nike". Then "Size: 10". Then "Color: Black". The query is built dynamically based on your clicks. Criteria API handles this perfectly.`,
+            hinglish: `Criteria API bina SQL likhe Java code se query banane ka tarika hai.<br><br>Iska sabse bada fayda hai **Dynamic Search**. Jab humein pata nahi hota ki user kya search karega. Agar user ne sirf Naam dala, to sirf Naam search karo. Agar Naam aur Date dono dala, to dono search karo. Ye if-else laga ke query banana Criteria se aasan hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Subway Sandwich.</strong> Wahan menu fix nahi hota. Aap batate ho "Bread ye wali", "Sauce ye wala". Aap apni dish (Query) khud banate ho step-by-step.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Amazon Filter.</strong> Kabhi aap sirf 'Shoes' search karte ho, kabhi 'Shoes + Puma + Under 2000'. Query har baar badal rahi hai. Ye Criteria API ka kaam hai.`,
+            strategy: `Note: "The old Criteria API was deprecated in Hibernate 5.2. Now we use the **JPA CriteriaBuilder**, which is standard across all ORMs."`
+        },
+        {
+            id: 34,
+            title: "What is volatile keyword?",
+            eng: `The <code>volatile</code> keyword is used in Multithreading. It guarantees **Visibility** of changes to variables across threads.<br><br>Normally, threads cache variables in their local CPU cache for speed. If Thread A updates a variable, Thread B might still see the old value in its cache. Declaring a variable <code>volatile</code> forces threads to read/write directly from **Main Memory (RAM)**, ensuring everyone sees the latest value.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Digital Scoreboard.</strong> In a cricket match, the scoreboard is 'volatile'. When the scorer updates it, every spectator (Thread) sees the new score immediately. If it wasn't volatile, some people might still see the old score.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Office Notice Board.</strong> If the boss puts a notice on the main board (Main Memory), everyone sees it. If he writes it in his personal diary (CPU Cache), no one else knows. Volatile puts it on the Notice Board.`,
+            hinglish: `<code>volatile</code> keyword Multithreading mein use hota hai. Ye sure karta hai ki agar ek Thread ne value badli, to baki sabhi Threads ko turant pata chale.<br><br>Computer mein har Thread ka apna chota dimaag (Cache) hota hai. Wo purani value yaad rakh sakta hai. <code>volatile</code> bolta hai: "Apne dimaag mein mat rakho, Main Memory (RAM) se padho".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Live Cricket Score.</strong> Jab TV pe score badalta hai, to puri duniya ko turant dikhta hai. Ye volatile variable hai. Agar update na ho, to log purana score dekhte rahenge.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>WhatsApp Group Message.</strong> Agar main group mein message bhejun, to sabke phone mein bajta hai. Sabka data sync ho jata hai.`,
+            strategy: `Contrast: "Volatile guarantees visibility, but NOT atomicity. For atomic operations (like counter++), we need **AtomicInteger** or **Synchronized**."`
+        },
+        {
+            id: 35,
+            title: "What is the difference between ArrayList and LinkedList?",
+            eng: `Both implement the List interface, but their internal structure is different.<br><br><strong>ArrayList:</strong> Uses a **Dynamic Array**. Fast for accessing data (<code>get(5)</code> is instant). Slow for inserting/deleting in the middle (because all other elements must shift).<br><strong>LinkedList:</strong> Uses a **Doubly Linked List**. Fast for insertion/deletion (just change pointers). Slow for accessing data (must travel node by node from start).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>ArrayList:</em> **Bookshelf.** Picking the 5th book is easy. But if you want to insert a book in the middle, you have to shift all other books to the right.<br>
+            <em>LinkedList:</em> **Treasure Hunt Chain.** To find clue #5, you must visit clue #1, then #2, then #3... You can't jump directly. But adding a new clue in the middle is easy (just change the paper note).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>ArrayList:</em> **Cinema Seats.** Numbered seats. You find seat H-5 instantly.<br>
+            <em>LinkedList:</em> **Human Chain.** People holding hands. To find a person, you start from the first and ask "Who is next?".`,
+            hinglish: `<strong>ArrayList:</strong> Ye **Array** use karta hai. Data dhoondna (Search) bahut fast hai. Par beech mein data dalna (Insert/Delete) slow hai kyunki baki sabko khiskana padta hai.<br><strong>LinkedList:</strong> Ye **Chain** (zanjeer) use karta hai. Beech mein data dalna fast hai (bas kadi kholo aur jodo). Par dhoondna slow hai kyunki shuru se check karna padta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>ArrayList:</em> **Kitabon ki rack.** 5vi kitab nikalna aasan hai. Par beech mein nayi kitab ghusani ho to baki sabko side karna padega.<br>
+            <em>LinkedList:</em> **Train ke dabbe.** Beech mein naya dabba jodna aasan hai, bas hook kholo aur jodo. Par 50ve dabbe tak jane ke liye 1 se 49 cross karne padenge.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>ArrayList:</em> **Numbered Parking.**<br>
+            <em>LinkedList:</em> **Haath pakad ke khade log.**`,
+            strategy: `Guidance: "90% of the time we use ArrayList because usually, we read more than we write. LinkedList consumes more memory due to storing 'Next' and 'Prev' pointers."`
+        },
+        {
+            id: 36,
+            title: "Can Java code be executed without generating .class file?",
+            eng: `Before Java 11: **No.** You had to compile (<code>javac</code>) to create a .class file, then run (<code>java</code>).<br><br>Since **Java 11**: **Yes!** For single-file source code, you can run it directly using <code>java MyFile.java</code>. The JVM compiles it in memory and executes it immediately without producing a .class file on disk.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Instant Noodles.</strong> Old Java: Buy veggies, chop them, cook them (Compile), then eat. Java 11: Cup Noodles. Just pour hot water and eat immediately. No prep work stored on disk.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Streaming Music.</strong> Old way: Download MP3 file (.class), then play. New way: Stream directly (Spotify). You listen to the song without saving a permanent file.`,
+            hinglish: `Java 11 se pehle: **Nahi.** Pehle .class file banana zaruri tha.<br><br>Java 11 ke baad: **Haan.** Agar code ek hi file mein hai, to aap sidha <code>java MyCode.java</code> likh kar run kar sakte ho. Java andar hi andar memory mein compile karke run kar dega, hard disk pe file nahi banayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Live Speech vs Recorded.</strong> Pehle speech record hoti thi (.class file) fir sunayi jati thi. Ab Live speech (Java 11) sidha suni jati hai, record karne ki zarurat nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Instant Photo Print.</strong> Pehle negative reel dhulwani padti thi. Ab Polaroid camera se photo sidha bahar aati hai.`,
+            strategy: `Context: "This feature was added primarily to make Java friendlier for beginners and for writing simple scripts, similar to Python."`
+        },
+        {
+            id: 37,
+            title: "What is the difference between HashSet, LinkedHashSet and TreeSet?",
+            eng: `All implement the Set interface (Unique elements only), but order differs:<br><br>1. **HashSet:** **No Order.** Stores elements using Hashing. Fastest performance (O(1)). Use this if you don't care about order.<br>2. **LinkedHashSet:** **Insertion Order.** Remembers the order in which you added elements. Slightly slower than HashSet.<br>3. **TreeSet:** **Sorted Order.** Stores elements sorted (A-Z or 1-100). Slowest (O(log n)) because it sorts continuously.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>HashSet:</em> **Bag of Balls.** You throw balls in a bag. When you take them out, they come out randomly.<br>
+            <em>LinkedHashSet:</em> **Playlist Queue.** Songs play in the exact order you added them.<br>
+            <em>TreeSet:</em> **Dictionary.** No matter in what order you add words, they will always be arranged A-Z.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>HashSet:</em> **Crowd in a Mela.** Random arrangement.<br>
+            <em>LinkedHashSet:</em> **Line at Ticket Counter.** First come, first served.<br>
+            <em>TreeSet:</em> **Assembly Line Height-wise.** Students stand sorted by height.`,
+            hinglish: `Teeno mein Duplicate allow nahi hai, bas "Order" ka fark hai:<br><br>1. **HashSet:** **Koi Order nahi.** Fast hota hai. Data kaise bhi store hoga. (Randon).<br>2. **LinkedHashSet:** **Insertion Order.** Jaise dala, waise niklega (Line mein).<br>3. **TreeSet:** **Sorted Order.** Ye data ko sort karke rakhta hai (A-Z ya 1-10). Thoda slow hota hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>HashSet:</em> **Sikke ka dabba.** Sikke daalo, nikalte waqt koi bhi pehle aa sakta hai.<br>
+            <em>LinkedHashSet:</em> **YouTube History.** Jo video pehle dekhi, wo list mein pehle dikhegi.<br>
+            <em>TreeSet:</em> **Attendance Register.** Bachon ke naam hamesha A to Z likhe hote hain.`,
+            strategy: `Trap: "TreeSet does not allow NULL values because it cannot compare null with other values for sorting. HashSet allows one Null."`
+        },
+        {
+            id: 38,
+            title: "What is the difference between JDK, JRE and JVM?",
+            eng: `Think of it as a hierarchy:<br><br>1. **JVM (Java Virtual Machine):** The engine that actually runs the code. It is platform-dependent (Windows JVM is different from Mac JVM).<br>2. **JRE (Java Runtime Environment):** JVM + Libraries. It is for *users* who just want to run Java apps (like Minecraft). They don't need to write code.<br>3. **JDK (Java Development Kit):** JRE + Compiler (javac) + Tools. It is for *developers* who need to write and compile code.<br><br>Formula: **JDK = JRE + Development Tools**. **JRE = JVM + Library Classes**.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JVM:</em> **The Driver.** He actually drives the car.<br>
+            <em>JRE:</em> **The Car + Driver.** A complete package to travel (Run).<br>
+            <em>JDK:</em> **Car Factory + Car + Driver.** You can build (Code) new cars and also drive them.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JVM:</em> **Stomach.** It digests the food.<br>
+            <em>JRE:</em> **Body + Stomach.** Needed to live.<br>
+            <em>JDK:</em> **Chef + Kitchen + Body.** Needed to *cook* food (Develop) and eat it.`,
+            hinglish: `Ye ek Russian Doll jaisa hai (Ek ke andar ek):<br><br>1. **JVM:** Ye Engine hai jo code run karta hai.<br>2. **JRE:** JVM + Libraries. Ye normal logo ke liye hai jinhe bas game khelna hai ya app chalana hai.<br>3. **JDK:** JRE + Developer Tools (javac). Ye programmers ke liye hai taaki wo code likh sakein aur compile kar sakein.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JVM:</em> **Driver.** Jo gadi chalata hai.<br>
+            <em>JRE:</em> **Taxi.** Gadi aur Driver dono hain, baitho aur jao (Run karo).<br>
+            <em>JDK:</em> **Garage/Workshop.** Yahan gadi banti bhi hai (Develop) aur chalti bhi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JVM:</em> **Pet (Stomach).** Khana hazam karta hai.<br>
+            <em>JRE:</em> **Insaan.** Khana khata hai.<br>
+            <em>JDK:</em> **Cook (Rasoiya).** Jo khana bana bhi sakta hai aur kha bhi sakta hai.`,
+            strategy: `Detail: "Remember, JVM is platform dependent (software for Windows/Linux is different), but Java Language is platform independent (Write Once Run Anywhere)." (This is the classic slogan).`
+        },
+        {
+            id: 39,
+            title: "Can we have default arguments in Java?",
+            eng: `**No**, unlike C++ or Python, Java does strictly **NOT** support default arguments in methods.<br><br>However, we can simulate this behavior using **Method Overloading**. We create multiple methods with the same name but different parameters. The method with fewer parameters calls the method with more parameters, passing a default value.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Coffee Shop.</strong> Java doesn't have a button "Coffee" that assumes sugar. Instead, Java creates two buttons: 1. <code>Coffee()</code> which internally calls 2. <code>Coffee(Sugar)</code> passing "Medium Sugar" as default.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Search Bar.</strong> You can't have a default search. So we overload: <code>search()</code> calls <code>search("All Categories")</code> internally.`,
+            hinglish: `**Nahi**, Java mein C++ ya Python ki tarah Default Arguments nahi hote.<br><br>Par hum "Jugad" karte hain **Method Overloading** se. Hum ek bina argument wala method banate hain, aur uske andar se main method ko call kar dete hain default value ke saath.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Chai banana.</strong> Java mein automatic cheeni nahi padti. Hum do method banate hain: <code>chaiBanao()</code> jo apne aap <code>chaiBanao(2 chammach)</code> ko call kar deta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Pizza Order.</strong> Agar customer ne topping nahi boli, to hum manually 'Cheese' topping select karke order place karte hain.`,
+            strategy: `Say: "This design choice was made to keep Java simple and avoid ambiguity. Overloading is explicitly clear about which method is being called."`
+        },
+        {
+            id: 40,
+            title: "Can a constructor be final in Java?",
+            eng: `**No.** A constructor cannot be marked as <code>final</code>, <code>static</code>, or <code>abstract</code>.<br><br>Why? Because <code>final</code> methods cannot be overridden. But **Constructors are NEVER overridden** anyway (they are not inherited). So, marking it final makes no sense logically. It's redundant. The compiler will give an error.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Birth Certificate.</strong> A constructor is like being born. You are born only once. You can't "Override" your birth. Saying "This birth is final" is silly because birth is always unique to you.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Foundation of a House.</strong> The foundation is built once. You can't "inherit" a foundation and change it for the second floor. It belongs strictly to the ground floor.`,
+            hinglish: `**Nahi.** Constructor kabhi <code>final</code> nahi ho sakta.<br><br>Kyun? Kyunki <code>final</code> ka matlab hota hai "Override mat karna". Aur Constructors waise bhi kabhi Override hote hi nahi hain (Kyunki Child class ka naam alag hota hai Parent class se). To ye bolna befizool hai. Compiler error dega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Janam.</strong> Constructor janam jaisa hai. Aapka janam bas aapka hai. Aapka beta aapka janam 'Override' nahi kar sakta, uska apna janam hoga.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Makan ki neev.</strong> Neev ek baar padti hai. Uspe 'Final' likhne ka koi matlab nahi kyunki wo waise bhi badli nahi ja sakti.`,
+            strategy: `Lead: "However, a constructor CAN be private. We use **Private Constructors** to create Singleton classes or Utility classes (like java.lang.Math) to prevent instantiation."`
+        },
+        {
+            id: 41,
+            title: "What are the new Java 11 features?",
+            eng: `Java 11 is a Long Term Support (LTS) version. Key features include:<br>1. **Direct execution of single file source code** (Run without compile).<br>2. **String Methods:** <code>isBlank()</code>, <code>lines()</code>, <code>strip()</code>, <code>repeat()</code>.<br>3. **New File Methods:** <code>Files.readString()</code> and <code>Files.writeString()</code> making file IO incredibly easy.<br>4. **var in Lambda:** You can now use <code>var</code> inside lambda parameters.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>New String Tools.</strong> Earlier checking for blank space was manual. Now <code>" ".isBlank()</code> is a built-in tool, like a Swiss Knife feature.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Reading a Book.</strong> Old Java: Open book, read line by line, buffer it, close book. Java 11: <code>Files.readString()</code> is like "Scan whole page instantly".`,
+            hinglish: `Java 11 ek LTS (Stable) version hai. Iske naye features:<br>1. **Direct Run:** Bina compile kiye code run karna.<br>2. **String ke naye methods:** <code>isBlank()</code> (kya khali hai?), <code>repeat(3)</code> (3 baar likho).<br>3. **File Handling:** Ab file padhna baccho ka khel hai <code>readString()</code> ke saath. Pehle 10 line likhni padti thi.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>File Padhna.</strong> Pehle file padhna matlab pura process follow karna (BufferedReader etc). Ab bas ek command: "Puri file padh lo".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>String Repeat.</strong> Agar "Sorry" 100 baar likhna hai, to loop mat lagao. Bas <code>"Sorry".repeat(100)</code> likho.`,
+            strategy: `Say: "The HttpClient API was also standardized in Java 11, which replaced the ancient HttpURLConnection. It supports HTTP/2 and WebSocket."`
+        },
+        {
+            id: 42,
+            title: "What is Classloader in Java?",
+            eng: `The Classloader is a subsystem of JVM responsible for loading <code>.class</code> files (Bytecode) into memory dynamically when needed.<br><br>It follows a **Delegation Model**: <br>1. **Bootstrap:** Loads core Java classes (rt.jar like String, System).<br>2. **Extension:** Loads external extensions.<br>3. **Application:** Loads your own code (classpath).<br>When you ask for a class, the App Classloader asks the Extension, which asks the Bootstrap. If no one finds it, you get <code>ClassNotFoundException</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Looking for a File.</strong> You (App) ask your Manager (Ext). Manager asks the CEO (Bootstrap). If CEO has it, good. If not, Manager checks. If not, You check. If no one has it -> Error.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Librarian.</strong> You ask for a book. The Junior librarian asks the Senior. Senior asks the Head Librarian. They search top-down.`,
+            hinglish: `Classloader JVM ka wo hissa hai jo files (.class) ko dhoond kar memory mein lata hai. Ye 3 level pe kaam karta hai (Delegation):<br>1. **Bootstrap:** Ye Java ki main files lata hai (String, Integer).<br>2. **Extension:** Ye extra libraries lata hai.<br>3. **Application:** Ye aapka likha hua code lata hai.<br>Hamesha request upar (Bootstrap) jati hai. Agar upar wale ke paas nahi mila, tab niche wala dhoondta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ghar mein saman dhoondna.</strong> Aapne Mummy (Bootstrap) se pucha. Unhe nahi mila to Bade bhai (Ext) se pucha. Nahi mila to khud (App) dhoonda. Kahin nahi mila to "Kho gaya" (Exception).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>School Permission.</strong> Pehle Principal (Bootstrap) se pucho. Fir Teacher (Ext) se. Fir Monitor (App) se.`,
+            strategy: `Trap: "A Classloader cannot see classes loaded by its child classloader, but a child can see classes loaded by the parent. This isolation is crucial for security."`
+        },
+        {
+            id: 43,
+            title: "What is Primary Cache in Hibernate?",
+            eng: `Primary Cache (First Level Cache) is the default cache provided by Hibernate. It is associated with the **Session** object.<br><br>It is enabled by default and cannot be disabled. If you request the same object (same ID) twice within the same Session, Hibernate returns it from the cache instead of hitting the database again.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Wallet (Pocket).</strong> Primary cache is like your wallet. If you need money, you check your wallet first. You only go to the ATM (Database) if the wallet is empty. Once you withdraw, you keep it in the wallet for next time.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Browser Cache.</strong> When you visit a website, images are stored locally. If you refresh, it loads from local memory, not from the server.`,
+            hinglish: `Primary Cache (Level 1) Hibernate ka default cache hai. Ye **Session** ke saath juda hota hai.<br><br>Ye hamesha ON rehta hai. Agar aapne ek transaction mein user ID 1 manga, aur 2 second baad firse user ID 1 manga, to Hibernate database nahi jayega. Wo pehli baar wala hi wapas de dega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Jeb (Pocket).</strong> Agar paise chahiye to pehle jeb check karoge. Agar jeb mein hai (Cache hit), to Bank (Database) jane ki zarurat nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Short Term Memory.</strong> Agar maine abhi phone number bola, to wo aapke dimaag mein hai. Agar 1 minute baad fir pucha, to aap turant bata doge (Cache). Yaad nahi karna padega.`,
+            strategy: `Contrast: "However, L1 cache dies when the Session is closed. For caching across multiple sessions (global), we need **Secondary Cache (Level 2)** like EhCache or Redis."`
+        },
+        {
+            id: 44,
+            title: "Why String is immutable in Java?",
+            eng: `String is immutable (unchangeable) for three main reasons:<br>1. **String Pool:** To save memory, Java reuses String literals. If Strings were mutable, changing one reference would affect all other variables pointing to that same string.<br>2. **Security:** Strings are used for database connections, usernames, and passwords. If they were mutable, a hacker could change the connection URL after security checks passed.<br>3. **Thread Safety:** Immutable objects are automatically thread-safe. Multiple threads can share a String without synchronization.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bank Cheque.</strong> Once you write "$1000" and sign it, it becomes immutable. If it were mutable, someone could add a zero and make it "$10000". Immutability provides security.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Notice Board.</strong> If 10 people are reading a notice, and one person erases a word, everyone gets wrong information. Immutability means no one can erase the notice.`,
+            hinglish: `String ko immutable (na badalne wala) banaya gaya 3 wajah se:<br>1. **Memory (String Pool):** Java memory bachane ke liye ek hi "Hello" ko 10 jagah share karta hai. Agar ek ne badal diya, to sabka badal jayega. Isliye badalna mana hai.<br>2. **Security:** Passwords aur Username String hote hain. Agar wo change ho sakein, to hacker security check ke baad password badal dega.<br>3. **Thread Safety:** Kyunki wo change nahi ho sakta, kai threads usse ek saath use kar sakte hain bina dar ke.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Check pe Sign.</strong> Ek baar amount likh ke sign kar diya, to wo final hai. Agar wo mutable hota, to koi bhi zero badha deta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Printed Book.</strong> Kitab chap gayi to chap gayi. Aap uske text ko change nahi kar sakte. Agar sabke paas alag text hota to confusion hoti.`,
+            strategy: `Lead: "Since String is immutable, manipulating strings in a loop creates many garbage objects. That is why we use **StringBuilder** or **StringBuffer** for heavy modifications."`
+        },
+        {
+            id: 45,
+            title: "What is an Enum in Java?",
+            eng: `An Enum (Enumeration) is a special data type used to define a collection of **Constants**. It is type-safe.<br><br>Enums are more powerful in Java than in C++. In Java, an Enum is technically a **Class**. It can have constructors, methods, and variables. We use it when we know all possible values at compile time (e.g., Days of Week, Colors, OrderStatus).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Traffic Lights.</strong> There are only 3 valid states: RED, YELLOW, GREEN. You can't have a "PURPLE" light. Enum ensures you only pick from these 3.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Pizza Sizes.</strong> SMALL, MEDIUM, LARGE. You cannot order a "Gigantic" size if it's not in the menu (Enum).`,
+            hinglish: `Enum constants ka ek group hai. Iska use tab karte hain jab humein pata ho ki values fix hain aur badlengi nahi.<br><br>Java mein Enum ek tarah ki **Class** hi hoti hai. Iske andar hum methods aur constructor bhi bana sakte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hafte ke Din.</strong> Sunday se Saturday tak 7 hi din hote hain. 8va din nahi ho sakta. Ye Enum hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Payment Status.</strong> PENDING, SUCCESS, FAILED. Iske alawa chotha option nahi ho sakta.`,
+            strategy: `Mention: "A very popular interview question is using Enum to create a **Singleton**, as it is the safest way to prevent Reflection attacks."`
+        },
+        {
+            id: 46,
+            title: "What is the difference between synchronized, volatile and atomic in Java?",
+            eng: `These deal with thread safety at different levels:<br><br>1. **volatile:** Solves **Visibility** problem. Ensures threads read the latest value from RAM. Does NOT ensure atomicity (safety in compound actions like count++).<br>2. **Atomic Variables (AtomicInteger):** Solves **Visibility + Atomicity** for single variables. Efficient lock-free thread safety using CAS (Compare-And-Swap) hardware instructions.<br>3. **synchronized:** The "Big Hammer". Solves **Visibility + Atomicity** for blocks of code. It uses locks (mutex). Only one thread enters at a time. Safe but slower.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>volatile:</em> <strong>TV Screen.</strong> Everyone sees the same image.<br>
+            <em>Atomic:</em> <strong>Turnstile (Metro Gate).</strong> Only one person passes at a time. It counts people accurately automatically.<br>
+            <em>synchronized:</em> <strong>Fitting Room.</strong> You lock the door. No one else can enter until you come out. Totally safe, but creates a queue.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>volatile:</em> Announcement on speaker.<br>
+            <em>Atomic:</em> Token machine dispensing tokens 1-by-1.<br>
+            <em>synchronized:</em> Using the office printer (Exclusive access).`,
+            hinglish: `Teeno Thread safety ke liye hain:<br><br>1. **volatile:** Ye sure karta hai ki data sabko dikhe (Visibility). Par ye calculations (++) mein fail ho jata hai.<br>2. **Atomic (AtomicInteger):** Ye variable ke liye best hai. Ye bina lock lagaye calculation safe karta hai (Hardware level pe).<br>3. **synchronized:** Ye sabse powerful (aur slow) hai. Ye darwaza band kar leta hai (Lock). Jab tak ek thread kaam kar raha hai, dusra bahar wait karega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>volatile:</em> <strong>Notice Board.</strong> Sabko dikh raha hai.<br>
+            <em>Atomic:</em> <strong>Counter Machine.</strong> Button dabao, ek number badhega. Galti ka chance nahi.<br>
+            <em>synchronized:</em> <strong>Toilet ka darwaza.</strong> Andar se kundi band. Jab tak banda bahar na aaye, dusra nahi ja sakta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Atomic:</em> **Like Button.** Jitne log dabayenge, count sahi badhega.<br>
+            <em>synchronized:</em> **ATM Machine.** Ek baar mein ek aadmi hi use karega.`,
+            strategy: `Guidance: "Always prefer **Atomic classes** for simple counters, **Volatile** for flags, and **Synchronized** only for complex logic blocks."`
+        },
+        {
+            id: 47,
+            title: "What is the difference between TDD and BDD?",
+            eng: `1. **TDD (Test Driven Development):** "Test First, Code Later". Developers write unit tests (JUnit) before writing the actual code. It focuses on **implementation** (How the code works).<br>2. **BDD (Behavior Driven Development):** An extension of TDD. It focuses on the **behavior** of the system from a user's perspective (What the user does). Tests are written in plain English (Gherkin syntax: Given-When-Then) so business owners can understand.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>TDD:</em> <strong>Mechanic.</strong> He checks "Does the spark plug fire?" (Component test).<br>
+            <em>BDD:</em> <strong>Driver.</strong> He checks "When I turn the key, does the car start?" (Behavior test).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>TDD:</em> Checking if the bulb filament is intact.<br>
+            <em>BDD:</em> Checking if the room lights up when switch is pressed.`,
+            hinglish: `1. **TDD (Test Driven):** Pehle Test likho, fir Code likho. Ye **Developers** karte hain. Iska focus hai ki code andar se sahi kaam kare (Unit testing).<br>2. **BDD (Behavior Driven):** Ye TDD ka bada bhai hai. Iska focus hai ki **User** ko kya result mil raha hai. Iske test English mein likhe jate hain (Given-When-Then) taaki Manager bhi padh sake.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>TDD:</em> <strong>Mechanic.</strong> Wo engine ka voltage check kar raha hai (Technical check).<br>
+            <em>BDD:</em> <strong>Driver.</strong> Wo check kar raha hai ki break dabane pe gadi rukti hai ya nahi (Behavior check).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>TDD:</em> Check karna ki Pizza oven ka taapman 200 degree hai.<br>
+            <em>BDD:</em> Check karna ki Pizza jala to nahi.`,
+            strategy: `Say: "In my project, we used **JUnit/Mockito** for TDD and **Cucumber** for BDD."`
+        },
+        {
+            id: 48,
+            title: "What is the difference between isEmpty() and isBlank()?",
+            eng: `Both check strings, but differently.<br><br>1. **isEmpty():** Returns true ONLY if the string length is 0. (<code>""</code>). If the string contains spaces (<code>" "</code>), it returns false.<br>2. **isBlank() (Java 11):** Returns true if the string is empty OR contains only whitespace (spaces, tabs). It is smarter and more useful for validation.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Empty Box.</strong><br>
+            <em>isEmpty():</em> Is the box literally containing 0 atoms? If there is dust (spaces), it says "Not Empty".<br>
+            <em>isBlank():</em> Is the box useful? If it has dust (spaces), it says "It's basically blank, ignore it".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Writing Paper.</strong><br>
+            <code>isEmpty()</code> checks if you wrote 0 characters.<br>
+            <code>isBlank()</code> checks if you just scribbled spaces with a pencil invisible ink. It treats space as "nothing".`,
+            hinglish: `Dono String check karte hain par fark hai:<br><br>1. **isEmpty():** Ye tabhi True bolega jab length bilkul 0 hogi. Agar aapne space (spacebar) bhi daba diya, to ye False bolega (Kyunki space bhi ek character hai).<br>2. **isBlank():** Ye Java 11 mein aaya. Ye samajhdar hai. Agar String mein sirf spaces hain, to ye bolega "Haan bhai, khali hi hai". Validation ke liye ye best hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Khali Kamra.</strong><br>
+            <em>isEmpty:</em> Kamra tabhi khali hai jab hawa bhi na ho.<br>
+            <em>isBlank:</em> Agar kamre mein sirf dhool (spaces) hai, koi insaan nahi, to ye manega kamra khali hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Form Validation.</strong> Agar user ne naam mein 5 space daal diye.<br>
+            <em>isEmpty</em> bolega: "Naam valid hai". (Galat).<br>
+            <em>isBlank</em> bolega: "Ye invalid hai, kuch likha nahi hai". (Sahi).`,
+            strategy: `Tip: "Always use isBlank() for form validations to prevent users from submitting empty comments filled with just spaces."`
+        },
+        {
+            id: 49,
+            title: "Why StringBuffer is obsolete?",
+            eng: `StringBuffer is obsolete (outdated) because it is **Synchronized**. Every method in StringBuffer (append, delete) checks for locks. This makes it **Slow**.<br><br>In 99% of cases, we manipulate Strings inside a single thread (local method variables). We don't need synchronization overhead. So, Java 5 introduced **StringBuilder**, which is non-synchronized and much faster. We use StringBuilder almost exclusively now.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Toll Booth.</strong> StringBuffer is a toll booth where every car must stop and pay (Lock), even if the road is empty. It's safe but slow.<br>
+            StringBuilder is a Free Highway. Cars zoom past. It's fast.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Knocking on Door.</strong> StringBuffer knocks on the door before entering every room (Checking locks). StringBuilder just walks in. Walking in is faster.`,
+            hinglish: `StringBuffer purana ho gaya hai kyunki wo **Synchronized** hai. Uska har method lock check karta hai, jisse wo **Slow** ho jata hai.<br><br>Zyadatar hum String ek hi method ke andar banate hain, wahan thread safety ki zarurat nahi hoti. Isliye Java 5 ne **StringBuilder** diya. Ye same kaam karta hai par bina lock ke, isliye ye bahut **Fast** hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Security Check.</strong> StringBuffer waisa hai jaise apne hi ghar mein ghusne se pehle ID card dikhana. Safe hai par slow hai.<br>
+            StringBuilder waisa hai jaise seedha andar aa jana. Fast hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Traffic Light.</strong> Raat ko jab road khali ho, tab bhi Red light pe rukna (StringBuffer) time waste hai. StringBuilder bina ruke nikal jata hai.`,
+            strategy: `Say: "The only time I would use StringBuffer today is if I am sharing a mutable string across multiple threads, which is a very rare design."`
+        },
+        {
+            id: 50,
+            title: "What is Nested class in Java?",
+            eng: `A Nested class is a class defined *inside* another class. It is used to logically group classes that are only used in one place. It increases encapsulation.<br><br>Types:<br>1. **Static Nested Class:** Like a static member. Can access only static members of the outer class.<br>2. **Inner Class (Non-static):** Associated with an object of the outer class. Can access all members (even private) of the outer class.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Car and Engine.</strong> The Engine is complex, but it is useful ONLY inside a Car. So we define <code>class Engine</code> inside <code>class Car</code>. It doesn't make sense to have an Engine lying around without a Car.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Computer and CPU.</strong> The CPU is an internal part of the Computer. It is nested inside the Computer cabinet.`,
+            hinglish: `Nested class wo class hai jo dusri class ke **andar** bani hoti hai. Ye hum tab banate hain jab ek class ka kaam sirf dusri class ke andar ho.<br><br>Do tarah ki hoti hain:<br>1. **Static:** Jo bina outer object ke ban sakti hai.<br>2. **Inner (Non-static):** Jo outer object ke sath judi hoti hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Gadi aur Engine.</strong> Engine alag se sadak pe nahi chalta. Wo Gadi ke andar hi kaam ka hai. Isliye Engine class ko Car class ke andar banate hain.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Kangaroo aur Baccha.</strong> Kangaroo ka baccha pouch (jeb) ke andar rehta hai. Wo nested hai.`,
+            strategy: `Trap: "Anonymous Inner Classes are a type of nested class. We used them heavily for event listeners before Lambdas came in Java 8."`
+        },
+        {
+            id: 51,
+            title: "What is Secondary Cache in Hibernate?",
+            eng: `Secondary Cache (Level 2 Cache) is an optional cache that is shared across **multiple sessions** (global cache). Unlike Level 1 cache (which dies when the session closes), Level 2 cache persists. <br><br>It is provided by third-party vendors like **EhCache, OSCache, or Redis**. It is used to store data that is read frequently but modified rarely (like Country lists, Reference data) to reduce database load.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Library Bookshelf (L2) vs Study Desk (L1).</strong> <br>
+            <em>L1 (Desk):</em> You bring a book to your desk. Only you can see it. When you leave (Session close), the desk is cleared.<br>
+            <em>L2 (Bookshelf):</em> The main bookshelf is shared by all students. If someone returns a book, another student can pick it up without ordering a new one from the publisher (Database).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Office Water Cooler.</strong> <br>
+            <em>L1:</em> Water in your personal bottle. Only you drink it.<br>
+            <em>L2:</em> The big water dispenser. Everyone in the office shares it. It saves everyone from walking to the river (Database) to get water.`,
+            hinglish: `Secondary Cache (Level 2) ek optional cache hai jo sabhi users (Sessions) ke beech share hota hai. <br><br>L1 cache sirf ek user tak seemit hai, par L2 cache global hai. Iske liye humein **EhCache** ya **Redis** use karna padta hai. Ye un cheezo ke liye best hai jo baar-baar padhi jati hain par badalti kam hain (Jaise India ke states ki list).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Library ki Almaree.</strong> <br>
+            <em>L1 (Desk):</em> Aapne book apne table pe rakhi. Sirf aap padh sakte ho.<br>
+            <em>L2 (Almaree):</em> Ye sabke liye common hai. Agar ek ladke ne book wapas rakhi, to dusra wahi se utha lega. Nayi kharidne (Database jane) ki zarurat nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Common Fridge.</strong> <br>
+            <em>L1:</em> Aapka lunch box (Personal).<br>
+            <em>L2:</em> Office ka Fridge. Isme rakha saman koi bhi access kar sakta hai.`,
+            strategy: `Lead: "Since L2 cache is global, we must be careful about 'stale data'. We usually use 'Read-Only' strategy for reference data."`
+        },
+        {
+            id: 52,
+            title: "How to prevent Singleton Pattern from Serialization?",
+            eng: `If you serialize and then deserialize a Singleton class, Java creates a **new instance** by default, breaking the Singleton rule (One object only).<br><br>To prevent this, you must implement the <code>readResolve()</code> method in your Singleton class. Inside this method, you simply return the existing instance. This tells the JVM: "Don't create a new object from the stream, just use the one I already have."<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Sim Card Replacement.</strong> When you lose your phone and ask for a new SIM (Deserialization), the company doesn't give you a new number. They map the new SIM to your **existing number** (Instance). They resolve it to the old identity.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Reincarnation (Soul).</strong> Even if the body changes (Serialization/Deserialization), the Soul (Instance) remains the same. The soul is resolved to the original one.`,
+            hinglish: `Agar aap Singleton object ko file mein save (Serialize) karke wapas load (Deserialize) karte ho, to Java galti se ek **naya object** bana deta hai. Isse Singleton ka rule toot jata hai.<br><br>Isse rokne ke liye hum class mein <code>readResolve()</code> method likhte hain. Isme hum bolte hain: "Naya mat banao, purana wala hi return karo."<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Aadhar Card Copy.</strong> Agar aap Aadhar card ki photo copy (Deserialization) nikalte ho, to wo naya insaan nahi ban jata. Wo usi purane insaan ko darshata hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Duplicate Key.</strong> Chabi nayi banwayi, par wo lagti usi purane taale mein hai. Naya tala nahi banta.`,
+            strategy: `Say: "Serialization is just one enemy. Another enemy of Singleton is **Cloning**." (This triggers the next question).`
+        },
+        {
+            id: 53,
+            title: "Explain try, catch and finally in Java?",
+            eng: `This is the core of Exception Handling flow.<br>1. **try:** The block where you write "risky" code that might fail (like opening a file).<br>2. **catch:** The block that runs *only* if an error occurs in the try block. It handles the problem (logs error, shows message).<br>3. **finally:** The block that runs *always*, regardless of success or failure. It is used for cleanup (closing Wi-Fi, Database, Files).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Learning to Ride a Bike.</strong><br>
+            <em>try:</em> Ride the bike.<br>
+            <em>catch:</em> If you fall, apply medicine (Handle error).<br>
+            <em>finally:</em> Park the bike in the garage (Cleanup). You do this whether you fell or rode successfully.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Eating Food.</strong><br>
+            <em>try:</em> Eat the food.<br>
+            <em>catch:</em> If spicy, drink water.<br>
+            <em>finally:</em> Wash your hands. You wash hands whether the food was spicy or not.`,
+            hinglish: `Ye Exception handle karne ka flow hai:<br>1. **try:** Yahan wo code likho jisme risk hai (jaise file kholna).<br>2. **catch:** Agar galti hui, to ye chalega (Error pakadna).<br>3. **finally:** Ye hamesha chalega, chahe error aaye ya na aaye. (Safai karne ke liye).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bike Chalana.</strong><br>
+            <em>try:</em> Bike chalao.<br>
+            <em>catch:</em> Agar gire, to bandage lagao.<br>
+            <em>finally:</em> Bike ko garage mein khadi karo. Girne ya na girne se fark nahi padta, park to karni hi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Online Shopping.</strong><br>
+            <em>try:</em> Payment karo.<br>
+            <em>catch:</em> Payment fail hua to retry karo.<br>
+            <em>finally:</em> App band karo.`,
+            strategy: `Tip: "In Java 7, 'Try-With-Resources' was introduced, which removes the need for the finally block by automatically closing resources."`
+        },
+        {
+            id: 54,
+            title: "How to prevent Singleton Pattern from Cloning?",
+            eng: `Cloning creates a copy of an object. If we clone a Singleton, we get two objects, breaking the rule.<br><br>To prevent this, we override the <code>clone()</code> method inside the Singleton class and throw a <code>CloneNotSupportedException</code>. This ensures that no one can create a duplicate copy.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Government ID.</strong> You cannot legally "Clone" or photocopy a currency note to use it as money. The government (Code) throws an exception (Jail) if you try to replicate the unique instance.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>The Mona Lisa.</strong> There is only one original. If a painter tries to clone it, the museum says "This is a fake, not supported".`,
+            hinglish: `Cloning ka matlab hai copy banana. Agar Singleton ki copy ban gayi, to wo Singleton nahi raha.<br><br>Isse rokne ke liye hum <code>clone()</code> method ko override karte hain aur usme se Error (Exception) fek dete hain. Hum bolte hain "Is class ki copy banana mana hai".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Taj Mahal.</strong> Taj Mahal ek hi hai (Singleton). Agar koi dusra banane ki koshish karega (Clone), to log use reject kar denge.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ungli ke Nishan (Fingerprint).</strong> Aapka fingerprint unique hai. Ise copy nahi kiya ja sakta.`,
+            strategy: `Say: "The third and final way to break a Singleton is through **Reflection**, which is the hardest to stop."`
+        },
+        {
+            id: 55,
+            title: "What is a Constructor in Java?",
+            eng: `A Constructor is a special block of code used to **initialize** an object. It runs automatically when we create an object using the <code>new</code> keyword.<br><br>Key Rules:<br>1. Name must be exactly the same as the Class name.<br>2. It has **no return type** (not even void).<br>3. If you don't write one, Java provides a default (empty) constructor.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Welcome Kit.</strong> When you join a new company (new Object), HR gives you a Welcome Kit (Laptop, ID Card, Notebook). This "Setup" process is the Constructor.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Mobile Setup Wizard.</strong> When you switch on a new phone for the first time, it asks for Language, WiFi, Google ID. It initializes the phone. That is the constructor.`,
+            hinglish: `Constructor ek special method jaisa hota hai jo object ko **start** (initialize) karne ke liye use hota hai. Jaise hi hum <code>new</code> likhte hain, ye apne aap call ho jata hai.<br><br>Rules:<br>1. Iska naam Class ke naam jaisa same hona chahiye.<br>2. Iska koi return type nahi hota.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Naya Ghar.</strong> Jab aap naya ghar lete ho, to pehle 'Griha Pravesh' (Pooja) hoti hai. Wo initialization hai. Wo constructor hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Game Loading.</strong> Jab game start karte ho to "Loading..." aata hai. Wo memory mein sab set kar raha hota hai. Wahi constructor hai.`,
+            strategy: `Trap: "Many people think constructor creates the object. No, the 'new' keyword creates the object. The constructor only 'initializes' (fills data into) it."`
+        },
+        {
+            id: 56,
+            title: "Can Constructors be overloaded?",
+            eng: `**Yes, absolutely.** This is called Constructor Overloading.<br><br>We can have multiple constructors with different parameters. This allows us to create objects in different ways.<br>Example: <code>new Student()</code> (Creates empty student) OR <code>new Student("Rahul")</code> (Creates student with name).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Subway Sandwich.</strong><br>
+            Constructor 1: Just Bread (Budget option).<br>
+            Constructor 2: Bread + Veggies.<br>
+            Constructor 3: Bread + Veggies + Cheese + Mayo.<br>
+            You can initialize your sandwich in multiple ways.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Booking a Ticket.</strong><br>
+            Option 1: Book with just Name.<br>
+            Option 2: Book with Name + Meal Preference.<br>
+            Option 3: Book with Name + Meal + Seat Choice.`,
+            hinglish: `**Haan, bilkul.** Ise Constructor Overloading kehte hain.<br><br>Hum ek class ke kai constructor bana sakte hain, bas unke parameters alag hone chahiye. Isse hum object ko alag-alag tarike se bana sakte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pizza Order.</strong><br>
+            1. Plain Pizza (Sirf bread aur cheese).<br>
+            2. Veg Pizza (Bread + Veggies).<br>
+            3. Loaded Pizza (Sab kuch).<br>
+            Object wahi hai (Pizza), par banane ke tarike alag hain.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Account Kholna.</strong><br>
+            1. Sirf ID proof se.<br>
+            2. ID proof + Pan Card se.<br>
+            3. ID + Pan + Nominee se.`,
+            strategy: `Lead: "We often use \`this()\` inside a constructor to call another constructor of the same class to avoid code duplication. This is called **Constructor Chaining**."`
+        },
+        {
+            id: 57,
+            title: "What is atomic variable in Java?",
+            eng: `Atomic variables (like <code>AtomicInteger</code>, <code>AtomicBoolean</code>) are part of the <code>java.util.concurrent.atomic</code> package. They allow us to perform thread-safe operations on single variables **without using synchronized locks**.<br><br>They use low-level CPU operations (CAS - Compare And Swap) which makes them much faster than using the synchronized keyword for simple counters.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Manual Clicker Counter.</strong> The device used by bouncers to count people. You press a button, it clicks. Even if two people press it fast, the mechanical gear ensures it counts 1, then 2. It never skips.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Token Machine.</strong> It dispenses tokens one by one. It is physically impossible for the machine to give the same token number to two people. It is atomic.`,
+            hinglish: `Atomic variable (jaise <code>AtomicInteger</code>) bina 'synchronized' keyword use kiye thread-safety dete hain.<br><br>Ye 'Lock' nahi lagate, balki CPU ke special hardware features use karte hain. Isliye ye simple ginti (counting) ke liye bahut fast hote hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Digital Tasbeeh/Counter.</strong> Aap button dabate ho, number badhta hai. Agar jaldi-jaldi bhi dabao, to bhi number sahi badhta hai, galti nahi hoti.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Bus ka Darwaza.</strong> Ek baar mein ek hi aadmi chadhta hai. Ye atomic operation hai. Do log ek saath ghusne ki koshish karenge to fas jayenge.`,
+            strategy: `Contrast: "I use AtomicInteger for ID generation or counters, but for complex business logic blocks, I still prefer Synchronized."`
+        },
+        {
+            id: 58,
+            title: "How to prevent Singleton Pattern from Reflection?",
+            eng: `Reflection is powerful; it can access private constructors and create new instances, destroying a Singleton. <br><br>To stop this, we modify the **private constructor** itself. Inside the constructor, we check if an instance already exists. If it does, and someone tries to call the constructor again (via Reflection), we throw an Exception.<br>Alternatively, using **Enums** is the safest way as Java guarantees Enums cannot be instantiated via Reflection.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>VIP Club.</strong> Reflection is like a hacker trying to enter through the back door. To stop him, you put a guard inside the back door (Constructor) who says "If one VIP is already inside, DO NOT let anyone else in, even if they have a key".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Highlander.</strong> "There can be only one." If magic (Reflection) tries to create another warrior, the universe throws an error.`,
+            hinglish: `Reflection Java ka "Hacker" tool hai. Ye private constructor ko bhi call kar sakta hai.<br><br>Isse bachne ke liye hum Constructor ke andar hi code likh dete hain: "Agar object pehle se bana hua hai, aur tum firse banane aaye ho, to main Error fek dunga."<br>Sabse best tarika hai **Enum** use karna, kyunki Enum ko Reflection bhi nahi tod sakta.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Chor Darwaza.</strong> Reflection chor darwaze se ghusne jaisa hai. Hum wahan bhi taala laga dete hain (Constructor check) ki agar koi ghusne ki koshish kare to alarm baj jaye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ek Myaan mein do talwar.</strong> Constructor bolta hai "Ek talwar pehle se hai, dusri nahi aa sakti".`,
+            strategy: `Strategy: "This completes the Singleton discussion. Mentioning Enums as the ultimate solution usually impresses interviewers."`
+        },
+        {
+            id: 59,
+            title: "What is super keyword in Java?",
+            eng: `The <code>super</code> keyword is a reference variable used to refer to the **immediate Parent class** object.<br><br>Uses:<br>1. <code>super.variable</code>: To access parent class variable (if child hid it).<br>2. <code>super.method()</code>: To call parent class method (if child overrode it).<br>3. <code>super()</code>: To call the Parent class constructor (must be the first line).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Family Business.</strong> You run a shop. You have your own rules. But sometimes you need to check "What did Dad do?". You use <code>super.rule()</code> to refer to your father's original rule.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Genetics.</strong> You have blue eyes. Your dad had brown eyes. If you want to refer to your dad's eye color in code, you say <code>super.eyeColor</code>.`,
+            hinglish: `<code>super</code> keyword ka matlab hai "Mera Parent".<br><br>Iske 3 kaam hain:<br>1. Parent ka variable use karna.<br>2. Parent ka method call karna (agar humne override kar diya ho).<br>3. Parent ka constructor call karna (<code>super()</code>).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Papa ki Rai.</strong> Aapne apna faisla liya (Override). Par agar aapko Papa ka purana faisla janna hai, to aap <code>super</code> use karoge.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ghar ka Naksha.</strong> Aapne upar wala floor apne hisab se banaya. Par neeche wala floor (Parent) waisa hi hai. Usko access karne ke liye super lagta hai.`,
+            strategy: `Trap: "Remember, \`super()\` must ALWAYS be the first statement in a constructor. You cannot write logic before calling the parent constructor."`
+        },
+        {
+            id: 60,
+            title: "What is this keyword in Java?",
+            eng: `The <code>this</code> keyword refers to the **Current Object** (the object calling the method).<br><br>Uses:<br>1. To differentiate between instance variables and parameters with the same name (e.g., <code>this.name = name</code>).<br>2. To call another constructor of the same class (<code>this()</code>).<br>3. To pass the current object as a parameter to another method.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pointing to Yourself.</strong> If in a group photo someone asks "Who is the leader?", you point to yourself and say "This guy" (Me).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>My Home.</strong> When you are inside your house, you call it "This house". When you are outside, you call it "That house". <code>this</code> works only when you are inside the object.`,
+            hinglish: `<code>this</code> ka matlab hai "Main Khud" (Current Object).<br><br>1. Agar variable ka naam same hai, to <code>this.name</code> batata hai ki "Mera class wala variable", local wala nahi.<br>2. Constructor chaining ke liye <code>this()</code> use hota hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Apni Taraf Ishara.</strong> Jab aap bolte ho "Main", to aap <code>this</code> keyword use kar rahe ho.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Mera Phone.</strong> Agar table pe 10 phone pade hain, to aap apna utha ke bologe "THIS is my phone". Specific object ki baat ho rahi hai.`,
+            strategy: `Contrast: "Unlike \`super\`, \`this\` refers to the current instance. Also, we cannot use \`this\` inside a static context (like main method) because static belongs to the class, not an object."`
+        },
+        {
+            id: 61,
+            title: "Can constructors have a return type?",
+            eng: `**No.** If you add a return type (like <code>void</code> or <code>int</code>) to a constructor, it is **no longer a constructor**. It becomes a regular method with the same name as the class.<br><br>This is a common interview trick. Even <code>void Student() { }</code> is NOT a constructor; it is just a method that happens to be named Student.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Born vs Named.</strong> Being born (Constructor) is an event. You don't "return" anything. If you name a task "Born", it's just a task, not the actual birth event.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Opening a Box.</strong> The act of opening (Constructor) sets up the box. It doesn't return a number. If a function returns a number, it's a calculator, not an opener.`,
+            hinglish: `**Nahi.** Agar aapne return type (jaise <code>void</code>) laga diya, to wo constructor nahi rahega. Wo ek mamooli method ban jayega.<br><br>Ye ek trick hai. <code>void Student()</code> constructor nahi hai, ye bas ek method hai jiska naam Student hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Naam vs Kaam.</strong> Constructor ka kaam hai banana. Wo wapas kuch nahi deta. Agar wo wapas kuch de raha hai, to wo constructor nahi, dukan hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Shaadi.</strong> Shaadi ek event (Constructor) hai jo do logo ko jodta hai. Ye koi product return nahi karta.`,
+            strategy: `Say: "The compiler will not give an error, but the object won't initialize properly, leading to logical bugs."`
+        },
+        {
+            id: 62,
+            title: "What is differnce between Stack memory and Heap memory?",
+            eng: `**Stack Memory:**<br>1. Stores method calls and **local variables**. <br>2. Works on LIFO (Last In First Out).<br>3. Very fast access but small size.<br>4. Variables here die as soon as the method ends.<br><br>**Heap Memory:**<br>1. Stores **Objects** (anything created with 'new').<br>2. Global access (any thread can access objects if they have reference).<br>3. Slower access but huge size.<br>4. Objects here live until Garbage Collector destroys them.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Stack:</em> **To-Do List sticky note.** You write a task, do it, throw the note away. Short term.<br>
+            <em>Heap:</em> **Warehouse.** You store big furniture (Objects) here. They stay until you hire a mover (Garbage Collector) to remove them.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Stack:</em> **Plate in hand.** You hold it while eating. When done, you put it away.<br>
+            <em>Heap:</em> **Buffet Table.** All the food is kept there. Anyone with a plate (Reference) can go take it.`,
+            hinglish: `**Stack Memory:**<br>1. Ye **Temporary** hoti hai. Method chala, variable bana. Method khatam, variable khatam.<br>2. Bahut fast hoti hai.<br><br>**Heap Memory:**<br>1. Ye **Permanent** storage hai Objects ke liye (jab tak GC delete na kare).<br>2. Sare <code>new Student()</code> yahan bante hain.<br>3. Badi hoti hai par thodi slow.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Stack:</em> **Jeb (Pocket).** Jo abhi chahiye wo jeb mein rakha. Kaam khatam, nikal diya.<br>
+            <em>Heap:</em> **Godown.** Badi cheezein wahan store hoti hain. Jab tak safai wala (GC) na aaye, wahi rahengi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Stack:</em> **Backpack.** Sirf aapka saman.<br>
+            <em>Heap:</em> **Luggage Room.** Sabka saman ek saath.`,
+            strategy: `Lead: "If Stack is full, we get StackOverflowError (Infinite recursion). If Heap is full, we get OutOfMemoryError."`
+        },
+        {
+            id: 63,
+            title: "What is the difference between Hibernate and JPA?",
+            eng: `**JPA (Java Persistence API)** is a **Specification** (A set of Rules/Interface). It is just a document that says "How Java should connect to Databases". It has no code.<br><br>**Hibernate** is the **Implementation** (The Tool). It follows JPA rules and writes the actual code to do the work. <br><br>Analogy: JPA is the Interface, Hibernate is the Class implementing it.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JPA:</em> **Traffic Rules Book.** It says "Stop at Red Light". It cannot stop your car.<br>
+            <em>Hibernate:</em> **Traffic Police.** He actually stops your car. He follows the rules written in the book.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JPA:</em> **Menu Card.** It lists "Pizza". You can't eat the menu.<br>
+            <em>Hibernate:</em> **Chef.** He actually cooks the Pizza listed on the menu.`,
+            hinglish: `**JPA** ek **Specification** (Rule Book) hai. Ye bas batata hai ki kaam kaise hona chahiye. Ye khud kaam nahi karta.<br><br>**Hibernate** ek **Implementation** (Tool) hai. Ye JPA ke rules padhta hai aur asli kaam (Database save/fetch) karta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JPA:</em> **Cricket Rule Book.** Kitab mein likha hai "6 run kaise lagenge".<br>
+            <em>Hibernate:</em> **Dhoni/Kohli.** Ye player hain jo us rule ke hisab se ground pe khelte hain.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JPA:</em> **Naksha (Map).** Rasta dikhata hai.<br>
+            <em>Hibernate:</em> **Driver.** Jo us nakshe ko dekh ke gadi chalata hai.`,
+            strategy: `Say: "We always code to the JPA interfaces (EntityManager) so that we can switch Hibernate with another provider (like EclipseLink) in the future easily."`
+        },
+        {
+            id: 64,
+            title: "What is an Association in Java?",
+            eng: `Association represents a **relationship** between two classes. It means "Objects of Class A know about Objects of Class B".<br><br>It creates a "Has-A" relationship. Example: A Teacher *has* Students. A Doctor *has* Patients. <br>Association can be One-to-One, One-to-Many, or Many-to-Many. It is the broad term for Aggregation and Composition.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bank and Customer.</strong> A Bank is associated with a Customer. They interact, but they are separate entities.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Driver and Car.</strong> A Driver uses a Car. They are associated.`,
+            hinglish: `Association ka matlab hai do classes ke beech **Rishta** (Relationship).<br><br>Matlab Class A, Class B ko janti hai. Jaise Teacher aur Student. Ye sabse upar ka term hai. Iske do bachhe hain: Aggregation aur Composition.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Doctor aur Patient.</strong> Doctor ka rishta patient se hai. Ye Association hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Main aur Mera Phone.</strong> Hum dono jude hue hain.`,
+            strategy: `Lead: "The key question is how strong this relationship is. That decides if it's Aggregation or Composition."`
+        },
+        {
+            id: 65,
+            title: "What is an Aggregation in Java?",
+            eng: `Aggregation is a **Weak Association**. It represents a "Has-A" relationship where both objects can **exist independently**.<br><br>If the main object is destroyed, the dependent object *survives*.<br>Example: A **Team** consists of **Players**. If the Team dissolves, the Players still exist as humans. They don't die.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Library and Books.</strong> If the Library burns down (Class A dies), the Books (Class B) checked out by students still exist. They are not destroyed.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Car and Music Player.</strong> If you sell the car, you can remove the music player and keep it. They are loosely coupled.`,
+            hinglish: `Aggregation ek **Kamzor Rishta** (Weak bond) hai.<br><br>Isme agar Main object mar bhi jaye, to dusra object zinda rehta hai. Dono alag-alag reh sakte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Team aur Players.</strong> Agar IPL team RCB khatam ho jaye, to Virat Kohli (Player) marega nahi. Wo kisi aur team mein chala jayega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Classroom aur Students.</strong> Agar Classroom toot jaye, to Students ghar chale jayenge. Wo classroom ke saath khatam nahi honge.`,
+            strategy: `Lead: "On the other hand, Composition is a strong relationship where death of one means death of the other."`
+        },
+        {
+            id: 66,
+            title: "What is Composition in Java?",
+            eng: `Composition is a **Strong Association**. It represents a relationship where the dependent object **cannot exist** without the main object.<br><br>If the main object is destroyed, the child object is also destroyed instantly.<br>Example: A **Human** and **Heart**. If the Human dies, the Heart dies too. The heart cannot exist roaming around alone.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>House and Rooms.</strong> If you demolish the House, the Kitchen and Bedroom are automatically destroyed. A Bedroom cannot exist without a House.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Book and Pages.</strong> If you burn a Book, the Pages are burnt too. Pages have no identity without the Book.`,
+            hinglish: `Composition ek **Mazboot Rishta** (Strong bond) hai.<br><br>Isme agar Baap (Parent) mara, to Beta (Child) bhi mar jayega. Child akele zinda nahi reh sakta.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Insaan aur Dil.</strong> Agar Insaan mara, to Dil bhi ruk jayega. Dil body ke bina nahi reh sakta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ghar aur Kamre.</strong> Agar ghar tod diya, to kamre apne aap toot jayenge. Hawa mein kamra nahi latak sakta.`,
+            strategy: `Summary: "So, Aggregation is 'Part-of' (optional), Composition is 'Part-of' (mandatory)."`
+        },
+        {
+            id: 67,
+            title: "What is the difference between JDBC and Hibernate?",
+            eng: `**JDBC** is low-level. You have to write SQL queries manually, handle connections, handle exceptions, and map results to Java objects line-by-line (boilerplate). It is fast but tedious.<br><br>**Hibernate** is an ORM (Object Relational Mapper). It sits on top of JDBC. You don't write SQL; you work with Java Objects. Hibernate automatically generates SQL, handles connections, and maps data. It saves massive development time.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JDBC:</em> **Walking.** You control every step. It's manual and tiring.<br>
+            <em>Hibernate:</em> **Taking a Taxi.** You just tell the driver destination (Object). He handles the driving, gears, and route (SQL).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JDBC:</em> **Writing a Letter.** You write every word, put in envelope, stamp it, post it.<br>
+            <em>Hibernate:</em> **Sending WhatsApp.** You type and hit send. The app handles transmission protocols.`,
+            hinglish: `**JDBC** purana aur manual hai. Isme SQL khud likhni padti hai. Result ko Java object mein badalne ke liye bahut code likhna padta hai.<br><br>**Hibernate** automatic hai. Aap bas Java object save karte ho, Hibernate khud SQL banata hai aur database mein dalta hai. Ye developer ka kaam aasan karta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>JDBC:</em> **Kapde dhona (Haath se).** Pani dalo, sabun lagao, ghisso. (Manual).<br>
+            <em>Hibernate:</em> **Washing Machine.** Kapde dalo, button dabao. Machine khud dho degi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>JDBC:</em> **Raw Material.**<br>
+            <em>Hibernate:</em> **Finished Product.**`,
+            strategy: `Say: "However, for extremely complex batch queries where Hibernate generates inefficient SQL, we fallback to JDBC or Native SQL for performance."`
+        },
+        {
+            id: 68,
+            title: "What are Annotations in Java?",
+            eng: `Annotations are **Metadata** (Data about Data). They provide information to the Compiler or JVM but do not change the direct logic of the code.<br><br>They start with <code>@</code>. They are used for:<br>1. **Compiler Instructions:** <code>@Override</code>, <code>@Deprecated</code>.<br>2. **Configuration:** <code>@SpringBootApplication</code>, <code>@Entity</code>.<br>3. **Testing:** <code>@Test</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Sticky Notes.</strong> You put a sticky note on a file saying "Urgent". The note is not part of the file content, but it tells the boss how to treat the file.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Price Tag.</strong> The tag on a shirt is not the shirt itself. It gives info (Price, Size) to the cashier (Compiler).`,
+            hinglish: `Annotations **Tags** ya labels hote hain jo code ke upar lagaye jate hain (<code>@</code> se).<br>Ye code ka logic change nahi karte, bas Compiler ya Framework ko extra jankari dete hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Parchee (Label).</strong> Dabbey pe likha hai "Kaanch ka saman". Ye andar ke saman ko badalta nahi hai, bas uthane wale ko batata hai ki dhyaan rakhe.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Traffic Signs.</strong> Sadak pe sign laga hai "School Ahead". Sadak wahi hai, bas sign aapko bata raha hai ki speed dheere rakho.`,
+            strategy: `Tip: "Annotations became massive with Spring Boot. Before that, we used XML configuration which was very messy."`
+        },
+        {
+            id: 69,
+            title: "What is DateTime API in Java?",
+            eng: `Before Java 8, <code>java.util.Date</code> was mutable and not thread-safe. It was a headache.<br><br>Java 8 introduced a new API (<code>java.time</code> package) which is **Immutable** and **Thread-Safe**. Key classes:<br>1. **LocalDate:** Date only (2025-10-10).<br>2. **LocalTime:** Time only (10:00 AM).<br>3. **LocalDateTime:** Both.<br>4. **ZonedDateTime:** Handles timezones.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>New Calendar.</strong> The old calendar (Date) had pages that could be torn and changed by anyone (Mutable). The new Calendar is engraved in stone (Immutable). You can't change today's date, you can only create a new date object for tomorrow.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Wall Clock.</strong> Old API was like a clock where anyone could move the hands. New API is like a digital server clock that no one can touch.`,
+            hinglish: `Pehle Java mein Date handle karna bahut mushkil tha. Purani Date class kharab thi (Mutable thi).<br><br>Java 8 mein naya API aaya jo **Immutable** hai. Matlab Date object ek baar ban gaya to change nahi ho sakta.<br>Example: <code>LocalDate</code>, <code>LocalTime</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Patthar ki Lakeer.</strong> Naya Date API patthar ki lakeer jaisa hai. Change nahi hoga. Purana wala pencil se likha tha, koi bhi mita deta tha.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Digital Watch.</strong> Purani suiyan wali ghadi (Date) aage piche kar sakte the. Nayi Satellite watch (LocalDate) ko ched nahi sakte.`,
+            strategy: `Say: "I use LocalDate usually, but for global applications, I prefer **Instant** or **ZonedDateTime** to handle GMT/UTC conversions correctly."`
+        },
+        {
+            id: 70,
+            title: "What are 4 main default Functional Interfaces in Java?",
+            eng: `Java 8 provided 4 built-in functional interfaces in <code>java.util.function</code> package so we don't have to create our own:<br><br>1. **Predicate:** Takes 1 argument, returns **Boolean**. (Check condition).<br>2. **Function:** Takes 1 argument, returns **Result**. (Transform data).<br>3. **Consumer:** Takes 1 argument, returns **Nothing (void)**. (Print/Save data).<br>4. **Supplier:** Takes NO argument, returns **Result**. (Factory/Provide data).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Predicate:</em> **Bouncer.** Checks ID. Returns Yes/No.<br>
+            <em>Function:</em> **Juicer.** Takes Fruit -> Gives Juice.<br>
+            <em>Consumer:</em> **Dustbin.** Takes trash -> Gives nothing back.<br>
+            <em>Supplier:</em> **News Paper Boy.** Takes nothing -> Gives News Paper.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Predicate:</em> Exam Result (Pass/Fail).<br>
+            <em>Function:</em> Math Calculator (Input 2 -> Output 4).<br>
+            <em>Consumer:</em> Printer (Takes file -> Prints it).<br>
+            <em>Supplier:</em> Milkman (Delivers milk).`,
+            hinglish: `Java ne humein 4 bane-banaye interface diye hain:<br><br>1. **Predicate:** Sawal puchta hai (Sahi/Galat). Example: Kya x > 10 hai?<br>2. **Function:** Badalta hai. Example: Aloo lo -> Sona do.<br>3. **Consumer:** Khata hai. Example: Data liya aur database mein save kar diya (Wapas kuch nahi diya).<br>4. **Supplier:** Deta hai. Example: OTP Generator (Maangne pe OTP deta hai).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Predicate:</em> **Security Guard.** (Card hai? Haan/Na).<br>
+            <em>Function:</em> **Chakki.** (Gehu dalo -> Aata nikalo).<br>
+            <em>Consumer:</em> **Bhukkad.** (Khana do, badle mein kuch mat mango).<br>
+            <em>Supplier:</em> **ATM.** (Paise deta hai).`,
+            strategy: `Tip: "Streams API uses these heavily. filter() uses Predicate, map() uses Function, forEach() uses Consumer."`
+        },
+        {
+            id: 71,
+            title: "What are stereotype annotations in Spring?",
+            eng: `Stereotype annotations tell Spring "What kind of role this class plays". They are all children of <code>@Component</code>.<br><br>1. **@Component:** Generic bean.<br>2. **@Service:** For Business Logic.<br>3. **@Repository:** For Database/DAO layer (Translates SQL exceptions).<br>4. **@Controller:** For Web layer (Handling Requests).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hospital Staff Badges.</strong> Everyone is an Employee (@Component). But they have specific badges: "Doctor" (@Service), "Surgeon" (@Controller), "Pharmacist" (@Repository). The badge tells you their specific job.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Construction Site.</strong> All are Workers. But you have specific helmets: "Engineer", "Laborer", "Architect".`,
+            hinglish: `Ye Spring ko batate hain ki "Ye class karti kya hai?".<br><br>1. **@Service:** Business logic (Dimaag).<br>2. **@Repository:** Database code (Godown).<br>3. **@Controller:** Request handle karna (Receptionist).<br>Agar hum sab jagah sirf @Component lagayein to bhi chalega, par ye specific naam code padhne mein help karte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Cricket Team.</strong> Sab 'Player' (@Component) hain. Par koi 'Batsman' (@Service) hai, koi 'Bowler' (@Repository) hai, koi 'Captain' (@Controller) hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>School.</strong> Sab Staff hain. Par Principal, Teacher, Peon alag-alag role play karte hain.`,
+            strategy: `Lead: "A common question is: Can we swap @Service with @Repository? Technically yes, but we lose specific features like Exception Translation in Repository."`
+        },
+        {
+            id: 72,
+            title: "What are Design Patterns in Java?",
+            eng: `Design patterns are **proven solutions to common problems**. They are not code; they are blueprints/concepts.<br><br>Categories:<br>1. **Creational:** How to create objects (Singleton, Factory, Builder).<br>2. **Structural:** How to connect objects (Adapter, Decorator).<br>3. **Behavioral:** How objects talk to each other (Observer, Strategy).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Standard Plug Points.</strong> All electrical plugs follow a pattern (3 pins). This is a standard solution so any device fits any socket. You don't invent a new plug shape for every fan.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Traffic Circle (Roundabout).</strong> Instead of a complex 4-way signal, civil engineers use a Roundabout pattern. It solves the problem of traffic jams efficiently.`,
+            hinglish: `Design Patterns **bane-banaye solutions** hain common problems ke liye. Ye best practices hain.<br><br>1. **Creational:** Object kaise banana hai (Singleton).<br>2. **Structural:** Class kaise jodna hai (Adapter).<br>3. **Behavioral:** Baat kaise karni hai (Observer).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ghar ka Naksha.</strong> Kitchen hamesha Hall ke paas hota hai. Ye ek pattern hai. Bathroom kabhi Kitchen ke andar nahi hota. Ye proven design hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Car ke Tyres.</strong> Har car mein 4 tyre hote hain. Ye pattern hai. Koi 3 ya 5 tyre nahi lagata kyunki 4 wala pattern best kaam karta hai.`,
+            strategy: `Say: "I frequently use **Singleton** (Spring Beans), **Factory** (creating objects), and **Builder** (complex objects) in my daily work."`
+        },
+        {
+            id: 73,
+            title: "What is Cloning in Java?",
+            eng: `Cloning is the process of creating an exact copy of an object. We use the <code>clone()</code> method from the Object class.<br><br>To support cloning, a class must implement the <code>Cloneable</code> interface. <br>Types:<br>1. **Shallow Copy:** Copies fields. If a field is an object, it copies the reference (both point to same inner object).<br>2. **Deep Copy:** Recursively creates copies of inner objects too (Totally separate).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Shallow Copy:</em> **Shared Google Doc.** You share a link. If one person edits, the other sees changes.<br>
+            <em>Deep Copy:</em> **Photocopy.** You photocopy a paper. If you write on the copy, the original does NOT change.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Shallow:</em> House keys given to two people.<br>
+            <em>Deep:</em> Building a second identical house next door.`,
+            hinglish: `Cloning ka matlab hai **Copy banana**.<br><br>Do tarah ki hoti hai:<br>1. **Shallow Copy (Upar-upar se):** Isme agar object ke andar koi list hai, to list copy nahi hoti, bas uska address copy hota hai. Dono object ek hi list share karte hain.<br>2. **Deep Copy (Gehrai se):** Isme sab kuch naya banta hai. Pura duplicate.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Shallow:</em> **Room Key share karna.** Dono ke paas key hai, par room ek hi hai.<br>
+            <em>Deep:</em> **Naya Room banana.** Bilkul waisa hi dusra room bana diya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Shallow:</em> Forwarded Message (Source same hai).<br>
+            <em>Deep:</em> Copy-Paste Text (Ab ye naya text ban gaya).`,
+            strategy: `Warning: "Cloning is tricky and often broken. Josh Bloch (author of Effective Java) recommends using **Copy Constructors** instead of clone()."`
+        },
+        {
+            id: 74,
+            title: "What are Wrapper classes in Java?",
+            eng: `Wrapper classes are Object representations of primitive data types.<br><br>Java has primitives (int, char, double) for speed. But Collections (List, Map) **cannot store primitives**. They only store Objects. So we "Wrap" the primitive int into an <code>Integer</code> object to put it in a List.<br>Auto-boxing handles the conversion automatically.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Chocolate Wrapper.</strong> The chocolate (int) is the raw material. To sell it in a shop (Collection), you must put it in a Wrapper (Integer). You can't put raw liquid chocolate on the shelf.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Gift Packing.</strong> A toy (primitive) is raw. To give it as a present (Object), you wrap it in a box.`,
+            hinglish: `Wrapper class primitive (int, float) ko **Object** banati hai.<br><br>List ya ArrayList mein hum <code>int</code> nahi rakh sakte. Wahan sirf Object aa sakta hai. Isliye hum <code>int</code> ko <code>Integer</code> wrapper mein lapet dete hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Toffee ka Wrapper.</strong> Toffee (int) sticky hoti hai. Use jeb (List) mein rakhne ke liye Wrapper (Integer) chahiye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Capsule.</strong> Dawai ka powder (primitive) khula nahi kha sakte. Use Capsule cover (Wrapper) mein daal ke khate hain.`,
+            strategy: `Tip: "Remember, comparing wrappers with == is dangerous because of caching logic. Always use .equals() for Wrapper objects."`
+        },
+        {
+            id: 75,
+            title: "Does Java has Copy Constructor?",
+            eng: `Java does **not** provide a default Copy Constructor (unlike C++). However, we can create one manually.<br><br>A Copy Constructor is a constructor that takes an object of the *same class* as a parameter and copies its values to the new object. It is preferred over <code>clone()</code>.<br>Example: <code>Student(Student s) { this.name = s.name; }</code><br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Backup Key.</strong> You go to a key-maker. You give him your Key (Object). He looks at it and cuts a new Key (New Object) exactly like the first one. That's a Copy Constructor.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Xerox Machine.</strong> You put a paper (Object 1). The machine creates a Paper (Object 2) with the same content.`,
+            hinglish: `Java apne aap Copy Constructor **nahi** deta (C++ deti hai). Par hum khud bana sakte hain.<br><br>Ye ek aisa constructor hota hai jo purane object ko input leta hai aur naya object bana deta hai same data ke saath. Ye clone() se behtar tarika hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Notes Copy karna.</strong> Aap apne dost ki copy (Object 1) lete ho, aur apni copy (Object 2) mein same likh lete ho. Ye copy constructor hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Duplicate Sim.</strong> Purani Sim kho gayi. Dukandar ne purani Sim ki details (Input) leke nayi Sim bana di.`,
+            strategy: `Lead: "Copy constructors are great for creating Deep Copies easily."`
+        },
+        {
+            id: 76,
+            title: "What is Package in Java?",
+            eng: `A Package is a namespace that organizes a set of related classes and interfaces. It helps in:<br>1. **Preventing Naming Conflicts:** You can have two classes named <code>Date</code> if they are in different packages (java.util vs java.sql).<br>2. **Access Control:** Protected and Default members are accessible only within the package.<br>3. **Organization:** Keeping 'Controllers', 'Services', and 'Models' in separate folders.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Folders on Computer.</strong> You can have "Photo.jpg" in the 'Holiday' folder and another "Photo.jpg" in the 'Work' folder. The folder (Package) prevents conflict.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Surnames.</strong> There are many people named "Rahul". But "Rahul Sharma" and "Rahul Verma" are different. The Surname acts like a Package to identify them uniquely.`,
+            hinglish: `Package ek Folder jaisa hota hai jo classes ko organize karta hai.<br><br>Iske 2 main fayde hain:<br>1. **Naam ka jhagda nahi hota:** Do classes ka naam 'Student' ho sakta hai agar unke package alag hon.<br>2. **Saja ke rakhna:** Hum khane ka saman 'Kitchen' (package) mein rakhte hain aur kapde 'Bedroom' (package) mein. Mix nahi karte.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Laptop Folders.</strong> 'Movies' folder alag hai, 'Documents' folder alag hai. Taaki dhoondna aasan ho.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>City Areas.</strong> 'MG Road'. Har sheher mein MG road hoti hai. Pune.MG_Road alag hai, Mumbai.MG_Road alag hai.`,
+            strategy: `Tip: "Standard naming convention is reverse domain name: com.company.project."`
+        },
+        {
+            id: 77,
+            title: "What happens when the main() isn't declared as static?",
+            eng: `The program will **compile successfully**, but it will **fail at runtime**.<br><br>When you run the program, the JVM looks for the exact signature <code>public static void main(String[] args)</code>. If <code>static</code> is missing, the JVM cannot call the method without creating an object, and since it doesn't know how to create the object of your class, it throws a <code>NoSuchMethodError</code> or "Main method not found".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Keyless Entry.</strong> Static is like a keyless entry. The JVM can enter immediately. Non-static requires a Key (Object). If JVM has no key, it stands outside and shouts "Error".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Calling the Boss.</strong> Static main is like the Boss's public hotline. Anyone can call. Non-static is like his personal mobile—you need an appointment (Object) to call. JVM doesn't have an appointment.`,
+            hinglish: `Program **Compile ho jayega** (koi red line nahi aayegi).<br>Par jab **Run** karoge, to Error aayega.<br><br>Kyunki JVM ko sikhaya gaya hai ki bina object banaye ghusna hai (Static). Agar aap static hata doge, to JVM andar ghus hi nahi payega. Wo bolega "Main method nahi mila".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Public Park.</strong> Static main Public Park hai (Koi bhi aao). Non-static main Private Ghar hai (Bina chabi/object ke entry nahi). JVM ke paas chabi nahi hoti.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Start Button.</strong> Gadi ka Start button (Main) hamesha accessible hona chahiye. Agar start button dabane ke liye pehle gadi start karni pade, to kaise hoga?`,
+            strategy: `Fact: "In very old versions of Java, it used to run via a static block trick, but that was fixed long ago. Now, main MUST be static."`
+        },
+        {
+            id: 78,
+            title: "Difference between instance and local variables?",
+            eng: `1. **Instance Variable:** Declared inside the class but outside methods. They belong to the Object. They have **default values** (0, null). They live as long as the object lives.<br>2. **Local Variable:** Declared inside a method. They belong to that method only. They generally have **NO default value** (must initialize before use). They die when the method finishes.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Instance:</em> **Your Name.** It stays with you everywhere you go. It is part of you.<br>
+            <em>Local:</em> **Bus Ticket.** It is valid only for that trip (Method). Once the trip ends, the ticket is trash. You don't carry it everywhere.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Instance:</em> **Employee ID.** Permanent.<br>
+            <em>Local:</em> **Lunch Token.** Valid only for one hour in the canteen.`,
+            hinglish: `1. **Instance Variable:** Class ka variable. Ye Object ke saath rehta hai. Iski default value hoti hai (0 ya null).<br>2. **Local Variable:** Method ke andar ka variable. Ye temporary hota hai. Isko initialize karna zaruri hai, nahi to error aayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Instance:</em> **Aapka Chehra.** Ye hamesha aapke saath hai.<br>
+            <em>Local:</em> **Cinema Ticket.** Movie khatam (Method end), ticket khatam. Wo phek diya jata hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Instance:</em> **Ghar ka Furniture.**<br>
+            <em>Local:</em> **Hotel ka Towel.** Use kiya aur wahin chhod diya. Ghar nahi late.`,
+            strategy: `Trap: "If you try to use a local variable without initializing it, you get a Compile Time Error."`
+        },
+        {
+            id: 79,
+            title: "What is Record in Java?",
+            eng: `Introduced in Java 14 (Preview) and 16 (Standard), a **Record** is a concise way to create **immutable data carrier classes**.<br><br>Instead of writing a class with private fields, getters, constructor, <code>toString</code>, <code>equals</code>, and <code>hashCode</code> (Boilerplate), you just write:<br><code>public record User(String name, int age) {}</code><br>Java automatically generates everything for you.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Visiting Card.</strong> A visiting card is just data (Name, Number). It doesn't "do" anything. It doesn't change (Immutable). A Record is exactly like a digital Visiting Card.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>ID Card.</strong> It just holds data. You don't perform calculations on an ID card.`,
+            hinglish: `Record Java 16 mein aaya naya feature hai. Ye **Data Class** banane ka shortcut hai.<br><br>Pehle humein Getter, Setter, Constructor, toString sab khud likhna padta tha. Ab bas ek line likho:<br><code>record Student(String name) {}</code><br>Java baki sab khud bana dega. Ye **Immutable** hota hai (Change nahi kar sakte).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Aadhar Card.</strong> Ye sirf data hold karta hai. Isme koi machine nahi lagi. Bas information hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Menu Card.</strong> Sirf items ke naam aur price likhe hain. Ye change nahi hota.`,
+            strategy: `Say: "I use Records heavily for DTOs (Data Transfer Objects) in Spring Boot to pass data between layers cleanly."`
+        },
+        {
+            id: 80,
+            title: "What is Multithreading in Java?",
+            eng: `Multithreading is the process of executing multiple threads (smaller units of a process) simultaneously to utilize the CPU efficiently.<br><br>Instead of waiting for one task to finish before starting another (Serial), we run them in parallel. It is mostly used in games, animations, and web servers to handle multiple users at once.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Kitchen Chef.</strong> A chef boils milk (Thread 1) on one burner and chops vegetables (Thread 2) on the counter simultaneously. He doesn't wait for the milk to boil before starting to chop. That is multithreading.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Browsing Internet.</strong> You download a file (Thread 1) while scrolling a webpage (Thread 2) while listening to music (Thread 3). All happen together.`,
+            hinglish: `Multithreading ka matlab hai **Ek saath kai kaam karna**.<br><br>Computer ka CPU bahut tez hota hai. Agar hum ek-ek karke kaam karenge to CPU bore ho jayega. Hum use kai kaam ek saath dete hain taaki wo busy rahe.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Rasoi (Kitchen).</strong> Ek gas pe chai ban rahi hai, dusre pe sabji, aur aap aata goond rahe ho. Teeno kaam saath mein chal rahe hain. Ye Multithreading hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Dussehra Ravan Dahan.</strong> Ek haath mein talwar, dusre mein dhaal. Dono haath (Threads) ek saath kaam kar rahe hain.`,
+            strategy: `Lead: "However, with great power comes great responsibility. Multithreading introduces issues like **Deadlock** and **Race Conditions**."`
+        },
+        {
+            id: 81,
+            title: "Explain Thread life cycle?",
+            eng: `A Thread goes through 5 states:<br>1. **New:** Created but not started (<code>new Thread()</code>).<br>2. **Runnable:** Ready to run, waiting for CPU time (<code>start()</code>).<br>3. **Running:** Actually executing code.<br>4. **Blocked/Waiting:** Waiting for I/O or another thread.<br>5. **Terminated:** The task is finished (Dead).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Uber Cab Ride.</strong><br>
+            1. New: You booked a cab.<br>
+            2. Runnable: Cab arrived, waiting for you to sit.<br>
+            3. Running: The ride is active (Moving).<br>
+            4. Blocked: Stuck in Traffic signal.<br>
+            5. Terminated: Reached destination, trip ended.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Athlete Race.</strong><br>
+            1. New: Athlete registers.<br>
+            2. Runnable: Standing at start line (On your mark).<br>
+            3. Running: Sprinting.<br>
+            4. Blocked: Tied shoelace.<br>
+            5. Terminated: Crossed finish line.`,
+            hinglish: `Thread ki zindagi ke 5 padav (stages) hote hain:<br>1. **New:** Paida hua (Code likha).<br>2. **Runnable:** Taiyaar hai (CPU ka wait kar raha hai).<br>3. **Running:** Daud raha hai (Kaam kar raha hai).<br>4. **Blocked:** Ruka hua hai (Kisi ka wait kar raha hai).<br>5. **Terminated:** Mar gaya (Kaam khatam).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Interview Process.</strong><br>
+            1. Resume bheja (New).<br>
+            2. Waiting Room mein baithe ho (Runnable).<br>
+            3. Interview de rahe ho (Running).<br>
+            4. Result ka wait kar rahe ho (Blocked).<br>
+            5. Ghar chale gaye (Terminated).`,
+            strategy: `Tip: "We should never call run() directly. We must call start(), which internally calls run(). Calling run() directly makes it a normal method call, not a thread."`
+        },
+        {
+            id: 82,
+            title: "What are Daemon Threads in Java?",
+            eng: `Daemon threads are **service threads** that run in the background to support user threads. They are low priority.<br><br>The JVM does not wait for Daemon threads to finish. If all User threads (Main thread) finish, the JVM kills all Daemon threads instantly and exits.<br>Example: **Garbage Collector** is a Daemon thread.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Mall Housekeeping Staff.</strong> The shoppers (User Threads) are the main priority. The cleaners (Daemon Threads) work in the background. When the mall closes and all shoppers leave, the cleaners stop and leave too. They don't keep cleaning an empty mall.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Background Music in Game.</strong> The Game logic (User Thread) is main. The background music (Daemon) plays along. If you quit the game, the music stops instantly. It doesn't finish the song.`,
+            hinglish: `Daemon Thread **Sevadar (Helper)** hote hain. Ye background mein chupchap apna kaam karte hain.<br><br>Agar Main program khatam ho jaye, to JVM Daemon threads ko turant band kar deta hai. Wo unke khatam hone ka wait nahi karta.<br>Example: Garbage Collector.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Office Boy.</strong> Jab tak employees (User Threads) kaam kar rahe hain, Office boy chai-pani deta hai. Jab sab employees ghar chale jate hain, to Office boy bhi chala jata hai. Wo akela office mein nahi rukta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Film Extras.</strong> Hero (User Thread) main hai. Piche chalne wale log (Daemon) bas mahaul banate hain. Agar Hero mar gaya (Movie khatam), to Extras ka koi kaam nahi.`,
+            strategy: `Say: "We can make a thread daemon using \`setDaemon(true)\` but only before starting it."`
+        },
+        {
+            id: 83,
+            title: "What is Garbage collection in Java?",
+            eng: `Garbage Collection (GC) is the process of automatic memory management. The JVM automatically identifies objects that are no longer in use (no references point to them) and deletes them to free up Heap memory.<br><br>This saves the programmer from manually deleting memory (like in C++), reducing memory leaks.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Restaurant Table Clearing.</strong> You eat and leave. You don't clean the table. The waiter (Garbage Collector) sees the table is empty (No Reference), comes, and clears the dishes to make space for new customers.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Sweeper Truck.</strong> You throw trash on the street. At night, the sweeper truck comes and collects everything that is useless.`,
+            hinglish: `Garbage Collection (GC) Java ka **Safai Karamchari** hai.<br><br>Jab hum kisi object ko use karna band kar dete hain (Reference null kar dete hain), to GC aata hai aur use memory se delete kar deta hai. Humein khud delete karne ki zarurat nahi padti.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shadi ki Plate.</strong> Log khana kha ke plate wahin chhod dete hain. Waiter (GC) ghoomta rehta hai, jahan khali plate dikhi, use utha le gaya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Mobile Cleaner App.</strong> Jaise app 'Cache' clear karta hai jo zaruri nahi hai, waise hi GC memory clear karta hai.`,
+            strategy: `Lead: "GC is non-deterministic. We can suggest it to run using System.gc(), but we cannot force it."`
+        },
+        {
+            id: 84,
+            title: "What is the difference between HashMap and Hashtable?",
+            eng: `Both store Key-Value pairs, but:<br><br>1. **Synchronization:**<br>HashMap is **NOT synchronized** (Fast, not thread-safe).<br>Hashtable is **Synchronized** (Slow, thread-safe).<br><br>2. **Null Keys:**<br>HashMap allows **one null key** and multiple null values.<br>Hashtable does **NOT allow** any null key or value (throws NullPointerException).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>HashMap:</em> **Open Discussion.** Everyone talks at once. Fast, but chaotic (Not safe).<br>
+            <em>Hashtable:</em> **Courtroom.** Only one person speaks at a time (Synchronized). Slow, but orderly.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>HashMap:</em> **Notepad.** You can scribble anything (Null allowed).<br>
+            <em>Hashtable:</em> **Official Form.** You cannot leave fields blank (Null not allowed).`,
+            hinglish: `Dono Key-Value store karte hain, par:<br><br>1. **Speed:** HashMap fast hai kyunki ye **Non-synchronized** hai (Taala nahi lagata). Hashtable slow hai.<br>2. **Null:** HashMap mein ek null key chalegi. Hashtable mein Null dala to Error aayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>HashMap:</em> **Private Diary.** Fast likho, koi rule nahi.<br>
+            <em>Hashtable:</em> **Sarkari Register.** Line mein lag ke likho (Sync), aur khali mat chodo (No Null).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>HashMap:</em> **General Coach.** Koi bhi ghus jao.<br>
+            <em>Hashtable:</em> **Reserved Coach.** Ticket check karke ek-ek karke entry.`,
+            strategy: `Say: "Hashtable is considered a 'Legacy Class'. Today, if we need thread safety, we use **ConcurrentHashMap**, never Hashtable."`
+        },
+        {
+            id: 85,
+            title: "What is the difference between Call By Value and Call By Reference?",
+            eng: `**Call By Value:** Pass a COPY of the data. If the function changes the copy, the original value does NOT change.<br>**Call By Reference:** Pass the ADDRESS of the data. If the function changes it, the original value changes.<br><br>Crucial Fact: **Java is ALWAYS Call By Value.**<br>When passing objects, Java passes the *value of the reference* (address copy), not the object itself. It looks like reference passing, but technically it's value passing of the address.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Call By Value:</em> **Emailing a Photo.** You send a photo to a friend. If he edits it (draws a mustache), YOUR original photo in your phone does not change.<br>
+            <em>Call By Reference:</em> **Sharing Google Drive Link.** You share the link. If he deletes the file, it is deleted for you too.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Call By Value:</em> **Photocopy.** You give notes photocopy to friend.<br>
+            <em>Call By Reference:</em> **Original Notebook.** You give original notebook to friend.`,
+            hinglish: `**Call By Value:** Copy dena. Agar wo change kare, to aapka original kharab nahi hota.<br>**Call By Reference:** Original dena. Agar wo change kare, to aapka bhi change ho gaya.<br><br>Yaad rakhein: **Java hamesha Call By Value hai.**<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Value:</em> **WhatsApp Photo.** Dost ko photo bheji. Usne delete kar di. Aapke phone mein abhi bhi hai.<br>
+            <em>Reference:</em> **Locker ki Chabi.** Dost ko locker ki chabi di. Usne paise nikal liye. Aapke locker se bhi gaye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Value:</em> **Xerox Notes.**<br>
+            <em>Reference:</em> **Original Register.**`,
+            strategy: `Trap: "Interviewers will ask 'If I pass an Object and change a field, it changes. Isn't that pass by reference?' Answer: No, you passed a copy of the Remote Control. You pointed the copy at the same TV and changed the channel. But you didn't pass the TV itself."`
+        },
+        {
+            id: 86,
+            title: "What is executor framework in Java?",
+            eng: `The Executor Framework (Java 5) allows us to create and manage a **Pool of Threads** instead of manually creating threads (new Thread()).<br><br>It decouples the task submission from task execution. We just throw tasks at the pool, and the pool manages which thread executes which task. It reuses threads, saving memory.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Call Center.</strong> You don't hire a new employee for every single call (creating new Thread). You have a team of 10 people (Thread Pool). When a call comes, an available person takes it. When done, they take the next call.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Restaurant Kitchen.</strong> You have 4 burners (Pool). You get 20 orders. You cook 4 dishes at a time. As soon as one is done, you put the next pan on. You don't buy 20 burners.`,
+            hinglish: `Executor Framework **Thread Pool** manage karta hai.<br><br>Har kaam ke liye naya Thread banana bewakoofi hai (Memory bharegi). Hum 10 Thread ka Pool bana lete hain. Kaam aate jate hain, aur ye 10 threads baari-baari unhe nipatate rehte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bank Counter.</strong> Bank mein 5 counter (Threads) hote hain. Grahak (Tasks) 100 hote hain. Counter wahi rehte hain, grahak badalte rehte hain. Har grahak ke liye naya counter nahi khulta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ola/Uber Drivers.</strong> Driver (Thread) ride complete karta hai, fir turant dusri ride (Task) le leta hai.`,
+            strategy: `Say: "We use \`Executors.newFixedThreadPool(10)\` most commonly to prevent resource exhaustion."`
+        },
+        {
+            id: 87,
+            title: "Why Java is Call by Value?",
+            eng: `Java is Call by Value to ensure **Simplicity and Safety**.<br><br>If Java allowed Call by Reference (like C++ pointers), a method could inadvertently change the reference of a variable in the caller method, pointing it to a completely different object or null. This leads to dangerous bugs and crashes.<br>By passing only the value (copy of address), Java protects the original reference variable from being reassigned.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Valet Parking.</strong> You give the valet your car key (Copy of Reference). He can move your car (Modify object), but he cannot swap your car with a truck (Reassign reference) and make you drive the truck home.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Remote Control.</strong> I give you a copy of my TV remote. You can change the channel (Modify state). But you cannot make my original remote suddenly start controlling the Fridge (Reassign).`,
+            hinglish: `Safety ke liye.<br><br>Agar Java Call by Reference allow karta, to koi bhi method aapke variable ko kisi dusre object se jod sakta tha. Ye bahut dangerous hota.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ghar ki Chabi.</strong> Main aapko apne ghar ki duplicate chabi deta hoon. Aap ghar khol ke TV chori kar sakte ho (Object change). Par aap mere 'Ghar' ko badal ke 'Jhopdi' nahi bana sakte.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Credit Card Add-on.</strong> Maine aapko add-on card diya. Aap kharcha kar sakte ho. Par aap mera main bank account band nahi karwa sakte.`,
+            strategy: `Summary: "It gives us the best of both worlds: safety of references, but flexibility to modify object data."`
+        },
+        {
+            id: 88,
+            title: "How does Thread Pool reuse a thread?",
+            eng: `Normally, a Thread dies after its <code>run()</code> method completes. <br>However, in a Thread Pool, the threads run in an infinite loop (essentially <code>while(true)</code>).<br><br>They wait for a task from a **Task Queue**. When a task arrives, they execute it, and instead of dying, they go back to the queue to ask "Is there more work?". This keeps the thread alive and reusable.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Taxi Driver.</strong> A driver drops a passenger. He doesn't go home and retire (Die). He checks his app (Queue), picks the next passenger, drops them, and repeats. The driver (Thread) is reused for many trips.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Factory Worker.</strong> He stands at the conveyor belt. He packs one box. Then waits. Packs the next box. He stays at his station all day.`,
+            hinglish: `Normal Thread kaam khatam karke mar jata hai.<br><br>Par Thread Pool ka thread ek loop mein chalta hai. Wo **Queue** (Line) ko dekhta rehta hai. Jaise hi kaam aata hai, wo use karta hai, aur fir wapas line mein lag jata hai agle kaam ke liye. Wo marta nahi hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Barber (Naayi).</strong> Naayi ek baal katne ke baad dukan band nahi karta. Wo kursi saaf karta hai aur agle customer ko bulata hai. Wo wahi rehta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Cashier.</strong> Ek customer ka bill banaya, fir agle ka banaya. Wo seat nahi chodta.`,
+            strategy: `Lead: "This pattern uses a **BlockingQueue** internally to hold the tasks."`
+        },
+        {
+            id: 89,
+            title: "What is the difference between Runnable and Callable?",
+            eng: `Both represent a task to be executed by a thread.<br><br>1. **Runnable (Old):**<br>- Method: <code>run()</code>.<br>- Returns: **void** (Cannot return a result).<br>- Exception: Cannot throw checked exceptions.<br><br>2. **Callable (New - Java 5):**<br>- Method: <code>call()</code>.<br>- Returns: **Object** (Can return a result, e.g., fetched data).<br>- Exception: Can throw checked exceptions.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Runnable:</em> **Firing a Rocket.** You press the button. It goes up. You don't get anything back immediately in your hand.<br>
+            <em>Callable:</em> **Ordering Pizza.** You place an order. You wait. You get a Pizza box (Result) back.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Runnable:</em> **Posting a Letter.** You drop it in the box. Done. No immediate reply.<br>
+            <em>Callable:</em> **Phone Call.** You talk, and you get a reply immediately.`,
+            hinglish: `1. **Runnable (Purana):**<br>- Ye kuch wapas nahi deta (void). Bas kaam karta hai aur chup ho jata hai.<br>- Method: <code>run()</code>.<br><br>2. **Callable (Naya):**<br>- Ye kaam karke **Result** wapas deta hai.<br>- Method: <code>call()</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Runnable:</em> **Naukar ko bolna "Safai karo".** Wo safai karega, wapas aake kuch dega nahi.<br>
+            <em>Callable:</em> **Naukar ko bolna "Sabji lao".** Wo jayega aur Sabji (Result) lekar wapas aayega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Runnable:</em> **TV On karna.**<br>
+            <em>Callable:</em> **Bank se Balance check karna** (Balance wapas aayega).`,
+            strategy: `Tip: "Callable is used with **Future** and **ExecutorService**. We submit a Callable and get a Future object back."`
+        },
+        {
+            id: 90,
+            title: "Is Java still relevant in 2024?",
+            eng: `**Yes, massively.**<br><br>1. **Enterprise Dominance:** 90% of Fortune 500 companies run their backends on Java (Spring Boot). Banks, Insurance, Amazon, Netflix all rely on it.<br>2. **Android:** Android development is still heavily Java/Kotlin based.<br>3. **Cloud Native:** With GraalVM and Quarkus, Java is now as fast and light as Go/Node.js for cloud functions.<br>It is not dying; it is evolving.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Concrete Foundations.</strong> New fancy materials come (Python, JS), but big skyscrapers (Banks) are still built on Concrete (Java). It is strong, reliable, and tested.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>English Language.</strong> New slang comes and goes. But official contracts are still written in formal English. Java is the formal language of the Enterprise world.`,
+            hinglish: `**Haan, 100%.**<br><br>1. **Badi Companies:** Duniya ke sare Banks, Amazon, Netflix Java (Spring Boot) use karte hain kyunki ye reliable hai.<br>2. **Jobs:** Java ki jobs sabse zyada hain kyunki purana code maintain karna hai aur naya bhi banana hai.<br>3. **Modern:** Java ab purana nahi raha. 6 mahine mein naya update aata hai. Ab ye Cloud pe bhi fast chalta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Diesel Engine.</strong> Electric cars aa gayi hain, par Trucks aur Train aaj bhi Diesel (Java) pe chalte hain kyunki power chahiye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Purana Chawal.</strong> Chawal jitna purana hota hai, utna mehenga aur acha hota hai. Java wahi purana chawal hai.`,
+            strategy: `Confident Close: "The sheer ecosystem of libraries (Spring, Hibernate, Maven) makes it unbeatable for large scale systems."`
+        },
+        {
+            id: 91,
+            title: "What is Race condition in Multithreading?",
+            eng: `A Race Condition occurs when two or more threads try to access and modify the **same shared resource** simultaneously without proper synchronization.<br><br>The final result depends on the "timing" (race) of the threads. It leads to data corruption or incorrect values because one thread might overwrite the changes made by another.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Joint Bank Account.</strong> Husband and Wife both try to withdraw ₹5000 from an account that has only ₹6000. They swipe cards at the exact same second. If the bank system has a race condition, it might give money to both (-₹10,000) leading to a negative balance error.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Booking the Last Seat.</strong> Two users click "Book Now" for the last movie ticket at the same millisecond. Without synchronization, both get a "Success" message, but there was only one seat.`,
+            hinglish: `Race Condition tab hoti hai jab do threads ek saath ek hi variable ko change karne ki koshish karte hain bina kisi rule ke.<br><br>Result galat aata hai kyunki threads ke beech "Race" lag jati hai ki kaun pehle likhega. Ek thread ka kaam dusra thread overwrite kar deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shared Account.</strong> Pati aur Patni dono ne ek saath card swipe kiya. Account mein paise kam the, par dono ko paise mil gaye kyunki system update hone se pehle hi dusra transaction ho gaya. Ye gadbad hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Musical Chairs.</strong> Ek kursi bachi hai, do log bhaag rahe hain. Agar koi rule nahi hai, to dono ek dusre ke upar baith jayenge (Data Corruption).`,
+            strategy: `Lead: "We solve this using **Synchronized** blocks, **Locks**, or **Atomic Variables** to ensure mutual exclusion."`
+        },
+        {
+            id: 92,
+            title: "What is Deadlock in Multithreading?",
+            eng: `Deadlock is a situation where two threads are waiting for each other to release a lock, but neither can proceed. They get stuck forever.<br><br>Logic: Thread A holds Lock 1 and wants Lock 2. Thread B holds Lock 2 and wants Lock 1. Both are waiting. Infinite waiting.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Two Stubborn Drivers.</strong> Two cars meet on a narrow bridge. Driver A refuses to reverse until B moves. Driver B refuses to reverse until A moves. Traffic stops forever.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Hostage Situation.</strong> Kidnapper says: "Give me money, then I release hostage." Police says: "Release hostage, then we give money." No one moves.`,
+            hinglish: `Deadlock matlab "Gati-rodh". Do threads ek dusre ka intezaar kar rahe hain, aur koi piche hatne ko tayar nahi.<br><br>Thread A ke paas Lock 1 hai, use Lock 2 chahiye. Thread B ke paas Lock 2 hai, use Lock 1 chahiye. Dono atak gaye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pen aur Dhakkan.</strong> Mere paas Pen hai, mujhe Dhakkan chahiye. Tumhare paas Dhakkan hai, tumhe Pen chahiye. Hum dono zidd par ade hain ki "Pehle tu de".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Job aur Experience.</strong> Company kehti hai "Experience lao to Job denge". Banda kehta hai "Job do to Experience aayega". Deadlock.`,
+            strategy: `Solution: "We can prevent Deadlock by ensuring all threads acquire locks in a **Fixed Order** (e.g., always Lock 1 then Lock 2)." `
+        },
+        {
+            id: 93,
+            title: "What is Livelock in Multithreading?",
+            eng: `Livelock is similar to Deadlock, but the threads are **not stuck**; they are active. They are constantly changing their state in response to each other but making no progress.<br><br>They are too polite, giving way to each other endlessly.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Corridor Politeness.</strong> You meet someone in a corridor. You move Left to let them pass. They also move to *their* Right (your Left). Then you both move Right. You keep dancing left-right but never cross each other.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Phone Call Collision.</strong> You call friend -> Busy. You hang up. Friend sees missed call -> Calls you -> Busy. You both keep calling and hanging up perfectly in sync.`,
+            hinglish: `Livelock mein threads marte nahi hain, zinda rehte hain, par kaam fir bhi nahi hota.<br><br>Wo bas ek dusre ko side dene mein hi lage rehte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Raaste mein Takrao.</strong> Aap kisi ke samne aa gaye. Aap Left huye, wo bhi udhar hua. Aap Right huye, wo bhi udhar hua. Aap hil rahe ho (Alive) par aage nahi badh rahe.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Tu Pehle.</strong> "Tu phone kaat", "Nahi tu kaat". Dono line pe hain, par baat khatam nahi ho rahi.`,
+            strategy: `Contrast: "In Deadlock, threads are sleeping (Blocked). In Livelock, threads are running (consuming CPU) but useless."`
+        },
+        {
+            id: 94,
+            title: "Can we create infinite threads in Java?",
+            eng: `**No.** You cannot create infinite threads.<br><br>Each thread consumes memory (Stack Memory). If you keep creating threads, you will eventually run out of memory and hit **java.lang.OutOfMemoryError: unable to create new native thread**.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hiring Employees.</strong> Even if you have infinite work, you cannot hire 1 million employees in a small office. You will run out of chairs (Memory).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Traffic.</strong> You can't put infinite cars on a highway. Eventually, the road jams completely.`,
+            hinglish: `**Nahi.** Infinite threads banana namumkin hai.<br><br>Har thread thodi si memory (RAM) leta hai. Agar aap banate jaoge, to RAM bhar jayegi aur **OutOfMemoryError** aa jayega. Computer hang ho jayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Gubbare (Balloons).</strong> Ek kamre mein aap kitne gubbare phula sakte ho? Kabhi to kamra bhar jayega aur naya gubbara fat jayega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Notebook ke Pages.</strong> Har thread ek page jaisa hai. Notebook (RAM) khatam to thread khatam.`,
+            strategy: `Pivot: "That is exactly why we use a **Thread Pool** (Executor Framework) to limit the number of active threads."`
+        },
+        {
+            id: 95,
+            title: "What is Sealed class?",
+            eng: `Introduced in Java 17, a **Sealed Class** allows you to restrict *which* other classes can extend it. You use the <code>permits</code> keyword.<br><br>Syntax: <code>public sealed class Shape permits Circle, Square {}</code><br>This gives you control over your inheritance hierarchy. Only Circle and Square can be children; no one else.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Visa Policy.</strong> A country says "We only permit citizens of Country A and Country B to enter." Random people cannot enter (Inherit).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Apple Ecosystem.</strong> An iPhone charger works with iPhone, iPad, and AirPods. It does NOT work with Android. Apple has "Sealed" its hardware ecosystem.`,
+            hinglish: `Java 17 ka feature. Sealed class ka matlab hai aap decide karoge ki **kaun aapka child ban sakta hai**.<br><br><code>permits</code> keyword use karke hum batate hain: "Sirf Circle aur Square hi Shape ko extend karenge, koi aur nahi."<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Private Party.</strong> Guard ke paas list hai: "Sirf Rahul aur Amit andar aayenge". Koi teesra banda inherit (andar) nahi aa sakta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Family Property.</strong> Baap ki jaydad sirf beton ko milegi. Padosi aake inherit nahi kar sakta.`,
+            strategy: `Say: "The subclasses of a sealed class must be declared as final, sealed, or non-sealed."`
+        },
+        {
+            id: 96,
+            title: "What is typecasting in Java?",
+            eng: `Typecasting is converting a variable from one data type to another.<br><br>1. **Implicit (Widening):** Automatic. Small type to Big type (int to double). Safe.<br>2. **Explicit (Narrowing):** Manual. Big type to Small type (double to int). Data loss can happen.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Widening:</em> **Pouring a cup of water into a Bucket.** No spill. Easy.<br>
+            <em>Narrowing:</em> **Pouring a Bucket into a Cup.** You have to be careful, water will spill (Data loss).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Widening:</em> **Small kid in big shirt.** Fits easily.<br>
+            <em>Narrowing:</em> **Adult in kid's shirt.** Won't fit unless you cut (truncate) the person.`,
+            hinglish: `Typecasting ka matlab hai data ka roop badalna.<br><br>1. **Implicit (Chote se Bada):** int se double. Ye apne aap hota hai. Pani ko balti mein dalna.<br>2. **Explicit (Bade se Chota):** double se int. Ye zabardasti karni padti hai. Balti ka pani mug mein dalna (Pani girega/Data loss hoga).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Suitcase Packing.</strong> Chote bag ka saman bade bag mein aaram se aa jata hai (Widening). Bade bag ka saman chote mein thusna padta hai (Narrowing).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Currency.</strong> Paise ko Rupaye mein badalna aasan hai.`,
+            strategy: `Trap: "If you cast an object to a class it doesn't belong to, you get **ClassCastException** at runtime."`
+        },
+        {
+            id: 97,
+            title: "What is hashcode() and equals() contract?",
+            eng: `This contract is crucial for HashMaps/HashSets.<br>1. If two objects are **equal** (according to <code>equals()</code>), they **MUST** have the same <code>hashCode()</code>.<br>2. If two objects have the same <code>hashCode()</code>, they are **NOT** necessarily equal (Collision).<br><br>If you override equals(), you MUST override hashCode(). If you violate this, HashMaps will lose your data (put will work, get will return null).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Token System.</strong><br>
+            Token Number = HashCode.<br>
+            Bag inside = Actual Object.<br>
+            If I give my token (Hashcode), I must get MY bag. If two people have the same token number (Collision), the shopkeeper checks the name tag (equals()) to distinguish.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Pincode.</strong><br>
+            Pincode = HashCode.<br>
+            House Address = Equals.<br>
+            Two houses can have the same Pincode (Collision). But if the full Address is same, Pincode MUST be same.`,
+            hinglish: `Ye rule HashMap ke liye zaruri hai.<br>1. Agar do object same hain (equals true hai), to unka HashCode **same hona hi chahiye**.<br>2. Agar HashCode same hai, to zaruri nahi ki object same hon (Collision ho sakta hai).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Token aur Samaan.</strong><br>
+            Agar mera bag wahi hai (Equal), to uska token number (HashCode) bhi wahi hona chahiye. Agar token badal gaya, to bag nahi milega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Naam aur Aadmi.</strong><br>
+            Do logon ka naam "Rahul" ho sakta hai (Same HashCode). Par wo same aadmi nahi hain. Par agar aadmi same hai, to uska naam bhi same hi hoga.`,
+            strategy: `Trap: "The default implementation uses the memory address for hashCode. That's why we must override it for logical equality."`
+        },
+        {
+            id: 98,
+            title: "What is Hashing?",
+            eng: `Hashing is the process of converting an arbitrary size object (like a String or Student object) into a fixed-size integer value (the hash code).<br><br>It is used for **fast data retrieval**. Instead of searching through 1000 items one by one (O(n)), we use the hash code to jump directly to the slot where the data is stored (O(1)).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Library Index Cards.</strong> Instead of searching every shelf for a book, you look at the Index Card (Hash). It tells you "Row 5, Shelf B". You jump straight there.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>School Roll Numbers.</strong> Instead of searching for "Ramesh" by face in assembly, the teacher says "Roll No 25". Roll No 25 is the hash that identifies the student location instantly.`,
+            hinglish: `Hashing ka matlab hai kisi bade data ko ek chote number (code) mein badalna.<br><br>Iska use fast search ke liye hota hai. 1000 logon mein "Amit" ko dhoondne ki jagah, hum uska code nikalte hain aur seedha wahin pahunch jate hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Medical Store.</strong> Dawai wala puri dukan nahi dhoondta. Wo computer pe naam dalta hai, computer code batata hai "Rack A-5". Wo seedha wahin jata hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Dictionary.</strong> Words alphabetical hash mein hote hain. 'Z' wala word dhoondne ke liye aap puri kitab nahi padhte, seedha peeche kholte ho.`,
+            strategy: `Lead: "Hashing is the engine behind HashMap and HashSet."`
+        },
+        {
+            id: 99,
+            title: "Explain internal working of HashSet?",
+            eng: `HashSet internally uses a **HashMap**. Surprised?<br><br>When you call <code>set.add("A")</code>, Java internally calls <code>map.put("A", DUMMY_OBJECT)</code>.<br>It stores the element you give as the **Key** of the map, and a dummy constant object as the Value. Since Map keys must be unique, the Set automatically ensures uniqueness.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Guest List.</strong> A Set is just a Guest List name check. You don't care about the +1 (Value). You just check if the Name (Key) is on the list. If "Rahul" is already written, you don't write it again.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Attendance.</strong> Teacher calls "Roll 1". Mark P. If Roll 1 speaks again, teacher ignores. The Key is Roll No. The Value (P) is dummy/constant.`,
+            hinglish: `HashSet andar hi andar **HashMap** ka use karta hai. Haan, ye sach hai.<br><br>Jab aap <code>add("Data")</code> karte ho, to HashSet us "Data" ko Map ki **Key** bana deta hai, aur Value ki jagah ek Dummy object daal deta hai.<br>Kyunki Map ki Keys duplicate nahi ho sakti, HashSet bhi duplicate nahi leta.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Parking Lot.</strong> Guard bas gadi ka number (Key) note karta hai. Driver kaun hai (Value) usse fark nahi padta. Agar number pehle se likha hai, to dubara nahi likhta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Election Vote.</strong> Ungli pe shyahi (ink) laga di. Ab dubara aaye to bhaga diya. Sirf banda (Key) check hota hai.`,
+            strategy: `Say: "So strictly speaking, HashSet consumes slightly more memory than necessary because it creates a Map Entry for every element."`
+        },
+        {
+            id: 100,
+            title: "Explain internal working of HashMap?",
+            eng: `HashMap works on the principle of Hashing.<br>1. **put(K, V):** It calculates <code>hash(K)</code> to find the "Bucket" index. It stores the Key-Value pair there.<br>2. **Collision:** If two keys land in the same bucket, they are stored as a **LinkedList**.<br>3. **Java 8 Improvement:** If the LinkedList gets too long (more than 8 nodes), it converts into a **Balanced Tree (Red-Black Tree)** to improve performance from O(n) to O(log n).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Post Office Sorting.</strong><br>
+            Bucket = City Pincode.<br>
+            Letters = Key-Value pairs.<br>
+            All letters for 'Mumbai' go into the Mumbai bag (Bucket). If the bag is too full (Collision), they organize it by Street Name (LinkedList/Tree).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Hotel Rooms.</strong><br>
+            Hash = Floor Number.<br>
+            If Hash is 5, go to 5th Floor (Bucket). Find room 501. If multiple guests are in 501 (Collision - rare), they form a queue inside.`,
+            hinglish: `HashMap **Buckets** (Balti) ke concept pe chalta hai.<br>1. Key ka Hash nikalo -> Bucket select karo -> Data wahan daal do.<br>2. Agar ek hi Bucket mein do data aa gaye (Collision), to wahan ek **LinkedList** (Chain) ban jati hai.<br>3. **Java 8 Update:** Agar Chain bahut lambi ho gayi (8 se zyada), to wo **Tree** ban jati hai taaki search fast ho jaye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Wardrobe (Almaree).</strong><br>
+            Aap socks ek drawer mein (Bucket 1), shirts dusre mein (Bucket 2). Agar socks wale drawer mein bahut saare socks ho gaye, to aap unhe organize (Tree) karte ho taaki dhoondna aasan ho.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Exam Hall.</strong><br>
+            Roll No 1-10 Room A mein. 11-20 Room B mein. Ye Buckets hain.`,
+            strategy: `Lead: "This improvement in Java 8 prevents 'Hash Collision DoS Attacks' where hackers intentionally created collisions to slow down the server."`
+        },
+        {
+            id: 101,
+            title: "Why Java is not pure object oriented language?",
+            eng: `Java is not considered "Pure" OOP because it supports **Primitive Data Types** (int, char, float, boolean, etc.).<br><br>In a pure OOP language (like Smalltalk), EVERYTHING must be an object. But in Java, <code>int a = 10;</code> is not an object. It has no methods. This was done for **Performance** (Objects are heavy, primitives are light).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Vegetarian Restaurant that serves Eggs.</strong> It claims to be Veg (OOP), but it serves Eggs (Primitives) because some customers need protein (Performance). So it's 99% Veg, not Pure Veg.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Digital Payment.</strong> Most transactions are digital (Objects), but you still keep some loose Cash (Primitives) for small, fast payments like buying tea.`,
+            hinglish: `Java "Pure" OOP nahi hai kyunki isme **Primitives** (int, char) hote hain jo Objects nahi hain.<br><br>Pure OOP mein sab kuch object hona chahiye. Par <code>int x = 5</code> object nahi hai. Java ne ye speed ke liye kiya tha. Objects memory zyada khaate hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shudh Shakahari Hotel.</strong> Hotel bolta hai veg hai, par Anda (Egg) bechta hai. To wo "Pure" veg nahi raha. Waise hi Java Pure OOP nahi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Smart Home.</strong> Sab kuch Alexa se chalta hai (Objects). Par ek purana switch (Primitive) bhi laga rakha hai emergency ke liye.`,
+            strategy: `Say: "However, wrapper classes allow us to treat primitives as objects when needed."`
+        },
+        {
+            id: 102,
+            title: "Why to use Getter and Setter methods?",
+            eng: `We use Getters and Setters to achieve **Encapsulation** and **Control**.<br><br>1. **Control:** You can validate data in a Setter (e.g., Age cannot be negative). If you made the variable public, anyone could set Age = -50.<br>2. **Flexibility:** You can make a field Read-Only by only providing a Getter.<br>3. **Hiding Internal Logic:** You can change how data is stored internally without affecting external users.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>ATM Machine.</strong> You don't take cash directly from the bin (Public Variable). You ask the machine (Getter). The machine checks your balance (Validation) and then gives cash.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Volume Knob.</strong> You don't touch the electrical circuit directly. You turn the knob (Setter). The knob ensures you don't blast the speakers beyond limit (Validation).`,
+            hinglish: `Hum variables ko direct public karne ki jagah Getter/Setter use karte hain **Control** ke liye.<br><br>1. **Validation:** Setter mein hum check laga sakte hain (Age negative nahi ho sakti).<br>2. **Read-Only:** Agar Setter hatado, to variable change nahi hoga.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bank Cashier.</strong> Aap bank ke tijori se khud paise nahi nikalte. Aap Cashier (Getter) se maangte ho. Wo check karta hai, fir deta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Email Password.</strong> Password change karne ke liye (Setter) purana password dalna padta hai. Agar direct access hota to koi bhi badal deta.`,
+            strategy: `Tip: "Using Lombok (@Getter @Setter) saves us from writing this boilerplate code manually."`
+        },
+        {
+            id: 103,
+            title: "What are Parallel Streams in Java?",
+            eng: `Parallel Streams allow us to split a stream into multiple chunks and process them **simultaneously** using multiple threads (cores) of the CPU.<br><br>You just call <code>list.parallelStream()</code> instead of <code>list.stream()</code>. Java automatically handles the splitting and merging of results. It is faster for huge datasets but can be slower for small ones due to thread management overhead.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Counting Cash.</strong><br>
+            <em>Stream:</em> One person counting a bundle of notes alone.<br>
+            <em>Parallel Stream:</em> Dividing the bundle among 4 friends. Everyone counts their part, and you sum up the total at the end.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Cutting Vegetables.</strong><br>
+            <em>Stream:</em> One chef cutting 100 onions.<br>
+            <em>Parallel Stream:</em> 5 chefs cutting 20 onions each. Job is done faster.`,
+            hinglish: `Parallel Stream ka matlab hai data ko tukdon mein baant kar **ek saath process karna**.<br><br>Bas <code>parallelStream()</code> likho, aur Java apne aap CPU ke sare cores use karega kaam jaldi khatam karne ke liye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shadi ke Card baantna.</strong><br>
+            <em>Stream:</em> Aap akele pure sheher mein card baant rahe ho.<br>
+            <em>Parallel:</em> Aapne 4 doston ko alag-alag areas mein bhej diya. Kaam jaldi ho gaya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Exam Paper Checking.</strong> Ek teacher check kare (Stream) vs 10 teachers milke check karein (Parallel).`,
+            strategy: `Warning: "Be careful! All parallel streams share the same 'Common ForkJoinPool'. If one task blocks, it slows down the entire application."`
+        },
+        {
+            id: 104,
+            title: "What is a ForkJoinPool in Java?",
+            eng: `ForkJoinPool is a special thread pool designed for **Divide and Conquer** tasks (like Parallel Streams).<br><br>It uses a **Work-Stealing Algorithm**. If a thread finishes its own task early, it doesn't sit idle. It "steals" tasks from the queue of other busy threads. This ensures maximum CPU utilization.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Efficient Team.</strong> Imagine a team painting a wall. If Painter A finishes his section, he doesn't stand and smoke. He goes and helps Painter B finish his section. This is Work-Stealing.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Eating Pizza.</strong> You and your friend have 4 slices each. You eat fast and finish yours. Instead of waiting, you grab a slice from your friend's plate (Stealing work).`,
+            hinglish: `ForkJoinPool ek special thread pool hai jo **Kaam chori (Work-Stealing)** karta hai—par ache sense mein.<br><br>Agar ek Thread apna kaam jaldi khatam kar le, to wo khali nahi baithta. Wo dusre Thread ki line se kaam utha leta hai taaki sab busy rahein.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Khet katna (Farming).</strong> 4 kisaan khet kaat rahe hain. Ek ne apna hissa kaat liya. Wo ghar nahi gaya, usne padosi kisaan ki madat karni shuru kar di.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Dish Washing.</strong> 2 log bartan dho rahe hain. Mera dher khatam ho gaya to maine tumhare dher se bartan utha liye.`,
+            strategy: `Say: "This is the engine behind Java 8 Parallel Streams."`
+        },
+        {
+            id: 105,
+            title: "What is a ReentrantLock?",
+            eng: `ReentrantLock is an advanced alternative to the <code>synchronized</code> keyword. It provides more features:<br>1. **Fairness:** You can ensure the longest waiting thread gets the lock first (FIFO).<br>2. **TryLock:** You can try to get the lock, and if it's busy, do something else (instead of waiting forever).<br>3. **Manual Control:** You explicitly call <code>lock()</code> and <code>unlock()</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Synchronized:</em> **Toilet Door.** You knock. If locked, you stand there frozen until it opens.<br>
+            <em>ReentrantLock (TryLock):</em> **Toilet Door.** You knock. If locked, you say "Okay, I'll go check my email and come back later." You don't freeze.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Fairness:</em> **Ticket Counter.** Synchronized is a crowd pushing (Luck). ReentrantLock with fairness is a disciplined Queue (First come First serve).`,
+            hinglish: `ReentrantLock <code>synchronized</code> ka bada bhai hai. Ye zyada power deta hai:<br>1. **TryLock:** "Try karo, agar lock mila to thik, nahi to main wait nahi karunga, kuch aur karunga."<br>2. **Fairness:** Line se number aayega. Jo pehle aaya wo pehle lock lega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Fitting Room.</strong><br>
+            <em>Sync:</em> Line mein khade raho jab tak room khali na ho.<br>
+            <em>Reentrant:</em> Dekha bhara hai? Thik hai, main tab tak dusre kapde dekh leta hoon.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ola Booking.</strong> Agar driver busy hai, to "Retry Later" (TryLock). App hang nahi hota.`,
+            strategy: `Trap: "Always use try-finally block with ReentrantLock. Call unlock() in the finally block, otherwise if an exception occurs, the lock will never be released (Deadlock)." `
+        },
+        {
+            id: 106,
+            title: "What is the difference between PermGen and Metaspace?",
+            eng: `Both are memory areas to store **Class Metadata** (Class names, Methods, Static variables).<br><br>1. **PermGen (Java 7 & older):** Part of Heap. Fixed size. If you loaded too many classes, you got <code>OutOfMemoryError: PermGen space</code>. Difficult to tune.<br>2. **Metaspace (Java 8 & newer):** Outside Heap (Native Memory). Auto-resizable. It grows automatically based on OS memory availability. No more PermGen errors!<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>PermGen:</em> **Small Backpack.** You put your books (Classes) in it. If full, you can't add more. Error.<br>
+            <em>Metaspace:</em> **Elastic Bag.** The bag stretches (Expands) as you put more books in it. It uses the room's space (OS RAM).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>PermGen:</em> **House Parking.** Limited to 2 cars.<br>
+            <em>Metaspace:</em> **Street Parking.** You can park as many cars as the street allows.`,
+            hinglish: `Dono jagah Class ki jaankari store hoti hai.<br><br>1. **PermGen (Purana):** Ye Heap ka hissa tha. Iska size fix tha. Agar classes zyada ho gayin, to crash ho jata tha.<br>2. **Metaspace (Naya - Java 8):** Ye Heap se bahar hai. Ye **Elastic** hai. Jitni jagah chahiye, utni RAM le leta hai. Crash hone ke chance kam hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>PermGen:</em> **Jeb (Pocket).** Limited jagah. 5 pen rakh sakte ho.<br>
+            <em>Metaspace:</em> **Jhola (Shopping Bag).** Jitna saman dalo, failta jata hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>PermGen:</em> **Fixed Tank.** 500 Liter pani.<br>
+            <em>Metaspace:</em> **River connection.** Jitna pani chahiye lelo.`,
+            strategy: `Say: "This is why Java 8 applications are more stable with dynamic class loading (like Spring Boot) compared to Java 7."`
+        },
+        {
+            id: 107,
+            title: "What are Covariant return types?",
+            eng: `Before Java 5, when overriding a method, the return type had to be EXACTLY the same.<br><br>With **Covariant Return Types**, an overridden method in the Child class can return a **Subclass** of the return type declared in the Parent class. It allows more specific return types.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Car Dealership.</strong><br>
+            Parent method: <code>Vehicle manufacture()</code>.<br>
+            Child (BMW Factory) overrides: <code>BMW manufacture()</code>.<br>
+            BMW IS-A Vehicle. So this is allowed. It's better because the client knows they are getting a BMW, not just a generic Vehicle.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Gift Giver.</strong><br>
+            Dad says: "I will give you a Fruit". (Parent Method).<br>
+            Mom says: "I will give you an Apple". (Child Override).<br>
+            Since Apple is a Fruit, this promise is valid.`,
+            hinglish: `Pehle Overriding mein Return type same hona zaruri tha.<br><br>Ab Java allow karta hai ki agar Parent method <code>Janwar</code> return karta hai, to Child method <code>Kutta</code> return kar sakta hai (Kyunki Kutta bhi Janwar hai). Ise Covariant Return Type kehte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Burger Shop.</strong><br>
+            Menu (Parent): "Hum <code>Khana</code> denge".<br>
+            Waiter (Child): "Hum <code>Burger</code> denge".<br>
+            Valid hai, kyunki Burger bhi Khana hi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Education.</strong><br>
+            College: "Hum Degree denge".<br>
+            IIT: "Hum B.Tech Degree denge". (More specific).`,
+            strategy: `Lead: "This helps avoid unnecessary typecasting in client code."`
+        },
+        {
+            id: 108,
+            title: "What is the difference between == and equals() in Java?",
+            eng: `1. **== (Operator):** Compares **References** (Memory Address). Checks if two variables point to the exact same object in heap.<br>2. **equals() (Method):** Compares **Content** (Values). Checks if the data inside the objects is meaningfuly same.<br><br>Note: By default, equals() behaves like == unless overridden.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Twin Brothers.</strong><br>
+            <em>==:</em> Are they the SAME person? No. They are two different bodies (False).<br>
+            <em>equals():</em> Do they look same? Yes. Their DNA/Face is identical (True).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Two Identical Cars.</strong><br>
+            <em>==:</em> Is this the exact same physical car? No, one is mine, one is yours.<br>
+            <em>equals():</em> Are they same model and color? Yes.`,
+            hinglish: `1. **==:** Ye **Address** check karta hai. "Kya ye wahi object hai?"<br>2. **equals():** Ye **Data** check karta hai. "Kya inke andar ka maal same hai?"<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Do iPhone 15.</strong><br>
+            <em>==:</em> Kya ye ek hi phone hai? Nahi, do alag dabba pack phones hain.<br>
+            <em>equals():</em> Kya ye same hain? Haan, dono iPhone 15 hain, features same hain.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Xerox Copy.</strong><br>
+            <em>==:</em> Kya ye original paper hai? Nahi.<br>
+            <em>equals():</em> Kya likha hua same hai? Haan.`,
+            strategy: `Trap: "For String literals, '==' might return true because of String Pool. Never rely on it. Always use .equals() for objects."`
+        },
+        {
+            id: 109,
+            title: "What is Cyclic Dependency?",
+            eng: `Cyclic Dependency happens when Bean A depends on Bean B, and Bean B depends back on Bean A.<br><br>Spring gets confused: "To create A, I need B. To create B, I need A." It creates an infinite loop and throws <code>BeanCurrentlyInCreationException</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Job Application.</strong><br>
+            "To get a Job, you need Experience."<br>
+            "To get Experience, you need a Job."<br>
+            You are stuck in a cycle.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Loan Guarantee.</strong><br>
+            Ram says: "I will sign if Sham signs."<br>
+            Sham says: "I will sign if Ram signs."<br>
+            No one signs. Cycle.`,
+            hinglish: `Cyclic Dependency matlab Gol-Gol ghumna.<br><br>Class A ko B chahiye. Class B ko A chahiye. Spring confuse ho jata hai ki pehle kisko banaye. Dono ek dusre ka wait kar rahe hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Anda aur Murgi.</strong><br>
+            Murgi banne ke liye Anda chahiye. Anda banne ke liye Murgi chahiye. Pehle kaun aaya? (Loop).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Taala Chabi.</strong><br>
+            Chabi taale wale kamre mein band hai. Kamra kholne ke liye chabi chahiye.`,
+            strategy: `Solution: "We solve this using **@Lazy** annotation on one of the dependencies, or by using Setter Injection instead of Constructor Injection."`
+        },
+        {
+            id: 110,
+            title: "What is Memory Leak in Java?",
+            eng: `A Memory Leak happens when objects are no longer needed but are **still referenced** by some other object, so the Garbage Collector cannot delete them.<br><br>Slowly, the heap fills up with these useless objects until the application crashes with <code>OutOfMemoryError</code>.<br>Common causes: Static lists growing forever, unclosed connections.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Library Books.</strong> You check out books but never return them. The library thinks you are still reading them (Reference exists). Eventually, the library has no books left for others.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Hoarding.</strong> You keep empty boxes in your house thinking "I might use them". You never use them. Eventually, your house is full of trash and you can't move.`,
+            hinglish: `Memory Leak ka matlab hai "Kachra jama hona".<br><br>Aise objects jo ab kaam ke nahi hain, par humne galti se unhe pakad rakha hai (Reference). GC unhe delete nahi kar pa raha. Dheere-dheere RAM bhar jati hai aur app crash ho jati hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Subscription bhool jana.</strong> Aapne Netflix liya, par dekhte nahi ho. Cancel karna bhool gaye. Paise (Memory) kat rahe hain par use nahi ho raha.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ghar ka kooda.</strong> Agar aap kooda bahar na feko (Reference clear na karo), to ghar bhar jayega.`,
+            strategy: `Lead: "We detect memory leaks using tools like **VisualVM** or **Eclipse Memory Analyzer (MAT)**."`
+        },
+        {
+            id: 111,
+            title: "What is Thread Safe code?",
+            eng: `Thread Safe code means code that functions correctly even when multiple threads access it simultaneously.<br><br>It ensures that shared data is not corrupted. We achieve this by using Synchronization, Atomic variables, or Immutable objects.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Queue System.</strong> A bus conductor makes people form a line. Only one person enters at a time. This is "Thread Safe". Without the line, people push each other (Race Condition/Unsafe).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Traffic Signal.</strong> It ensures cars from North and East don't crash. It manages the flow safely.`,
+            hinglish: `Thread Safe code wo hai jo tab bhi sahi chale jab bahut sare threads ek saath use karein.<br><br>Matlab data kharab nahi hona chahiye. Iske liye hum Lock lagate hain ya Immutable objects use karte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bank Locker.</strong> Bank ka locker thread-safe hai. Ek baar mein ek hi aadmi ke paas chabi hoti hai. Koi aur beech mein nahi ghus sakta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Single Lane Bridge.</strong> Signal laga hai taaki gadiyan takraye nahi.`,
+            strategy: `Example: "StringBuffer is thread-safe. StringBuilder is NOT thread-safe."`
+        },
+        {
+            id: 112,
+            title: "What is ThreadLocal?",
+            eng: `<code>ThreadLocal</code> allows you to create variables that can only be read/written by the **same thread**. <br><br>Even if two threads execute the same code, they will see their own separate versions of the variable. They don't share it. It's like giving every thread its own private pocket.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hotel Room Key.</strong> Each guest (Thread) has their own key. My key opens my room. Your key opens your room. Even though we are in the same hotel (Class), our keys (Data) are private.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Voting Booth.</strong> Even though many people vote in the same booth, only YOU see your vote. It is local to you.`,
+            hinglish: `ThreadLocal ka matlab hai "Thread ka apna personal variable".<br><br>Har Thread ko apni alag copy milti hai. Thread A ka data Thread B nahi dekh sakta. Ye bina synchronization ke thread-safety deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Toothbrush.</strong> Ghar mein sab log hain (Threads), par sabka toothbrush (Variable) apna alag hai. Koi share nahi karta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Exam Paper.</strong> Har student (Thread) apni sheet pe likhta hai. Dusre ki sheet pe nahi likh sakta.`,
+            strategy: `Usage: "We use it for storing **User Context** or **Transaction IDs** in web applications."`
+        },
+        {
+            id: 113,
+            title: "What is Method Reference?",
+            eng: `Method Reference (<code>::</code> operator) is a shorthand syntax for a Lambda expression that just calls an existing method.<br><br>Instead of writing <code>s -> System.out.println(s)</code>, you write <code>System.out::println</code>. It makes code cleaner and more readable.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pointing Finger.</strong> Instead of explaining "Go to the shelf, pick the book, bring it here", you just point to the Librarian (Method Reference) and say "Ask him". You refer to an existing handler.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Speed Dial.</strong> Instead of typing the number every time (Lambda), you press '1' (Method Ref) which refers to "Mom's Number".`,
+            hinglish: `Method Reference (<code>::</code>) Lambda likhne ka chota tarika hai.<br><br>Agar aapka Lambda bas kisi aur method ko call kar raha hai, to pura code mat likho. Bas us method ka naam refer kar do.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Menu Card.</strong> Waiter ko recipe batane ki zarurat nahi (Lambda). Bas Menu mein "Butter Chicken" pe ungli rakh do (Method Ref). Wo samajh jayega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Forward Message.</strong> Message dubara type karne ki jagah (Lambda), aap bas "Forward" button dabate ho (Method Ref).`,
+            strategy: `Tip: "There are 4 types: Static method ref, Instance method ref, Constructor ref, and Arbitrary object ref."`
+        },
+        {
+            id: 114,
+            title: "What is Tight Coupling and Loose Coupling?",
+            eng: `**Tight Coupling:** Two classes are highly dependent. If you change one, you must change the other. Hard to test and maintain.<br>**Loose Coupling:** Classes are independent. They interact via **Interfaces**. Changing one doesn't break the other.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Tight:</em> **Wired Headphones.** Soldered to the phone. To change headphones, you must break the phone.<br>
+            <em>Loose:</em> **Bluetooth Headphones.** You can connect Sony, Bose, or Apple. The phone doesn't care. Just need Bluetooth standard (Interface).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Tight:</em> **Train Wheels.** You can't put Car wheels on a Train. They are fixed for tracks.<br>
+            <em>Loose:</em> **USB Drive.** Fits in Laptop, TV, Car, Desktop. Universal fit.`,
+            hinglish: `**Tight Coupling:** Do cheezein buri tarah judi hui hain. Ek ko badla to dusra toot jayega.<br>**Loose Coupling:** Do cheezein azaad hain. Interface se judi hain. Ek ko badalne se dusre ko fark nahi padta.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Tight:</em> **Charger with Fixed Wire.** Agar wire kharab hui, to pura charger fekna padega.<br>
+            <em>Loose:</em> **USB Cable + Adapter.** Cable kharab hui? Dusri laga lo. Adapter wahi rahega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Tight:</em> **Inbuilt Battery.** Phone kholo tab niklegi.<br>
+            <em>Loose:</em> **Removable Battery (Old phones).** Khola aur badal diya.`,
+            strategy: `Lead: "Spring Framework helps us achieve Loose Coupling using **Dependency Injection**."`
+        },
+        {
+            id: 115,
+            title: "What is Inversion of Control (IoC)?",
+            eng: `IoC is a design principle where the control of creating and managing objects is transferred from the programmer to a container (Framework like Spring).<br><br>Instead of you creating objects using <code>new</code>, the Framework creates them and gives them to you. "Don't call us, we'll call you."<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Taxi vs Uber.</strong><br>
+            <em>Traditional:</em> You stand on road, wave hand, find taxi, negotiate. (You control).<br>
+            <em>IoC (Uber):</em> You just request. The App (Container) finds the driver, handles payment, and sends car to you. Control is inverted.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Buffet vs Wedding Service.</strong><br>
+            <em>Traditional:</em> You go to table and take food.<br>
+            <em>IoC:</em> You sit. Waiters bring food to your table.`,
+            hinglish: `IoC ka matlab hai "Control ulti disha mein".<br><br>Pehle hum code mein objects banate the (<code>new Class()</code>). IoC mein hum nahi banate, **Spring Framework** banata hai aur humein deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hollywood Principle.</strong> Audition ke baad Director bolta hai: "Tum humein call mat karna, hum tumhe call karenge". Control Director ke paas hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Pizza Delivery.</strong><br>
+            <em>Normal:</em> Dukan jao, pizza lao.<br>
+            <em>IoC:</em> Ghar baitho, Domino's khud aayega.`,
+            strategy: `Differentiation: "IoC is the Principle (The Idea). Dependency Injection is the Design Pattern (The Implementation)." `
+        },
+        {
+            id: 116,
+            title: "What is Dependency Injection (DI)?",
+            eng: `DI is the implementation of IoC. It is the process where the Spring Container "Injects" the required dependencies (Objects) into your class.<br><br>You just declare "I need an Engine". Spring creates the Engine and puts it inside your Car. You don't create it.<br>Types: Constructor Injection, Setter Injection, Field Injection.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Surgery.</strong> A Surgeon needs a Scalpel. He doesn't go to the factory to manufacture a scalpel. The nurse **injects** (hands over) the scalpel into his hand when he asks.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Game Console.</strong> You buy a Console. You don't build the controller. The box comes with the controller **injected** inside.<br><br>`,
+            hinglish: `DI ka matlab hai zarurat ki cheez (Dependency) bahar se supply karna.<br><br>Aap bas bolte ho "Mujhe Engine chahiye". Spring Engine banata hai aur aapki Car mein fit kar deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Injection (Medical).</strong> Davai (Dependency) body ke andar ban nahi rahi. Doctor injection se bahar se daal raha hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Restaurant.</strong> Chef sabji khud nahi ugata. Vendor sabji (Dependency) laata hai aur Chef use karta hai.`,
+            strategy: `Opinion: "Constructor Injection is considered best practice because it ensures the object is fully initialized and immutable."`
+        },
+        {
+            id: 117,
+            title: "What is a Bean in Spring Framework?",
+            eng: `A Bean is simply a Java Object that is managed by the **Spring IoC Container**.<br><br>If you create an object with <code>new Student()</code>, it's just a normal object. If you let Spring create it (using <code>@Component</code> or <code>@Bean</code>), it becomes a Spring Bean. Spring handles its lifecycle (Creation, Initialization, Destruction).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pet vs Zoo Animal.</strong><br>
+            <em>Object:</em> Stray Dog. No one takes care of it. It lives and dies on its own.<br>
+            <em>Bean:</em> Zoo Lion. The Zoo (Spring Container) feeds it, cleans it, and manages its life.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Home Plant.</strong> You water it. It's an object.<br>
+            <strong>Nursery Plant.</strong> The gardener takes care of it. It's a Bean.`,
+            hinglish: `Bean bas ek Java Object hai, par wo special hai kyunki **Spring** uska dhyaan rakhta hai.<br><br>Agar hum khud object banayein, to wo Normal Object hai. Agar Spring banaye aur manage kare, to wo Bean hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Sarkari Naukri.</strong><br>
+            <em>Object:</em> Private job. Khud dhyaan rakho.<br>
+            <em>Bean:</em> Sarkari damad. Sarkar (Container) pura khayal rakhti hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Street Light.</strong> Ye Bean hai (Municipality manage karti hai). Ghar ka bulb Object hai (Aap manage karte ho).`,
+            strategy: `Lead: "Beans have scopes like Singleton (default) and Prototype."`
+        },
+        {
+            id: 118,
+            title: "What is Autowiring in Spring?",
+            eng: `Autowiring is the magic where Spring automatically finds the correct Bean and injects it into your class.<br><br>You just put <code>@Autowired</code> on a variable. Spring scans its container, looks for a matching object, and assigns it. You don't write <code>= new Class()</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Magnet.</strong> If you hold a magnet near iron, it snaps together automatically. <code>@Autowired</code> is that magnetic force connecting objects.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Automatic WiFi Connect.</strong> You enter a known cafe. Your phone **automatically** connects to WiFi. You didn't type the password again. Spring connected the dependency automatically.`,
+            hinglish: `Autowiring ka matlab hai "Apne aap jodna".<br><br>Aapne bas likha <code>@Autowired Engine engine;</code>. Spring dhoondega ki kya koi Engine bana hua hai? Agar haan, to wo lake isme fit kar dega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Arranged Marriage.</strong> Aapne nahi dhoonda. Ghar walon ne (Spring) ladki dhoond ke aapke saath 'Autowire' kar di.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>USB Plug.</strong> USB lagate hi Computer mouse ko detect kar leta hai aur connect kar leta hai.`,
+            strategy: `Trap: "Autowiring can happen byType (default) or byName."`
+        },
+        {
+            id: 119,
+            title: "What is @Qualifier?",
+            eng: `<code>@Qualifier</code> is used to resolve ambiguity when multiple beans of the same type exist.<br><br>Imagine you need an <code>Animal</code>, but Spring has both <code>Dog</code> and <code>Cat</code> beans. <code>@Autowired</code> fails because it's confused. You use <code>@Qualifier("dog")</code> to tell Spring specifically which one to inject.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ordering Tea.</strong> You say "Give me Tea". Waiter is confused (Milk Tea? Green Tea?). You verify: "Give me **Green** Tea". 'Green' is the Qualifier.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Calling a Name.</strong> Teacher calls "Rahul". There are 3 Rahuls. Teacher says "Rahul **Sharma**". Sharma is the Qualifier.`,
+            hinglish: `Jab Spring confuse ho jata hai, tab Qualifier kaam aata hai.<br><br>Agar 2 beans hain same type ke (Dog aur Cat), aur aapne maanga Animal, to Spring poochega "Kaunsa?". Qualifier se hum naam batate hain: "Mujhe Dog wala chahiye".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Kirana Store.</strong> Aapne kaha "Colgate do". Dukan wala confuse (Salt wala? Gel wala?). Aapne kaha "**Active Salt** wala". Ye Qualifier hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Cricket.</strong> Captain ne bola "Bowler bulao". Umpire confuse. Captain ne kaha "**Bumrah** ko bulao".`,
+            strategy: `Lead: "Another way to solve this is using @Primary."`
+        },
+        {
+            id: 120,
+            title: "What if the bean mentioned in @Qualifier is not available?",
+            eng: `If the bean name specified in <code>@Qualifier("ghostBean")</code> does not exist, Spring throws a <code>NoSuchBeanDefinitionException</code> at startup. The application will fail to start.<br><br>Strict check ensures you don't run with missing dependencies.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Prescription.</strong> Doctor wrote "Medicine X". Pharmacist checks shelf. Not there. He cannot give you anything else. Transaction fails.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Roll Call.</strong> Teacher calls "Ramesh". Ramesh is absent. No one answers. Error.`,
+            hinglish: `Agar Qualifier wala naam nahi mila, to **Crash** (Exception).<br><br>Spring start hi nahi hoga. Wo bolega "Tumne jo maanga wo hai hi nahi".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Restaurant.</strong> Aapne order kiya "Butter Chicken". Waiter ne kaha "Khatam ho gaya". Ab aap kha nahi sakte (Error).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Galat Address.</strong> Courier wala galat address pe gaya. Ghar nahi mila. Delivery fail.`,
+            strategy: `Solution: "We can make autowiring optional using \`@Autowired(required=false)\`."`
+        },
+        {
+            id: 121,
+            title: "What is @Primary?",
+            eng: `<code>@Primary</code> is an annotation used to define a **default** preference when multiple beans of the same type exist.<br><br>If you have <code>Dog</code> and <code>Cat</code>, and you mark <code>Dog</code> as <code>@Primary</code>, then whenever someone asks for <code>Animal</code> without specifying a name, Spring will automatically give the Dog.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Default Sim Card.</strong> You have 2 SIMs (Airtel, Jio). You set Airtel as 'Default for Calls'. When you dial, it goes via Airtel automatically unless you manually select Jio.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Favorite Address.</strong> Amazon has 3 addresses. You mark Home as 'Default'. If you don't choose, parcel comes Home.`,
+            hinglish: `<code>@Primary</code> ka matlab hai "Default Choice".<br><br>Agar confusion ho, to Spring Primary wale ko chunta hai.<br>Example: Ghar mein 2 gaadi hain. Aapne ek ko Primary bana diya. Jab bhi koi bolega "Gadi chahiye", aap Primary wali de doge.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Primary Bank Account.</strong> UPI pe 4 bank link hain. Par ek Primary hai. Paise wahin aate hain by default.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Default Browser.</strong> Link click karne pe Chrome khulta hai kyunki wo Primary set hai.`,
+            strategy: `Contrast: "@Qualifier is stronger than @Primary. If both are present, Qualifier wins."`
+        },
+        {
+            id: 122,
+            title: "What if the bean annotated with @Primary is not available?",
+            eng: `This is a trick question. <code>@Primary</code> is placed ON the bean class itself. So if the class exists and is scanned, the bean IS available.<br><br>However, if you exclude that class from component scanning, and no other unique bean is found, Spring throws <code>NoUniqueBeanDefinitionException</code> (because it sees multiple options and no Primary to decide) OR <code>NoSuchBeanDefinitionException</code> (if no beans exist).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Voting.</strong> If the Class Monitor (Primary) is absent, and teacher asks "Who is responsible?", and there are 50 students, confusion occurs.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Main Switch.</strong> If the main power line is cut, lights go out.`,
+            hinglish: `Ye sawal thoda tricky hai. Agar Primary wala bean hai hi nahi (delete kar diya), aur baki beans hain, to Spring confuse ho jayega.<br><br>Wo bolega "Bahut sare hain, mujhe nahi pata kisko chunna hai". (NoUniqueBeanDefinitionException).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Captain.</strong> Agar Cricket team ka Captain (Primary) ground pe na aaye, to decision kaun lega? Confusion.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Head of Family.</strong> Agar mukhiya bahar gaya hai, to bada faisla kaun lega?`,
+            strategy: `Clarify: "Usually @Primary is checked at compile/startup time."`
+        },
+        {
+            id: 123,
+            title: "What is the difference between @Qualifier and @Primary?",
+            eng: `1. **@Primary (General):** Sets a default for *everyone*. "If no one asks specifically, use this."<br>2. **@Qualifier (Specific):** Used by the *caller* to ask for a specific one. "I specifically want THAT one."<br><br>Priority: **Qualifier > Primary**. Specific demand overrides default setting.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Cafeteria.</strong><br>
+            <em>Primary:</em> Daily Special is Rajma Chawal. If you say "Lunch", you get Rajma.<br>
+            <em>Qualifier:</em> You say "I want Pizza". You get Pizza (Overriding the daily special).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Music Player.</strong><br>
+            <em>Primary:</em> Shuffle Play.<br>
+            <em>Qualifier:</em> You search and play a specific song "Despacito".`,
+            hinglish: `1. **@Primary:** Ye Default hai. Agar kuch nahi bola to ye milega.<br>2. **@Qualifier:** Ye Specific maang hai. "Mujhe ye wala chahiye".<br><br>Qualifier ki power zyada hoti hai. Agar aapne maanga, to Primary ignore ho jayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ghar ka Khana.</strong><br>
+            <em>Primary:</em> Mummy ne Dal-Chawal banaya (Default).<br>
+            <em>Qualifier:</em> Aapne zidd ki "Mujhe Maggie chahiye". To Maggie milegi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>TV Channel.</strong><br>
+            <em>Primary:</em> TV on karte hi News channel aata hai.<br>
+            <em>Qualifier:</em> Aapne remote se Sports channel lagaya.`,
+            strategy: `Summary: "Use Primary when you control the library definition. Use Qualifier when you are injecting dependencies."`
+        },
+        {
+            id: 124,
+            title: "What are SOLID Principles?",
+            eng: `SOLID is an acronym for 5 design principles intended to make software designs more understandable, flexible, and maintainable.<br><br>S - Single Responsibility<br>O - Open/Closed<br>L - Liskov Substitution<br>I - Interface Segregation<br>D - Dependency Inversion<br><br>They prevent "Spaghetti Code".<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Building a House.</strong> Good architecture (SOLID) means you can change the kitchen tiles without breaking the bedroom wall. Bad architecture means touching one brick collapses the roof.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Lego Blocks.</strong> They follow strict principles so any block fits with any other block easily.`,
+            hinglish: `SOLID 5 rules hain jo code ko saaf aur majboot banate hain.<br><br>Agar aap inhein follow nahi karoge, to code "Kichdi" ban jayega. Ek jagah change karoge to dusri jagah fat jayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Modular Kitchen.</strong> Kharab drawer nikal ke naya laga sakte hain. Pura kitchen todne ki zarurat nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Car Service.</strong> Mechanic sirf tyre badalta hai, engine ko haath lagaye bina. Kyunki car SOLID design pe bani hai.`,
+            strategy: `Say: "These were introduced by Robert C. Martin (Uncle Bob)." `
+        },
+        {
+            id: 125,
+            title: "What is S in SOLID Principles?",
+            eng: `**Single Responsibility Principle (SRP).**<br><br>A class should have **only one reason to change**. It should do only ONE job.<br>Don't create a "God Class" that handles Database, Logic, Email, and Printing together. Split them.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Swiss Army Knife vs Scalpel.</strong> A Swiss Knife does everything but nothing perfectly. A Scalpel does only one thing (cut) but does it perfectly. SRP prefers the Scalpel.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Restaurant Staff.</strong> The Chef cooks. The Waiter serves. The Cleaner cleans. If the Chef starts cleaning tables, food will burn (Violation of SRP).`,
+            hinglish: `**Single Responsibility (Ek Kaam).**<br><br>Ek class ka bas **ek hi kaam** hona chahiye.<br>Agar aap ek hi class mein sab kuch bhar doge (Khana banana, Kapde dhona, Gadi chalana), to wo manage nahi hogi.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Cricket Team.</strong> Batsman batting karega. Bowler bowling karega. Agar Kohli wicket-keeping bhi kare aur ticket bhi beche, to performance giregi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Printer.</strong> Printer ka kaam print karna hai. Agar wo Coffee bhi banane lage, to complex ho jayega.`,
+            strategy: `Trap: "Does this mean a class should have only one method? No. It can have many methods, but they should all relate to one *responsibility*."`
+        },
+        {
+            id: 126,
+            title: "What is O in SOLID Principles?",
+            eng: `**Open/Closed Principle.**<br><br>Software entities (Classes, Modules) should be **Open for Extension, but Closed for Modification.**<br>You should be able to add new features WITHOUT touching the existing, tested code.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Extension Cord.</strong> The wall socket is Closed (you don't break the wall to add plugs). But you use an Extension Cord to Extend it. You get more sockets without breaking the wall.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Smartphone Apps.</strong> You install a new App (Extension) to get new features. You don't unscrew the phone and solder new chips (Modification) to get a calculator.`,
+            hinglish: `**Open/Closed Principle.**<br><br>Class **Open** honi chahiye naya feature add karne ke liye, par **Closed** honi chahiye purana code change karne ke liye.<br>Purana code (jo sahi chal raha hai) use mat chedo.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shirt aur Jacket.</strong> Thand lag rahi hai? Shirt (Existing Code) mat faado. Upar se Jacket (New Class) pehen lo. Shirt waisi hi rahegi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Video Game DLC.</strong> Naya map khelne ke liye puri game dubara nahi banate. Bas naya map download (Extend) karte hain.`,
+            strategy: `Lead: "We achieve this using **Interfaces** and **Abstract Classes**."`
+        },
+        {
+            id: 127,
+            title: "What is L in SOLID Principles?",
+            eng: `**Liskov Substitution Principle (LSP).**<br><br>Objects of a superclass should be replaceable with objects of its subclasses without breaking the application.<br>Basically: **A Child class should not break the rules of the Parent class.**<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>The Duck Test.</strong> If it looks like a duck and quacks like a duck, but needs batteries (Toy Duck), you cannot treat it like a Real Duck. If you swap them, the Toy Duck will sink and rust. Violation of LSP.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Remote Control.</strong> If you replace an old TV remote with a Universal Remote (Child), it should still turn on the TV. If pressing 'Power' on the new remote explodes the TV, it violates LSP.`,
+            hinglish: `**Liskov Substitution Principle.**<br><br>Agar Parent ki jagah Child ko khada kar diya jaye, to sab kuch sahi chalna chahiye.<br>Child class ko Parent ka behavior badalna nahi chahiye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Bulb.</strong> Agar aap 100W bulb (Parent) nikal ke LED bulb (Child) lagate ho, to light jalni chahiye. Agar LED lagane se ghar mein aag lag jaye, to wo galat Child hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Tea.</strong> Agar maine "Chai" maangi, aur aapne "Nimbu Chai" di, to chalega. Par agar aapne "Mitti ka ghol" de diya, to nahi chalega.`,
+            strategy: `Trap: "The classic violation example is Square extending Rectangle. If you change width of Square, height changes too, breaking Rectangle's logic."`
+        },
+        {
+            id: 128,
+            title: "What is I in SOLID Principles?",
+            eng: `**Interface Segregation Principle (ISP).**<br><br>Clients should not be forced to depend on interfaces they do not use.<br>Instead of one huge "Fat Interface", create smaller, specific interfaces.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Restaurant Menu.</strong> Imagine a menu having Vegetarian, Non-Veg, and Drinks all on one giant page. A Vegetarian shouldn't have to hold a menu smelling of Fish. Better to split: Veg Menu, Bar Menu.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>USB Cable.</strong> Imagine a cable with Lightning, USB-C, Micro-USB, and VGA all in one bunch. Heavy and useless. Better to have separate cables for separate needs.`,
+            hinglish: `**Interface Segregation.**<br><br>Bada interface mat banao. Chote-chote banao.<br>Kisi ko wo method implement karne pe majboor mat karo jo uske kaam ka nahi hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Combo Pack.</strong> Agar mujhe sirf Burger chahiye, to mujhe zabardasti Coke aur Fries ka paisa kyu dena pade? Alag-alag becho.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Office Printer.</strong> Printer mein "Fax" ka button hai. Par mujhe Fax nahi karna. Wo button mere liye faltu hai.`,
+            strategy: `Say: "This keeps our classes clean and focused."`
+        },
+        {
+            id: 129,
+            title: "What is D in SOLID Principles?",
+            eng: `**Dependency Inversion Principle (DIP).**<br><br>High-level modules should not depend on low-level modules. Both should depend on **Abstractions (Interfaces)**.<br>Don't code to implementation; code to interface.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Plug Socket.</strong> Your Lamp (High Level) doesn't connect directly to the Nuclear Power Plant (Low Level). It connects to a Socket (Interface). You can change the power source (Solar/Wind), the Lamp still works.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Debit Card.</strong> You don't carry gold bars (Low Level) to shop. You carry a Card (Interface). The shop doesn't care if money comes from SBI or HDFC, as long as the Card works.`,
+            hinglish: `**Dependency Inversion.**<br><br>Direct class pe depend mat raho, Interface pe depend raho.<br>Taaki agar future mein class badal jaye, to humara code na toote.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Driver.</strong> Driver ko "Maruti" chalani nahi aani chahiye, usse "Gadi" (Interface) chalani aani chahiye. Taaki kal agar Mercedes mile to wo bhi chala le.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Sim Card.</strong> Mobile (High Level) Sim Card (Interface) ko support karta hai. Usse fark nahi padta ki Sim Airtel ka hai ya Jio ka.`,
+            strategy: `Summary: "This is the core principle behind Spring's Dependency Injection."`
+        },
+        {
+            id: 130,
+            title: "Is public static void main insignificant in Java now?",
+            eng: `With **Java 21**, we have "Implicitly Declared Classes and Instance Main Methods" (Preview feature).<br><br>You can now simply write:<br><code>void main() { System.out.println("Hello"); }</code><br>No need for <code>public static</code>, no need for <code>String[] args</code>, no need for <code>class Main</code> wrapper.<br>However, for enterprise apps (Spring Boot), the classic psvm is still the standard entry point.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Formal vs Casual Greeting.</strong><br>
+            Old: "Good Morning Sir, how are you?" (Boilerplate).<br>
+            New: "Hi." (Concise).<br>
+            Both work, but "Hi" is faster for beginners.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Keyless Car.</strong> Old cars needed key insert + turn (PSVM). New cars just need a Button Press (void main). It simplifies the start.`,
+            hinglish: `**Java 21** se cheezein badal rahi hain.<br><br>Ab aap bina <code>public static class</code> likhe seedha <code>void main()</code> likh sakte ho. Ye beginners ke liye kiya gaya hai taaki wo dar na jayein.<br>Par companies mein abhi bhi purana tarika hi chalta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>SMS vs WhatsApp.</strong> Pehle chitti likhte the (Pura format). Ab WhatsApp pe bas "Hello" likhte hain. Kaam wahi hai, formality kam hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Instant Coffee.</strong> Pehle coffee beans peeso (Boilerplate). Ab sachet kato aur piyo.`,
+            strategy: `Lead: "This creates a smooth 'on-ramp' for students learning Java compared to Python."`
+        },
+        {
+            id: 131,
+            title: "What are ACID Properties?",
+            eng: `ACID properties ensure that database transactions are processed reliably. Without them, data would be corrupted.<br><br>A - **Atomicity** (All or Nothing).<br>C - **Consistency** (Rules must be followed).<br>I - **Isolation** (Transactions don't interfere).<br>D - **Durability** (Saved data stays saved).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>ATM Money Transfer.</strong> If you transfer money, either it leaves your account AND reaches the other account (Success), or it stays in your account (Fail). It never vanishes in between (Atomicity).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Voting Machine.</strong> One person, one vote. If two people press the button at the same time, the machine counts them separately (Isolation). Once voted, the vote is permanent (Durability).`,
+            hinglish: `ACID rules database ko reliable banate hain.<br><br>A - **Atomicity:** Pura kaam ho, ya bilkul na ho. Adha nahi.<br>C - **Consistency:** Data rules ke hisab se sahi hona chahiye.<br>I - **Isolation:** Do kaam ek saath hon to takrayein nahi.<br>D - **Durability:** Light jane par bhi data save rahe.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Transaction.</strong> Agar aapne payment kiya aur server fail ho gaya, to paise katne nahi chahiye (Atomicity).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Exam Result.</strong> Ek baar result publish ho gaya (Save ho gaya), to wo computer restart hone par gayab nahi hona chahiye (Durability).`,
+            strategy: `Lead: "Most Relational Databases (MySQL, PostgreSQL) follow ACID, while NoSQL databases (MongoDB) often follow the **CAP Theorem**."`
+        },
+        {
+            id: 132,
+            title: "What is a String Pool?",
+            eng: `String Pool is a special storage area in the **Java Heap Memory**.<br><br>Since Strings are used everywhere, storing every "Hello" as a new object would waste memory. Java checks the pool: if "Hello" exists, it returns the reference to the existing one. If not, it creates a new one. This saves huge memory.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shared Textbook.</strong> In a library, if 10 students want "Harry Potter", the librarian doesn't buy 10 new books. She gives the same book to share (if read-only).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>City Names.</strong> On a map, "Mumbai" is written once. Everyone refers to that same point. We don't create a new Mumbai for every person.`,
+            hinglish: `String Pool memory bachane ka tarika hai.<br><br>Agar code mein 10 jagah "Hello" likha hai, to Java 10 alag object nahi banata. Wo ek hi "Hello" banata hai aur sabko wahi pakda deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Classroom Chalk.</strong> Teacher chalk use karti hai. Break mein dusra teacher wahi chalk use karta hai. Nayi chalk nahi nikalte jab tak purani hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Train Route.</strong> "Delhi to Mumbai" track ek hi hai. Hazaron trains usi track (Pool) ko use karti hain.`,
+            strategy: `Trap: "String objects created with 'new String()' DO NOT go to the pool automatically. They go to the Heap. We must use .intern() to force them into the pool."`
+        },
+        {
+            id: 133,
+            title: "What is an Integer Pool?",
+            eng: `Similar to String Pool, Java caches Integer objects within a specific range (usually **-128 to 127**).<br><br>If you do <code>Integer a = 100;</code> and <code>Integer b = 100;</code>, then <code>a == b</code> is **True**. <br>But if you do <code>Integer a = 200;</code> and <code>Integer b = 200;</code>, then <code>a == b</code> is **False** (because 200 is outside the cache range, so new objects are created).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Speed Dial.</strong> Common numbers (Mom, Dad, Police) are saved on Speed Dial (Cache). Rare numbers (random shop) you have to dial manually every time.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Wallet Cash.</strong> You always keep small change (10, 20, 50, 100) in your pocket (Cache). For big amounts (2000), you go to the ATM (Heap).`,
+            hinglish: `Java chote numbers (**-128 se 127**) ko cache (save) karke rakhta hai.<br><br>Agar aapne 100 maanga, to Java bana-banaya object dega. Agar 200 maanga, to Java naya object banayega. Isliye 100==100 True hai, par 200==200 False hai (Wrapper classes mein).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Roz ka Saman.</strong> Chini-Patti (Small numbers) kitchen mein samne rakhi hoti hai. Bada saman (Big numbers) store room mein hota hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>VIP Entry.</strong> Chote numbers VIP hain, unhe direct entry milti hai. Bade numbers ko line mein lagna padta hai.`,
+            strategy: `Say: "This is defined in the IntegerCache inner class. We can actually increase the upper limit using JVM parameter -XX:AutoBoxCacheMax."`
+        },
+        {
+            id: 134,
+            title: "How does intern() method works?",
+            eng: `The <code>intern()</code> method is used to manually move a String from the Heap to the **String Pool**.<br><br>If you create <code>String s = new String("Hello");</code>, it creates 2 objects (one in Heap, one in Pool). Calling <code>s.intern()</code> returns the reference from the Pool, allowing you to save memory.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Verified Account.</strong> Anyone can make a profile named "Elon Musk" (Heap). But <code>intern()</code> is like getting the Blue Tick. It links you to the ONE official Elon Musk (Pool).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Library Donation.</strong> You bought a book (Heap). You donate it to the Library (Pool). Now everyone reads the Library copy, and you can throw away your personal copy.`,
+            hinglish: `<code>intern()</code> method zabardasti String ko Pool mein bhejta hai.<br><br>Agar aapne <code>new String()</code> use kiya, to wo Heap mein banta hai. <code>intern()</code> use karne se Java check karta hai "Kya ye Pool mein hai?". Agar haan, to wahi return karta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Sarkari Register.</strong> Aapke paas zameen ke kagaz hain (Heap). Aapne unhe Registrar office mein register karwaya (Intern). Ab wo official record (Pool) ban gaya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Official Group.</strong> WhatsApp pe bahut groups hain. Par 'intern()' matlab Official Office Group mein add hona.`,
+            strategy: `Usage: "It is rarely used explicitly now, as the G1 Garbage Collector automatically dedouplicates strings in modern Java."`
+        },
+        {
+            id: 135,
+            title: "What is A in ACID Properties?",
+            eng: `**A = Atomicity (All or Nothing).**<br><br>A transaction involves multiple steps. Atomicity ensures that either ALL steps complete successfully, or NONE of them do. If one step fails, the entire transaction is rolled back (undone). No partial data is allowed.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Online Ticket Booking.</strong> Step 1: Deduct Money. Step 2: Generate Ticket. If Step 1 succeeds but Step 2 fails, the money MUST be refunded. You can't have 'Money Gone, No Ticket'.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Jigsaw Puzzle.</strong> You can't say "I finished the puzzle" if one piece is missing. It's either Complete or Incomplete.`,
+            hinglish: `**A = Atomicity (Pura ya Kuch nahi).**<br><br>Agar process mein 4 steps hain, aur teesra fail ho gaya, to pehle 2 bhi cancel ho jayenge. Adha kaam nahi hoga.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pizza Delivery.</strong> Agar pizza thanda aaya, to pura wapas. Aisa nahi ki "Thoda kha lo, thoda wapas kar do".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Goli Chalana.</strong> Ya to goli chalegi, ya nahi chalegi. "Adhi goli" nahi chal sakti.`,
+            strategy: `Lead: "We manage this using @Transactional in Spring."`
+        },
+        {
+            id: 136,
+            title: "What is C in ACID Properties?",
+            eng: `**C = Consistency (Correctness).**<br><br>It ensures that the database moves from one valid state to another valid state. The data must satisfy all rules (Constraints, Primary Keys, Foreign Keys) before and after the transaction.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Accounting.</strong> If I transfer $100 to you, the Total Money in the bank must remain same. (My Balance + Your Balance) before = (My + Your) after. Money cannot disappear or appear magically.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Football Team.</strong> A team must have 11 players. If you sub a player out, you MUST sub a player in. You cannot play with 10 or 12. The rule (Consistency) must be kept.`,
+            hinglish: `**C = Consistency (Sahi rehna).**<br><br>Transaction ke baad data corrupt nahi hona chahiye. Sare rules follow hone chahiye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Inventory.</strong> Agar dukan mein 10 phone the, aur 1 bika, to stock 9 hona chahiye. Agar stock 8 dikha raha hai, to data Inconsistent hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Age Check.</strong> Agar rule hai "Voter Age > 18", to database kabhi bhi 17 saal ke voter ko save nahi karega.`,
+            strategy: `Say: "This is often enforced by Database Constraints."`
+        },
+        {
+            id: 137,
+            title: "What is I in ACID Properties?",
+            eng: `**I = Isolation (Separation).**<br><br>It ensures that multiple transactions occurring at the same time do not interfere with each other. Each transaction feels like it is the only one running.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Toilet Cubicles.</strong> Even though there are many people in the restroom, each person is in a private cubicle (Isolated). You don't see what others are doing.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Writing Exam.</strong> Every student writes their own paper. You cannot write on your neighbor's paper simultaneously.`,
+            hinglish: `**I = Isolation (Alag-Alag).**<br><br>Agar 10 log ek saath banking kar rahe hain, to unka kaam mix nahi hona chahiye. Sabka kaam alag-alag (Isolated) chalna chahiye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Trial Room.</strong> Kapde try karte waqt aap akele hote ho. Bahar kya ho raha hai usse fark nahi padta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Voting Booth.</strong> Jab aap vote daal rahe ho, koi aur dakhal nahi de sakta.`,
+            strategy: `Deep Dive: "There are isolation levels like Read Committed, Repeatable Read, and Serializable."`
+        },
+        {
+            id: 138,
+            title: "What is D in ACID Properties?",
+            eng: `**D = Durability (Permanence).**<br><br>Once a transaction is committed (Success), the changes are permanent. Even if the system crashes or power fails 1 second later, the data remains saved (on Hard Disk).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Carving in Stone.</strong> Once you carve a name in stone, rain or wind won't remove it. It is durable. (Writing in sand is NOT durable).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Sent Email.</strong> Once the screen says "Email Sent", it is sent. Even if you throw your phone in the water immediately, the email has reached the server.`,
+            hinglish: `**D = Durability (Mazbooti/Pakka).**<br><br>Agar screen pe aa gaya "Success", to matlab data save ho gaya. Ab chahe aag lag jaye ya computer band ho jaye, data uday-ga nahi.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Tattoo.</strong> Ek baar ban gaya to ban gaya. Pani se dhulne wala nahi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Laminated Certificate.</strong> Ab ye fat nahi sakta, pani se kharab nahi ho sakta.`,
+            strategy: `Say: "Databases achieve this using Write-Ahead Logging (WAL)." `
+        },
+        {
+            id: 139,
+            title: "Can static variables be autowired in Spring?",
+            eng: `**No, not directly.**<br><br>Why? Because <code>static</code> belongs to the **Class**, but Spring Dependency Injection works on **Objects** (Beans). Spring initializes beans *after* the class is loaded. Static variables are loaded *before* Spring starts.<br><br>Solution: We can use a non-static **Setter Method** with <code>@Autowired</code> to assign the value to the static variable.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Company Rules vs Employee Badge.</strong> Static is like a Company Rule (Applies to all). Autowire is like giving an ID Badge (Applies to one person). You can't stick an ID badge on a "Rule".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Blueprint.</strong> You can't put furniture (Autowire) into the Blueprint (Static Class). You put furniture into the built House (Object).`,
+            hinglish: `**Directly nahi.**<br><br>Kyunki Static cheezein **Class** ki hoti hain, aur Autowiring **Object** pe hoti hai. Class pehle banti hai, Spring baad mein aata hai.<br>Jugad: Hum ek Setter method banate hain aur uske zariye static variable mein value daal dete hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Hawa aur Gubara.</strong> Static Hawa hai (Sab jagah). Autowiring Gubara hai (Specific). Aap hawa pe sticker nahi laga sakte.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Notice Board.</strong> Notice board (Static) sabke liye same hai. Aap uspe kisi ek aadmi ka private letter (Autowired bean) nahi chipka sakte.`,
+            strategy: `Tip: "Using static fields in Spring beans is generally considered a bad design (Anti-pattern)." `
+        },
+        {
+            id: 140,
+            title: "What is spring-boot-starter-parent?",
+            eng: `It is a special starter project in Maven that provides default configurations for your Spring Boot application.<br><br>It manages **Dependency Versions**. You don't need to specify version numbers for libraries like Spring Web, Jackson, or Hibernate. The Parent decides the compatible versions so they don't clash ("Dependency Hell").<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Family Head.</strong> The Father (Parent) decides what everyone eats for dinner. The kids don't worry about choosing. They just eat. It simplifies choices.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>School Uniform.</strong> The School (Parent) decides the uniform color and fabric. You don't have to go to the shop and guess "Which shade of blue?". You just buy "School Uniform".`,
+            hinglish: `Ye project ka **Baap (Parent)** hai.<br><br>Iska main kaam hai **Versions sambhalna**. Aapko ye yaad rakhne ki zarurat nahi ki Spring ka kaunsa version Hibernate ke kaunse version ke saath chalega. Parent sab decide karta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Thali System.</strong> Restaurant mein Thali (Parent) order ki. Usme Dal, Roti, Sabji konsi hogi ye Chef decide karta hai. Aap alag-alag nahi chunte.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Travel Package.</strong> Tour operator (Parent) ne Hotel, Flight, Bus sab set kar diya. Aapko alag-alag book karne ki tension nahi.`,
+            strategy: `Say: "If we can't inherit from starter-parent (e.g., in a corporate multi-module project), we can use the 'Bill of Materials' (BOM) dependency import."`
+        },
+        {
+            id: 141,
+            title: "What is spring-boot-starter dependency?",
+            eng: `Starters are **Dependency Aggregators**. They group common libraries together so you don't have to add them one by one.<br><br>Example: <code>spring-boot-starter-web</code> automatically brings in Tomcat, Spring MVC, Jackson, Validation, and Logging. One line adds everything needed for a web app.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Happy Meal.</strong> instead of ordering Burger + Fries + Coke + Toy separately, you just say "One Happy Meal". It bundles everything.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Cricket Kit.</strong> You don't buy Bat, Ball, Pads, Helmet separately. You buy a "Cricket Kit". It contains everything needed to play.`,
+            hinglish: `Starters ka matlab hai **Combo Pack**.<br><br>Agar aapko Web App banana hai, to 10 alag libraries dhoondne ki zarurat nahi. Bas <code>starter-web</code> add karo, wo apne aap sab kuch (Tomcat, MVC, etc) le aayega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Make-up Kit.</strong> Alag se Lipstick, Powder, Kajal lene ki jagah pura Kit le liya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Toolbox.</strong> Plumber ko alag se pana-pechkas nahi kharidna padta. Wo pura Toolbox kharidta hai.`,
+            strategy: `Lead: "This simplifies the pom.xml file drastically."`
+        },
+        {
+            id: 142,
+            title: "What is the difference between Spring and Spring Boot?",
+            eng: `**Spring Framework:** The engine. Powerful but requires huge manual configuration (XML or Java Config). You spend days setting up the project.<br>**Spring Boot:** The car. It uses the Spring engine but adds **Auto-Configuration** and Embedded Servers. You can start coding logic in 5 minutes.<br><br>Formula: Spring Boot = Spring + Auto Config + Embedded Server - XML Configuration.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Spring:</em> **Buying Ingredients.** You buy flour, cheese, veggies and bake the pizza yourself. Flexible but takes time.<br>
+            <em>Spring Boot:</em> **Ordering Pizza.** You get a ready-made pizza. You just eat it (Code logic). Fast.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Spring:</em> **Assembling a PC.** Buy CPU, RAM, Motherboard, wire them up.<br>
+            <em>Spring Boot:</em> **Buying a MacBook.** Open box, turn on, start working.`,
+            hinglish: `**Spring:** Ye Engine hai. Power bahut hai par setup karne mein jaan nikal jati hai (XML config).<br>**Spring Boot:** Ye Gadi hai. Isme Engine wahi Spring ka hai, par ye chabi ghumaate hi start ho jati hai. Setup ka time bachta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Spring:</em> **Kapde silwana.** Kapda kharido, darzi ko do, nap do, wait karo.<br>
+            <em>Spring Boot:</em> **Readymade Kapde.** Dukan gaye, try kiya, pehen liya.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Spring:</em> **Zameen kharid ke ghar banana.**<br>
+            <em>Spring Boot:</em> **Furnished Flat kharidna.**`,
+            strategy: `Say: "Spring Boot is Opinionated. It makes decisions for you (defaults) so you don't have to."`
+        },
+        {
+            id: 143,
+            title: "What should we use in finance related logic - Double or BigDecimal?",
+            eng: `**BigDecimal.** Always.<br><br><code>Double</code> and <code>Float</code> use binary floating-point arithmetic, which is imprecise for decimals. (e.g., 0.1 + 0.2 might result in 0.3000000000004). In banking, this tiny error causes massive audit failures.<br><code>BigDecimal</code> provides exact precision.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Measuring Tape vs Laser.</strong> Double is like a cheap measuring tape (approximate). BigDecimal is a Laser Measure (Exact). You don't build a bank vault with a cheap tape.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Counting Cash.</strong> Double is like guessing "Looks like 100 rupees". BigDecimal is counting penny by penny "It is exactly 100.00".`,
+            hinglish: `**BigDecimal.** Hamesha.<br><br><code>Double</code> ganit mein kacha hai. Wo 0.1 + 0.2 ko 0.3000004 bana deta hai. Bank mein 1 paise ka ghotala bhi nahi chalega.<br>Isliye hum BigDecimal use karte hain jo bilkul sahi hisab rakhta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Sone (Gold) ka hisab.</strong> Sona taulte waqt sunar andaaza nahi lagata (Double). Wo kaante pe ratti-ratti taulta hai (BigDecimal).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Petrol Pump.</strong> Machine points mein hisab rakhti hai. Wahan 'lagbhag' nahi chalta.`,
+            strategy: `Tip: "Always use the String constructor \`new BigDecimal('0.1')\` instead of double constructor to be safe."`
+        },
+        {
+            id: 144,
+            title: "Why is it called classpath?",
+            eng: `The **Classpath** is literally the "Path to the Classes".<br><br>It tells the JVM where to look for user-defined classes and packages. Just like the OS needs a 'Path' to find .exe files, Java needs 'Classpath' to find .class files (or jars).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>School Bag.</strong> If the teacher asks for your homework, you search in your bag. Your Bag is the Classpath. If the homework is at home (not in Classpath), you get 'ClassNotFoundException'.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Contacts List.</strong> When you type "Mom", phone looks in Contacts. Contacts list is the Classpath. If not saved there, phone doesn't know who Mom is.`,
+            hinglish: `Classpath ka matlab hai "Classes ka Rasta".<br><br>JVM ko kaise pata chalega ki aapki file computer ke kaunse folder mein padi hai? Classpath wo address batata hai. Jaise chitti bhejne ke liye address chahiye, waise hi run karne ke liye classpath chahiye.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Kitchen Masala Rack.</strong> Agar aapko haldi chahiye, to aap Masala Rack (Classpath) mein dhoondoge. Agar wahan nahi hai, to Error.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Map Location.</strong> Classpath Google Maps jaisa hai jo batata hai ki destination kahan hai.`,
+            strategy: `Lead: "In Spring Boot, 'src/main/resources' is automatically added to the classpath."`
+        },
+        {
+            id: 145,
+            title: "Can we delete the application.properties file in Spring Boot?",
+            eng: `**Yes.**<br><br>Spring Boot runs on **Convention over Configuration**. If the file is missing, it simply uses default values (e.g., runs on port 8080, no database context). The app will start, but it might not do much if it needed DB credentials.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Factory Settings.</strong> If you delete your custom settings on a phone, it doesn't die. It resets to "Factory Defaults".<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Ordering Food.</strong> If you don't specify "Less Spicy" (Properties), the chef makes the standard dish (Default).`,
+            hinglish: `**Haan.**<br><br>Agar file delete kar doge, to Spring Boot **Default Settings** pe chalega (Port 8080). App crash nahi hogi (jab tak database zaruri na ho).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Nayee Gadi.</strong> Jab gadi showroom se aati hai (Default), tab bhi chalti hai. Seat cover (Properties) lagana aapki marzi hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Hotel Room.</strong> Agar aapne koi instruction nahi di, to Housekeeping standard safai karke jayega.`,
+            strategy: `Note: "However, in real projects, we actually need it for DB passwords and API keys."`
+        },
+        {
+            id: 146,
+            title: "What is Scope in Spring Boot?",
+            eng: `Scope defines the **Lifecycle and Visibility** of a Bean.<br>1. **Singleton (Default):** One instance per application.<br>2. **Prototype:** New instance every time requested.<br>3. **Request:** One instance per HTTP Request.<br>4. **Session:** One instance per User Session.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Singleton:</em> **Receptionist.** Only one per hotel. Everyone talks to the same person.<br>
+            <em>Prototype:</em> **Tissue Paper.** Every time you ask, you get a new one. You don't share tissues.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Request:</em> **Disposable Plate.** Used for one meal (Request), then thrown.<br>
+            <em>Session:</em> **Shopping Cart.** Stays with you as long as you are in the mall (Session).`,
+            hinglish: `Scope batata hai ki Bean kab tak zinda rahega.<br>1. **Singleton:** Puri app mein ek hi rahega (Jaise PM).<br>2. **Prototype:** Har baar naya (Jaise Tissue paper).<br>3. **Request:** Har click pe naya.<br>4. **Session:** Jab tak browser khula hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Singleton:</em> **Suraj (Sun).** Sabke liye ek hi hai.<br>
+            <em>Prototype:</em> **Chai ka Cup.** Sabka apna alag hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Session:</em> **Login.** Jab tak logout nahi karte, tab tak session chalta hai.`,
+            strategy: `Trap: "Be careful injecting a Prototype bean into a Singleton bean. The Prototype will only be created ONCE (when the Singleton is created), losing its prototype behavior."`
+        },
+        {
+            id: 147,
+            title: "What is Spring Initializr?",
+            eng: `Spring Initializr (start.spring.io) is a **web tool** to quickly generate a Spring Boot project structure.<br><br>You select Maven/Gradle, Java version, and Dependencies (Web, JPA, MySQL). It gives you a zip file with the standard folder structure and \`pom.xml\` ready. It saves setup time.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Cake Mix.</strong> Instead of buying flour, sugar, baking soda separately, you buy a Box Mix. Just add water and bake.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Starter Kit.</strong> Like a Lego kit. It comes with the base plate and bricks sorted, ready to build.`,
+            hinglish: `Ye ek website hai (**start.spring.io**) jo Spring Boot ka project bana ke deti hai.<br><br>Aap bas batao "Mujhe Web aur Database chahiye". Wo pura folder structure aur settings ready karke Zip file de dega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pizza Base.</strong> Pizza base bana banaya mil gaya (Initializr). Ab bas topping dalo aur bake karo.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Form.</strong> Bank account kholne ka form. Sab kuch printed hai, bas sign karna hai.`,
+            strategy: `Say: "It is integrated into IDEs like IntelliJ and Eclipse too."`
+        },
+        {
+            id: 148,
+            title: "What is CommandLineRunner?",
+            eng: `It is an interface used to run code **once** immediately after the application starts.<br><br>We implement the <code>run()</code> method. It is useful for seeding data into the database (e.g., creating an Admin user) or checking file paths at startup.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Pre-Flight Check.</strong> Pilots check instruments immediately after starting the engine but before taking off. That is CommandLineRunner.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Morning Routine.</strong> As soon as you wake up (App Start), you brush your teeth (Runner) before doing anything else.`,
+            hinglish: `Ye ek aisa code hai jo App start hote hi **sabse pehle chalta hai**.<br><br>Iska use hum Database mein default user banane ke liye ya settings check karne ke liye karte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Curtain Raiser.</strong> Show shuru hone se pehle parde uthana. Ye pehla kaam hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Starter.</strong> Gadi start karte hi dashboard ki lights jalti hain check karne ke liye. Wahi hai ye.`,
+            strategy: `Contrast: "Another similar interface is **ApplicationRunner**, which offers arguments in a more structured way."`
+        },
+        {
+            id: 149,
+            title: "How to implement Logging in Spring Boot?",
+            eng: `Spring Boot uses **SLF4J** and **Logback** by default.<br><br>We don't need to configure anything. Just use <code>LoggerFactory.getLogger(Class.class)</code>. We can configure log levels (INFO, DEBUG, ERROR) in <code>application.properties</code> to control what gets printed.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Black Box in Planes.</strong> It records everything happening. If the plane crashes (Error), investigators read the Black Box (Logs) to find the cause.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>CCTV Camera.</strong> It silently records everything. If a theft happens, you check the footage.`,
+            hinglish: `Spring Boot mein **SLF4J** default hota hai.<br><br>Humein bas Logger object banana hai aur likhna hai <code>log.info("Message")</code>. System.out.println use nahi karna chahiye kyunki Logs ko file mein save kiya ja sakta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ship ki Logbook.</strong> Captain har ghante likhta hai "Hum kahan hain". Agar ship kho jaye, to logbook se pata chalega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Diary.</strong> Roz ki baatein diary mein likhna. Baad mein padh ke yaad aata hai kya hua tha.`,
+            strategy: `Tip: "Use @Slf4j annotation from Lombok to avoid creating the logger line manually."`
+        },
+        {
+            id: 150,
+            title: "What is ConcurrentHashMap?",
+            eng: `It is a thread-safe version of HashMap.<br><br>Unlike Hashtable (which locks the whole map), ConcurrentHashMap divides the map into **Segments**. When a thread writes to Segment A, Segment B is still open for others. This allows multiple threads to work simultaneously without blocking each other completely. (High Performance).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Train Toilets.</strong><br>
+            <em>Hashtable:</em> Locks the entire bogie door. Only 1 person can use any toilet.<br>
+            <em>ConcurrentHashMap:</em> Locks only the specific toilet door. 4 people can use 4 toilets simultaneously.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Library Sections.</strong> Locking the Science section doesn't stop students from entering the Arts section.`,
+            hinglish: `Ye HashMap ka **Fast aur Safe** version hai.<br><br>Hashtable pure Map pe taala laga deta hai (Slow). ConcurrentHashMap Map ko tukdon (Segments) mein baant deta hai. Ek tukde pe kaam ho raha hai to baki tukde khule rehte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Apartment.</strong><br>
+            <em>Hashtable:</em> Main Gate band kar diya. Koi nahi aa sakta.<br>
+            <em>ConcurrentHashMap:</em> Sirf Flat ka darwaza band kiya. Padosi apne flat mein ja sakta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Bank Counters.</strong> Ek counter busy hone se pura bank band nahi hota.`,
+            strategy: `Fact: "It does not allow Null keys or values."`
+        },
+        {
+            id: 151,
+            title: "What is better: application.properties or application.yml?",
+            eng: `Both do the same thing, but **YML** is preferred for complex structures.<br><br>Properties files are flat and repetitive (<code>server.port=8080</code>, <code>server.path=/api</code>).<br>YML is hierarchical and cleaner (Tree structure). However, formatting (spaces) is strict in YML.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>List vs Mind Map.</strong><br>
+            Properties is a long boring list.<br>
+            YML is a Mind Map/Tree diagram. Easier to visualize relationships.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Full Name vs Family Tree.</strong><br>
+            Properties: Rahul Sharma, Amit Sharma, Priya Sharma.<br>
+            YML: Sharma -> [Rahul, Amit, Priya]. Less typing.`,
+            hinglish: `Dono same hain, par **YML** zyada neat hai.<br><br>Properties file mein baar-baar likhna padta hai (server.port, server.name).<br>YML mein ek baar Server likho, aur uske neeche sab daal do. Padhne mein aasan hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Shopping List.</strong><br>
+            <em>Properties:</em> Fruit Apple, Fruit Banana, Fruit Mango.<br>
+            <em>YML:</em> Fruit -> Apple, Banana, Mango.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Address.</strong> YML mein address hierarchical dikhta hai (India -> Delhi -> Saket), jo samajhne mein aasan hai.`,
+            strategy: `Note: "@PropertySource annotation still does not support YML files easily, so properties file is safer for custom configs."`
+        },
+        {
+            id: 152,
+            title: "What is Aspect Oriented Programming (AOP)?",
+            eng: `AOP allows us to separate **Cross-Cutting Concerns** (like Logging, Security, Transaction) from the main Business Logic.<br><br>Instead of writing logging code in every single method (clutter), we define an "Aspect". This Aspect runs automatically before or after the methods we select. It keeps code clean.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Mall Security.</strong> The shops (Business Logic) just sell clothes. They don't check bags. The Security Guard at the gate (Aspect) checks everyone. He is separate but applies to all shops.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>School Bell.</strong> The Bell (Aspect) rings at 9 AM. All classes start. Teachers don't look at their watches every second. The Bell cuts across all classes.`,
+            hinglish: `AOP ka matlab hai "Faltu kaam alag karna".<br><br>Logging, Security, Error Handling—ye sab Business Logic nahi hain. Agar har method mein log likhenge to code ganda ho jayega.<br>AOP ek "Guard" ki tarah hai jo method chalne se pehle ya baad mein apna kaam kar deta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Flight Announcement.</strong> Air Hostess har passenger ke paas jaake nahi bolti "Seatbelt bandho". Wo speaker pe bolti hai (Aspect) jo sabko sunayi deta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Toll Tax.</strong> Highway pe gadi chalana (Business Logic) hai. Toll Naka (Aspect) hai jo beech mein aata hai, tax leta hai, aur jane deta hai.`,
+            strategy: `Keywords: "Advice (What to do), Pointcut (Where to do), Aspect (The class)." `
+        },
+        {
+            id: 153,
+            title: "What is the difference between @Component and @Bean?",
+            eng: `1. **@Component:** Class-level annotation. Used for classes YOU write. Spring scans and creates the bean (Auto-detection).<br>2. **@Bean:** Method-level annotation. Used in configuration classes. Typically used for **Third-party libraries** where you cannot add @Component to the source code.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>@Component:</em> **Your Children.** You name them directly. You control them.<br>
+            <em>@Bean:</em> **Adopting a Child.** The child is already born (Third party). You sign papers (@Bean method) to bring them into your family (Spring Context).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>@Component:</em> **Homemade Food.** You make it.<br>
+            <em>@Bean:</em> **Ordering from Zomato.** You didn't make it, but you bring it to your table.`,
+            hinglish: `1. **@Component:** Ye un classes pe lagta hai jo **Aapne** likhi hain. Spring unhe dhoond leta hai.<br>2. **@Bean:** Ye un classes ke liye hai jo **Dusron** ne likhi hain (Library). Aap unke code mein jaake @Component nahi likh sakte na? To aap ek method banate ho aur @Bean lagate ho.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>@Component:</em> **Apna Ghar.** Aap paint kar sakte ho.<br>
+            <em>@Bean:</em> **Hotel Room.** Aap paint nahi kar sakte, bas use kar sakte ho.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>@Component:</em> **Khud ki Gadi.**<br>
+            <em>@Bean:</em> **Rental Gadi.**`,
+            strategy: `Summary: "@Bean gives more control over initialization logic."`
+        },
+        {
+            id: 154,
+            title: "How to sort 10GB of data with 1GB of RAM?",
+            eng: `You cannot load all 10GB into RAM. You use **External Merge Sort**.<br><br>1. **Split:** Divide 10GB into ten 1GB chunks.<br>2. **Sort:** Load 1st chunk, sort it in RAM, save to disk. Repeat for all chunks.<br>3. **Merge:** Open all 10 sorted files as streams. Compare the first element of each file, pick the smallest, write to Final Output. Repeat.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Evaluating Exam Papers.</strong> You have 10,000 papers but a small desk. You take 100 papers, sort them, put them in a pile. Repeat. Finally, you merge the piles.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Counting Coins.</strong> Huge bag of coins. You pour a handful (1GB), count/sort, put in box. Repeat.`,
+            hinglish: `Pura 10GB RAM mein nahi aayega (Crash ho jayega). Hum **External Merge Sort** use karenge.<br><br>1. Data ko 10 hisson mein todo.<br>2. Ek-ek hissa RAM mein lao, sort karo, aur wapas disk pe save karo.<br>3. Ab 10 sorted files ko dheere-dheere padho aur final file mein likho.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Kapde Teh (Fold) karna.</strong> Pura dher bed pe nahi aata. Thode kapde liye, teh kiye, almari mein rakhe. Fir aur liye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Anaaj Saaf karna.</strong> Pura anaaj ek thali mein nahi aata. Thoda-thoda leke saaf karte hain.`,
+            strategy: `Lead: "This is a classic 'Divide and Conquer' strategy used by Database engines."`
+        },
+        {
+            id: 155,
+            title: "Explain the working of MVC?",
+            eng: `**Model-View-Controller (MVC)** is a design pattern for web apps.<br>1. **Controller:** Takes user request (Waiter).<br>2. **Model:** The data/logic (Chef/Ingredients).<br>3. **View:** The output page/HTML (Plated Food).<br><br>Flow: User -> Controller -> Service/Model -> Controller -> View -> User.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Restaurant.</strong><br>
+            You (User) give order to Waiter (Controller).<br>
+            Waiter tells Chef (Model) to cook.<br>
+            Waiter brings Food on a Plate (View) to you.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>TV Remote.</strong><br>
+            You press button (Controller).<br>
+            Internal circuit changes channel (Model).<br>
+            Screen shows new picture (View).`,
+            hinglish: `Ye Web Apps ka design hai.<br>1. **Controller:** Request leta hai (Receptionist).<br>2. **Model:** Data aur Logic (Kitchen).<br>3. **View:** Jo user ko dikhta hai (Saji hui plate).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>ATM.</strong><br>
+            Button dabaya (Controller).<br>
+            Machine ne paise gine (Model).<br>
+            Screen pe "Collect Cash" dikha (View).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Car.</strong><br>
+            Steering/Pedal (Controller).<br>
+            Engine (Model).<br>
+            Speedometer/Window view (View).`,
+            strategy: `Note: "In modern usage (React/Angular), Spring only acts as REST Controller (sending JSON data), so the 'View' part is handled by the frontend."`
+        },
+        {
+            id: 156,
+            title: "What is the difference between @Controller and @RestController?",
+            eng: `1. **@Controller:** Used for traditional MVC. It returns a **View Name** (like "home.jsp"). It expects a View Resolver to find the HTML file.<br>2. **@RestController:** Used for REST APIs. It returns **Data** (JSON/XML) directly. It is a combination of <code>@Controller</code> + <code>@ResponseBody</code>.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Controller:</em> **Painter.** You ask for a landscape. He gives you a Painting (View).<br>
+            <em>RestController:</em> **Data Analyst.** You ask for statistics. He gives you an Excel sheet (Raw Data/JSON).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Controller:</em> Delivers a full Pizza (HTML page).<br>
+            <em>RestController:</em> Delivers just the recipe/ingredients list (JSON Data).`,
+            hinglish: `1. **@Controller:** Ye HTML page return karne ke liye hai. (Purana style).<br>2. **@RestController:** Ye **JSON Data** return karne ke liye hai. (Modern APIs). Isme <code>@ResponseBody</code> lagane ki zarurat nahi padti.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Controller:</em> **Akhbaar (Newspaper).** Pura page sajha hua aata hai.<br>
+            <em>RestController:</em> **News Ticker.** Sirf headlines (Text) aati hain.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Controller:</em> Restaurant mein baith ke khana (Ambience + Food).<br>
+            <em>RestController:</em> Takeaway (Sirf Food dabba).`,
+            strategy: `Lead: "So @RestController is basically @Controller annotated with @ResponseBody on every method."`
+        },
+        {
+            id: 157,
+            title: "What are Virtual Threads?",
+            eng: `Virtual Threads (Project Loom, Java 21) are lightweight threads managed by the **JVM**, not the OS.<br><br>Traditional threads are heavy (1 MB each). You can only have a few thousand. Virtual threads are tiny (bytes). You can have **millions** of them. They are perfect for high-throughput server applications (I/O bound).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Emails vs Letters.</strong><br>
+            <em>OS Thread:</em> Writing physical letters (Paper cost, Stamp cost). Expensive.<br>
+            <em>Virtual Thread:</em> Sending Emails. Free, instant, can send millions.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Uber Pool vs Bus.</strong><br>
+            <em>OS Thread:</em> Hiring a personal limo for every passenger. Expensive.<br>
+            <em>Virtual Thread:</em> Putting everyone in a Metro train. Cheap and efficient.`,
+            hinglish: `Ye Java 21 ka krantikari feature hai.<br><br>Normal Threads heavy hote hain (OS manage karta hai). Virtual Threads **halke** hote hain (JVM manage karta hai).<br>Aap 1 million Virtual Threads bana sakte ho bina computer hang kiye. Ye server ko super-fast banata hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Ants vs Elephants.</strong><br>
+            <em>OS Thread:</em> Haathi (Bada, kam jagah).<br>
+            <em>Virtual Thread:</em> Cheeti (Choti, lakhon aa sakti hain).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>WhatsApp Messages.</strong> SMS bhejne mein paise lagte the (OS Thread). WhatsApp free hai (Virtual Thread). Jitne marzi bhejo.`,
+            strategy: `Say: "This eliminates the need for complex Reactive Programming (WebFlux) for most use cases."`
+        },
+        {
+            id: 158,
+            title: "What is @SpringBootTest?",
+            eng: `This annotation is used for **Integration Testing**.<br><br>It starts up the complete Spring Application Context (creates all beans, connections) so you can test the application as a whole. It is heavy/slow compared to Unit Tests (@WebMvcTest).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Test Drive.</strong> Checking the engine separately is Unit Test. Taking the car out on the road (@SpringBootTest) checks if Engine + Wheels + Brakes work together.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Dress Rehearsal.</strong> Practicing lines alone is Unit Test. Full dress rehearsal with lights/sound is Integration Test.`,
+            hinglish: `Ye **Integration Testing** ke liye hai.<br><br>Ye puri Spring App ko start karta hai (Fake server). Ye check karta hai ki sab parts milke sahi kaam kar rahe hain ya nahi.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Exam.</strong><br>
+            <em>Unit Test:</em> Chapter wise test.<br>
+            <em>SpringBootTest:</em> Final Board Exam (Pura syllabus).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>House Inspection.</strong> Sirf nalka check karna Unit test hai. Pani chala ke dekhna ki leakage to nahi hai, ye Integration test hai.`,
+            strategy: `Tip: "We typically use it with \`TestRestTemplate\` or \`MockMvc\` to call our APIs."`
+        },
+        {
+            id: 159,
+            title: "What is Spring Boot DevTools?",
+            eng: `DevTools provides developer-friendly features like **Automatic Restart** (Hot Reload) and LiveReload.<br><br>When you change code and save, DevTools automatically restarts the application context. You don't have to manually stop and start the server. It saves development time.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Instant Mirror.</strong> When you comb hair, you see changes instantly in the mirror. You don't have to take a photo and develop it to see how you look.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Google Docs.</strong> You type, it saves automatically. You don't press Ctrl+S every time.`,
+            hinglish: `Ye developers ki help ke liye hai.<br><br>Iska sabse bada feature hai **Automatic Restart**. Jaise hi aap code change karke Save karte ho, ye server refresh kar deta hai. Baar-baar Run button dabane ki zarurat nahi.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Live Cricket Score.</strong> Score apne aap update hota hai. Refresh button nahi dabana padta.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Typing Tutor.</strong> Galat type karte hi laal line aa jati hai. Wait nahi karna padta.`,
+            strategy: `Note: "It is automatically disabled when you package the application for production (jar file)." `
+        },
+        {
+            id: 160,
+            title: "What is Spring Data JPA?",
+            eng: `Spring Data JPA is a layer on top of JPA/Hibernate that eliminates boilerplate code.<br><br>Instead of writing DAO classes and SQL queries, you just create an **Interface** extending <code>JpaRepository</code>. Spring automatically provides methods like <code>save()</code>, <code>findAll()</code>, <code>findById()</code> at runtime.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Voice Assistant.</strong> Instead of walking to switch, you say "Alexa, lights on". You just declare the intent (Interface), Alexa does the work.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Autopilot.</strong> You don't fly the plane manually. You set destination, the computer flies it.`,
+            hinglish: `Ye Hibernate ko aur aasan banata hai.<br><br>Aapko query likhne ki zarurat nahi. Bas interface banao: <code>interface UserRepo extends JpaRepository</code>. Spring apne aap <code>save</code>, <code>delete</code>, <code>find</code> ke methods bana dega.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Magic Wand.</strong> Harry Potter spell bolta hai, kaam ho jata hai. Kaise hua, wo magic (Spring) janta hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Vending Machine.</strong> Button dabao, coke niklegi. Andar kaise nikli, wo machine ka kaam hai.`,
+            strategy: `Lead: "It also supports 'Derived Query Methods' like \`findByNameAndAge(String name, int age)\`."`
+        },
+        {
+            id: 161,
+            title: "SQL to find employee with Nth highest salary?",
+            eng: `The most generic way (supported by MySQL, Postgres, Oracle) is using **DENSE_RANK()**.<br><br><code>SELECT * FROM (SELECT name, salary, DENSE_RANK() OVER (ORDER BY salary DESC) as rnk FROM Employee) WHERE rnk = N;</code><br><br>Why Dense Rank? Because if two people have same highest salary, it handles ties correctly without skipping rank.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Class Rank.</strong> If Rahul and Amit both got 99/100 (Rank 1), the next person with 98 gets Rank 2 (Dense Rank), not Rank 3.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Podium.</strong> Gold, Silver, Bronze. Even if 2 people win Gold, the next prize is Silver.`,
+            hinglish: `Sabse best tarika hai **DENSE_RANK()** function.<br><br>Query: "Salary ko descending order mein jamao aur rank de do. Fir wo row utha lo jiski rank N hai."<br>Dense rank isliye taaki agar do logon ki salary same ho, to rank skip na ho.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Race.</strong> Agar 2 log First aaye, to agla banda Second aayega. Third nahi.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Waiting List.</strong> List mein number wise naam hote hain. Nth banda wahi hai jo Nth number pe hai.`,
+            strategy: `Alternative: "In MySQL specifically, we can use \`LIMIT N-1, 1\` but that fails with ties."`
+        },
+        {
+            id: 162,
+            title: "What is CompletableFuture?",
+            eng: `<code>CompletableFuture</code> (Java 8) allows strictly asynchronous **non-blocking** programming.<br><br>It allows you to chain tasks (Callbacks). "Do Task A, THEN do Task B, THEN do Task C". Main thread doesn't wait. When Task A finishes, it automatically triggers B.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Domino's Order Tracker.</strong> You order (Task A). You don't stand at counter. When Baking is done -> Packing starts (Task B) -> Delivery starts (Task C). You get notified at end.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Relay Race.</strong> Runner 1 runs. As soon as he finishes, Runner 2 starts automatically. They are chained.`,
+            hinglish: `Ye Java mein Async programming ke liye hai.<br><br>Iska fayda hai **Chaining**. "Ye kaam karo, jab ho jaye to wo karo, fir wo karo." Main thread block nahi hota.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Factory Line.</strong> Machine A ne bottle banayi -> Machine B ne label lagaya -> Machine C ne pack kiya. Sab automatic sequence mein.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Cooking.</strong> Tel garam karo (Task A). Jab garam ho jaye -> Jeera dalo (Task B).`,
+            strategy: `Say: "It helps us write non-blocking code similar to Promises in JavaScript."`
+        },
+        {
+            id: 163,
+            title: "What is the difference between Future and CompletableFuture?",
+            eng: `1. **Future (Java 5):** You submit a task, you get a Future. To get the result, you MUST call <code>get()</code>, which **blocks** the thread until result is ready. (Not truly async).<br>2. **CompletableFuture (Java 8):** You don't need to block. You attach a callback (<code>thenApply</code>). When result is ready, it pushes it to the callback automatically.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Future:</em> **Checking Oven.** You keep opening the door "Is cake ready? No. Is it ready? No." (Blocking).<br>
+            <em>CompletableFuture:</em> **Oven Timer.** You set it and go watch TV. "Ding!" sound calls you when ready (Callback).<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Future:</em> **Waiting for Parcel.** Standing at the door staring at the road.<br>
+            <em>CompletableFuture:</em> **Phone Notification.** "Your package has been delivered."`,
+            hinglish: `1. **Future:** Isme result lene ke liye wait karna padta hai (Blocking).<br>2. **CompletableFuture:** Isme wait nahi karna padta. Jab kaam ho jata hai, ye khud bata deta hai (Callback).<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Future:</em> **Pani ki tanki dekhna.** Baar baar chat pe jaake dekhna ki tanki bhari ya nahi.<br>
+            <em>CompletableFuture:</em> **Alarm.** Tanki bharte hi alarm baj jayega.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Future:</em> Line mein khade rehna.<br>
+            <em>CompletableFuture:</em> Token leke baith jana. Number aayega to bula lenge.`,
+            strategy: `Summary: "Future is Pull-based (Give me result). CompletableFuture is Push-based (Here is result)."`
+        },
+        {
+            id: 164,
+            title: "What is Object/Relational Impedance Mismatch?",
+            eng: `This fancy term describes the **Structure Gap** between Object Oriented (Java) and Relational DB (SQL).<br><br>1. **Granularity:** Java has many classes (Address inside User), SQL has one table.<br>2. **Inheritance:** Java has inheritance, SQL tables don't.<br>3. **Identity:** Java uses \`==\`, SQL uses Primary Key.<br>ORMs like Hibernate try to bridge this gap, but it's never perfect.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Square Peg in Round Hole.</strong> Java objects are squares. SQL tables are circles. They don't fit perfectly. Hibernate is the hammer that forces them in.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Language Barrier.</strong> You speak English (Java). Database speaks Chinese (SQL). There is a mismatch. You need a Translator (Hibernate).`,
+            hinglish: `Ye Java (Objects) aur Database (Tables) ke beech ki **Anban (Difference)** hai.<br><br>Java mein Inheritance hoti hai, Database mein nahi. Java mein Object ke andar Object hota hai, Database mein Table alag hoti hai.<br>In dono ko milana mushkil hota hai. Isi problem ko Impedance Mismatch kehte hain.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <strong>Adapter.</strong> Indian plug American socket mein nahi lagta. Mismatch hai. Adapter (Hibernate) chahiye.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <strong>Oil and Water.</strong> Dono liquid hain par mix nahi hote. Unhe mix karne ke liye mehnat lagti hai.`,
+            strategy: `Lead: "We solve Inheritance mismatch using strategies like Single Table, Joined Table, or Table Per Class."`
+        },
+        {
+            id: 165,
+            title: "What is the difference between EntityManager and EntityManagerFactory?",
+            eng: `1. **EntityManagerFactory:** Heavy object. Created **ONCE** per application. It creates EntityManagers. Thread-safe.<br>2. **EntityManager:** Lightweight. Created **PER Request/Transaction**. It performs actual DB operations (find, persist). NOT thread-safe.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Factory:</em> **Car Factory.** You build the factory once. It's huge.<br>
+            <em>Manager:</em> **Car.** The factory produces many cars. You use a car for a trip (Transaction) and park it.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Factory:</em> **Bakery.** The shop itself.<br>
+            <em>Manager:</em> **Bread.** The product you buy and eat.`,
+            hinglish: `1. **Factory:** Ye **Factory** hai. Puri app mein ek hi hoti hai. Ye bhari hoti hai.<br>2. **Manager:** Ye **Worker** hai. Har naye kaam (Transaction) ke liye naya worker banta hai.<br><br>
+            <strong>Real Life Example 1:</strong><br>
+            <em>Factory:</em> **Bijli Ghar (Power Plant).** Ek hi hota hai.<br>
+            <em>Manager:</em> **Switch.** Har kamre mein alag hota hai.<br><br>
+            <strong>Real Life Example 2:</strong><br>
+            <em>Factory:</em> **Bank Head Office.**<br>
+            <em>Manager:</em> **Teller (Cashier).** Jo aapka kaam karta hai.`,
+            strategy: `Trap: "Never share an EntityManager between threads. It causes data corruption."`
+        },
+        {
+            id: 166,
+            title: "Final Strategy: How to Close the Interview?",
+            eng: `You have answered the technicals. Now close with attitude.<br>Ask: "I noticed your team uses X technology. I have been reading about how it integrates with Y. Do you plan to move towards Z architecture in the future?"<br>This shows you are not just a coder, but a **Thinker**.<br><br>
+            <strong>Real Life Example:</strong><br>
+            <strong>Dating.</strong> Don't just answer questions. Ask about *their* interests. It turns an interrogation into a conversation.`,
+            hinglish: `Interview khatam karte waqt chup mat raho.<br>Unse pucho: "Maine suna hai aap log X technology use karte ho. Kya future mein Y pe shift hone ka plan hai?"<br>Isse lagta hai ki aap sirf coder nahi, **Engineer** ho.<br><br>
+            <strong>Real Life Example:</strong><br>
+            <strong>Rishta dekhna.</strong> Sirf sawalon ke jawab mat do. Unse bhi pucho "Aapko kya pasand hai?". Impression acha padta hai.`,
+            strategy: `Smile and say: "Thank you for the opportunity. I really enjoyed the technical depth of this discussion."`
+        }
+        // ... TO ADD MORE QUESTIONS, COPY THE BLOCK ABOVE, CHANGE ID AND TEXT ...
+    ];
+
+    // Populate the rest of the list titles quickly for the sidebar
+    // NOTE: In a real app, you would fill the eng/hinglish for all 100+. 
+    // Here we generate placeholders so the search/UI works for the full list provided.
+    const rawTitles = [
+        "What is the difference between method Overloading and Overriding?",
+        "What is @SpringBootApplication annotation?",
+        "What is the difference between Checked and Unchecked exception?",
+        "What is N+1 problem?",
+        "What is Serialization?",
+        "What is Marker interface?",
+        "Why do we need Interface and Abstract Class in Java?",
+        "Can we have concrete methods in Java interface?",
+        "What is Encapsulation?",
+        "What is Abstraction?",
+        "What is Inheritance?",
+        "Can static methods be abstract in Java?",
+        "What is @Override annotation in Java?",
+        "What are the new features of Java 8?",
+        "What is Streams API?",
+        "What is Optional class?",
+        "What is the difference between Comparable and Comparator?",
+        "What is the difference between Eager Loading and Lazy Loading?",
+        "Explain final, finally {} and finalize()?",
+        "What are the new Java 9 features?",
+        "What are the new Java 10 features?",
+        "Why multiple inheritance is not allowed in Java?",
+        "What is Hibernate Criteria API?",
+        "What is volatile keyword?",
+        "What is the difference between ArrayList and LinkedList?",
+        "Can Java code be executed without generating .class file?",
+        "What is the difference between HashSet, LinkedHashSet and TreeSet?",
+        "What is the difference between JDK, JRE and JVM?",
+        "Can we have default arguments in Java?",
+        "Can a constructor be final in Java?",
+        "What are the new Java 11 features?",
+        "What is Classloader in Java?",
+        "What is Primary Cache in Hibernate?",
+        "Why String is immutable in Java?",
+        "What is an Enum in Java?",
+        "What is the difference between synchronized, volatile and atomic in Java?",
+        "What is the difference between TDD and BDD?",
+        "What is the difference between isEmpty() and isBlank()?",
+        "Why StringBuffer is obsolete?",
+        "What is Nested class in Java?",
+        "What is Secondary Cache in Hibernate?",
+        "How to prevent Singleton Pattern from Serialization?",
+        "Explain try, catch and finally in Java?",
+        "How to prevent Singleton Pattern from Cloning?",
+        "What is a Constructor in Java?",
+        "Can Constructors be overloaded?",
+        "What is atomic variable in Java?",
+        "How to prevent Singleton Pattern from Reflection?",
+        "What is super keyword in Java?",
+        "What is this keyword in Java?",
+        "Can constructors have a return type?",
+        "What is differnce between Stack memory and Heap memory?",
+        "What is the difference between Hibernate and JPA?",
+        "What is an Association in Java?",
+        "What is an Aggregation in Java?",
+        "What is Composition in Java?",
+        "What is the difference between JDBC and Hibernate?",
+        "What are Annotations in Java?",
+        "What is DateTime API in Java?",
+        "What are 4 main default Functional Interfaces in Java?",
+        "What are stereotype annotations in Spring?",
+        "What are Design Patterns in Java?",
+        "What is Cloning in Java?",
+        "What are Wrapper classes in Java?",
+        "Does Java has Copy Constructor?",
+        "What is Package in Java?",
+        "What happens when the main() isn't declared as static?",
+        "Difference between instance and local variables?",
+        "What is Record in Java?",
+        "What is Multithreading in Java?",
+        "Explain Thread life cycle?",
+        "What are Daemon Threads in Java?",
+        "What is Garbage collection in Java?",
+        "What is the difference between HashMap and Hashtable?",
+        "What is the difference between Call By Value and Call By Reference?",
+        "What is executor framework in Java?",
+        "Why Java is Call by Value?",
+        "How does Thread Pool reuse a thread?",
+        "What is the difference between Runnable and Callable?",
+        "Is Java still relevant in 2024?",
+        "What is Race condition in Multithreading?",
+        "What is Deadlock in Multithreading?",
+        "What is Livelock in Multithreading?",
+        "Can we create infinite threads in Java?",
+        "What is Sealed class?",
+        "What is typecasting in Java?",
+        "What is hashcode() and equals() contract?",
+        "What is Hashing?",
+        "Explain internal working of HashSet?",
+        "Explain internal working of HashMap?",
+        "Why Java is not pure object oriented language?",
+        "Why to use Getter and Setter methods?",
+        "What are Parallel Streams in Java?",
+        "What is a ForkJoinPool in Java?",
+        "What is a ReentrantLock?",
+        "What is the difference between PermGen and Metaspace in Java?",
+        "What are Covariant return types?",
+        "What is the difference between == and equals() in Java?",
+        "What is Cyclic Dependency?",
+        "What is Memory Leak in Java?",
+        "What is Thread Safe code?",
+        "What is ThreadLocal?",
+        "What is Method Reference?",
+        "What is Tight Coupling and Loose Coupling?",
+        "What is Inversion of Control?",
+        "What is Dependency Injection?",
+        "What is a Bean in Spring Framework?",
+        "What is Autowiring in Spring?",
+        "What is @Qualifier?",
+        "What if the bean mentioned in @Qualifier is not available?",
+        "What is @Primary?",
+        "What if the bean annotated with @Primary is not available?",
+        "What is the difference between @Qualifier and @Primary?",
+        "What are SOLID Principles?",
+        "What is S in SOLID Principles?",
+        "What is O in SOLID Principles?",
+        "What is L in SOLID Principles?",
+        "What is I in SOLID Principles?",
+        "What is D in SOLID Principles?",
+        "Is public static void main insignificant in Java now?",
+        "What are ACID Properties?",
+        "What is a String Pool?",
+        "What is an Integer Pool?",
+        "How does intern() method works?",
+        "What is A in ACID Properties?",
+        "What is C in ACID Properties?",
+        "What is I in ACID Properties?",
+        "What is D in ACID Properties?",
+        "Can static variables be autowired in Spring?",
+        "What is spring-boot-starter-parent?",
+        "What is spring-boot-starter dependency?",
+        "What is the difference between Spring and Spring Boot?",
+        "What should we use in finance related logic - Double or BigDecimal?",
+        "Why is it called classpath?",
+        "Can we delete the application.properties file in Spring Boot?",
+        "What is Scope in Spring Boot?",
+        "What is Spring Initializr?",
+        "What is CommandLineRunner?",
+        "How to implement Logging in Spring Boot?",
+        "What is ConcurrentHashMap?",
+        "What is better: application.properties or application.yml?",
+        "What is Aspect Oriented Programming?",
+        "What is the difference between @Component and @Bean?",
+        "How to sort 10GB of data with 1GB of RAM?",
+        "Explain the working of MVC?",
+        "What is the difference between @Controller and @RestController?",
+        "What are Virtual Threads?",
+        "What is @SpringBootTest?",
+        "What is Spring Boot DevTools?",
+        "What is Spring Data JPA?",
+        "SQL to find employee with Nth highest salary?",
+        "What is CompletableFuture?",
+        "What is the difference between Future and CompletableFuture?",
+        "What is Object/Relational Impedance Mismatch?",
+        "What is the difference between EntityManager and EntityManagerFactory?"
+    ];
+
+    // Helper to generate IDs and placeholder text for the rest
+    let currentId = 11;
+    rawTitles.forEach(t => {
+        questionsDB.push({
+            id: currentId++,
+            title: t,
+            eng: "Detailed explanation coming soon. Use this space to practice your answer.",
+            hinglish: "Iska jawaab jald hi update hoga. Filhal khud practice karein.",
+            strategy: "Suggest the next logical question in the flow."
+        });
+    });
+
+    // --- State Management ---
+    const viewedQuestions = new Set();
+    let isHinglish = false;
+    let currentQuestion = null;
+
+    // --- Core Logic ---
+
+    function startApp() {
+        document.getElementById('welcome-screen').style.opacity = '0';
+        setTimeout(() => {
+            document.getElementById('welcome-screen').style.display = 'none';
+        }, 800);
+    }
+
+    function renderList(filter = "") {
+        const listEl = document.getElementById('questionList');
+        listEl.innerHTML = "";
+        
+        questionsDB.forEach(q => {
+            if(q.title.toLowerCase().includes(filter.toLowerCase())) {
+                const li = document.createElement('li');
+                li.className = 'question-item';
+                if(viewedQuestions.has(q.id)) li.classList.add('completed');
+                
+                li.innerHTML = `
+                    <span>${q.title}</span>
+                    <div class="status"></div>
+                `;
+                li.onclick = () => loadQuestion(q.id, li);
+                listEl.appendChild(li);
+            }
+        });
+    }
+
+    // --- Add/Replace these functions in your script ---
+
+    function loadQuestion(id, liElement) {
+        // 1. Mark active in UI
+        document.querySelectorAll('.question-item').forEach(el => el.classList.remove('active'));
+        if(liElement) liElement.classList.add('active');
+
+        // 2. Fetch Data
+        currentQuestion = questionsDB.find(q => q.id === id);
+        updateContent();
+        
+        // 3. Progress Logic
+        if(!viewedQuestions.has(id)) {
+            viewedQuestions.add(id);
+            if(liElement) liElement.classList.add('completed');
+            updateProgress();
+        }
+
+        // 4. UI Display Logic
+        document.getElementById('empty-state').style.display = 'none';
+        document.getElementById('answer-display').style.display = 'block';
+
+        // 5. MOBILE SPECIFIC: Switch to reading mode
+        document.body.classList.add('reading-mode');
+        
+        // Auto-scroll to top of content
+        document.querySelector('.content-area').scrollTop = 0;
+    }
+
+    // New Function for the Back Button
+    function goBack() {
+        // Remove the class to slide the answer away and show the list
+        document.body.classList.remove('reading-mode');
+    }
+
+    function updateContent() {
+        if(!currentQuestion) return;
+        
+        const display = document.getElementById('answer-display');
+        const content = isHinglish ? currentQuestion.hinglish : currentQuestion.eng;
+        
+        display.innerHTML = `
+            <h2>${currentQuestion.title}</h2>
+            <div class="section-title">The Explanation</div>
+            <div class="explanation">${content}</div>
+            
+            <div class="strategy-box">
+                <h3><span style="font-size:1.2rem">💡</span> Lead the Interviewer</h3>
+                <p style="color: #d1fae5; font-size: 0.95rem;">${currentQuestion.strategy}</p>
+            </div>
+        `;
+        
+        // Retrigger animation
+        display.style.animation = 'none';
+        display.offsetHeight; /* trigger reflow */
+        display.style.animation = 'slideIn 0.3s ease-out';
+    }
+
+    function updateProgress() {
+        const total = questionsDB.length;
+        const current = viewedQuestions.size;
+        const pct = Math.floor((current / total) * 100);
+        
+        document.getElementById('progressBar').style.width = pct + "%";
+        document.getElementById('progress-val').innerText = pct;
+    }
+
+    function filterQuestions() {
+        const term = document.getElementById('searchInput').value;
+        renderList(term);
+    }
+
+    // Toggle Listener
+    document.getElementById('langToggle').addEventListener('change', (e) => {
+        isHinglish = e.target.checked;
+        updateContent();
+    });
+
+    // Init
+    renderList();
+
+</script>
+</body>
+</html>
\ No newline at end of file
