Tricky Core Java Interview Questions and Answers for 2-5 Years of Experience

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this article, we will discuss tricky core Java interview questions and answers for both beginners and developers with 2-5 years of experience.

Let's begin.

1) What happens if a return statement is executed inside the try or catch block? Does the finally block still execute?

Yes, the finally block still executes even if return is executed inside try or catch. When Java hits return, it doesn’t immediately leave the method. The JVM first computes the return value, then runs finally, and only after that does it actually return to the caller. This design exists because finally is meant for cleanup logic like closing files, releasing locks, and resetting state.

The real trap is when finally itself returns a value or throws a new exception. If finally contains a return, it overrides the earlier return from try or catch, which can silently break your logic. In interviews, the safe takeaway is: avoid return in finally and keep finally limited to cleanup.

public class Demo {
    static int test() {
        try {
            return 10;
        } finally {
            System.out.println("finally runs");
        }
    }

    public static void main(String[] args) {
        System.out.println(test()); // prints "finally runs" then 10
    }
}

2) Is it possible to execute a program without a catch block? If so, how would you use try and finally together?

Yes, you can write try with only a finally block and no catch. This is useful when you don’t want to handle the exception at the current level, but you still must run cleanup code no matter what happens. If an exception occurs in the try block, the finally block will run and then the exception will continue propagating up the call stack.

In real projects, this pattern appears in low-level utility code or legacy code where you want centralized error handling higher up (like a global exception handler) but still must close resources. In modern Java, try-with-resources is preferred for closable resources, but try + finally is still valid and often asked in interviews.

public class Demo {
    public static void main(String[] args) {
        try {
            System.out.println(10 / 0);
        } finally {
            System.out.println("cleanup always runs");
        }
        // Exception still propagates after finally executes.
    }
}

3) How does exception handling with try-catch-finally affect the performance of a Java application?

A try-catch-finally structure does not meaningfully hurt performance when exceptions are not thrown. The JVM is optimized for the “happy path.” Simply wrapping code in try does not automatically make it slow. In fact, in most production apps, you’ll see try blocks everywhere, especially around I/O and external calls.

The cost happens when exceptions are thrown frequently. Creating an exception object and capturing a stack trace is expensive, and unwinding the stack also adds overhead. That’s why using exceptions for normal control flow, like breaking loops or validating common cases, is considered bad design and can create noticeable performance issues at scale.

public class Demo {
    static void fastPath() {
        try {
            int x = 10 + 20; // no exception
        } catch (Exception e) {
            // not executed
        }
    }

    static void slowPath() {
        try {
            throw new RuntimeException("boom");
        } catch (RuntimeException e) {
            // throwing is expensive, especially repeatedly
        }
    }
}

4) In which scenario will the finally block not execute?

In normal program flow, finally executes almost always: after a successful try, after a handled exception, and even when you return early. That’s why Java developers trust finally for cleanup. If your code reaches the try block, Java will do its best to run finally before leaving that scope.

However, there are rare situations where finally won’t execute because the JVM stops abruptly. The most common interview answer is System.exit(), which terminates the JVM immediately. Other cases include JVM crash, OS-level process kill, or sudden power loss. The important point is that finally is guaranteed only when the JVM continues normal execution.

public class Demo {
    public static void main(String[] args) {
        try {
            System.out.println("inside try");
            System.exit(0);
        } finally {
            System.out.println("this will NOT print");
        }
    }
}

5) Can we write multiple finally blocks in Java?

No, a single try block can have only one finally block. Java’s grammar simply doesn’t allow multiple finally blocks attached to the same try. So if you have multiple cleanup actions, you put them inside the single finally block.

That said, you can use nested try blocks where each try has its own finally. This is sometimes used when cleanup steps depend on earlier steps, or when you want isolated cleanup behavior. But in modern Java, try-with-resources usually provides a cleaner approach for resource management.

public class Demo {
    public static void main(String[] args) {
        try {
            System.out.println("outer try");
            try {
                System.out.println("inner try");
            } finally {
                System.out.println("inner finally");
            }
        } finally {
            System.out.println("outer finally");
        }
    }
}

6) How would you handle multiple exceptions in a single catch block?

Java 7 introduced multi-catch, which lets you catch multiple exception types in one catch block using the | operator. This is useful when different exceptions have the same handling logic, such as logging and wrapping them into a custom exception. It reduces duplicate code and keeps error handling consistent.

One detail interviewers like: the exception variable in a multi-catch is implicitly final, meaning you can’t assign it to something else inside the catch block. That design avoids confusion because the variable could represent different types at runtime.

import java.io.IOException;
import java.sql.SQLException;

public class Demo {
    static void work(boolean io) throws IOException, SQLException {
        if (io) throw new IOException("io issue");
        throw new SQLException("db issue");
    }

    public static void main(String[] args) {
        try {
            work(true);
        } catch (IOException | SQLException e) {
            System.out.println("Handled: " + e.getClass().getSimpleName());
        }
    }
}

7) Can a Java application be run without installing the JRE?

Yes, in modern Java you can run an application without requiring a separately installed JRE on the machine. Since Java 9, the platform is modular, and you can build a trimmed runtime image containing only the required modules using jlink. That runtime image includes the JVM and necessary libraries, so users can run your app without installing Java separately.

In enterprise environments, this is valuable because it avoids “works on my machine” Java version mismatches. Teams ship an app together with a tested runtime, making deployments more predictable. In interviews, mention “custom runtime image” or “bundled runtime” and the interviewer usually knows you understand modern Java packaging.

8) Is it possible to have the JDK installed without having the JRE?

In older Java versions, JRE and JDK were separate downloads. In modern Java distributions (Java 11+), the separate JRE download is no longer the standard approach. The JDK includes everything needed to compile and run Java programs, meaning the runtime components are already part of the JDK installation.

So practically, if you install the JDK, you already have what you need to run Java applications. Interviewers ask this to check whether you understand the difference historically versus how modern Java distributions work today.

public class Demo {
    public static void main(String[] args) {
        System.out.println(System.getProperty("java.runtime.version"));
        System.out.println(System.getProperty("java.home"));
        // If JDK is installed, you can compile and run using javac and java.
    }
}

9) Can you tell me what algorithm the JVM uses for garbage collection?

The JVM does not use a single fixed garbage collection algorithm. It supports multiple collectors, and the actual GC in use depends on the JVM version, vendor, and runtime flags. Common collectors include G1 GC, Parallel GC, Serial GC, ZGC, and Shenandoah. Different collectors target different goals, like throughput, low latency, or small heap size.

In interviews, the best answer is to explain that GC is pluggable, and you can choose it based on your workload. Then show how to check which GC is active at runtime. That proves you understand GC as a configuration choice rather than a single “one correct algorithm” answer.

import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<String> gcs = java.lang.management.ManagementFactory
                .getGarbageCollectorMXBeans()
                .stream()
                .map(gc -> gc.getName())
                .toList();

        System.out.println("GCs in use: " + gcs);
    }
}

10) How can memory leaks occur in Java, even if we have automatic garbage collection?

Garbage collection removes objects that are unreachable. A memory leak in Java happens when objects remain reachable through references, even though your application no longer needs them. The GC cannot collect them because, from the JVM’s perspective, they are still in use. This is why “automatic GC” does not mean “no memory leaks.”

Classic causes include static collections that keep growing, caches without eviction policies, listeners not being removed, ThreadLocal misuse, and holding references to large object graphs longer than necessary. Interviewers want you to describe reachability and references, not just say “Java has GC so no leaks.”

import java.util.ArrayList;
import java.util.List;

public class Demo {
    private static final List<byte[]> LEAK = new ArrayList<>();

    public static void main(String[] args) {
        while (true) {
            LEAK.add(new byte[1024 * 1024]); // keep references forever
            System.out.println("Allocated MB: " + LEAK.size());
        }
    }
}

11) Is Java a 100% object-oriented programming language?

No, Java is not 100% object-oriented because it supports primitive types such as int, double, char, and boolean. These are not objects and do not have methods. The language design keeps primitives for performance and memory efficiency.

At the same time, Java provides wrapper classes like Integer and Double to represent primitive values as objects when needed. This mix is one reason Java balances developer productivity with strong runtime performance.

The second reason is related to the static keyword. In a pure object-oriented language, we should access everything through objects. However, Java contains static variables and methods that can be accessed directly without using objects.

public class Demo {
    public static void main(String[] args) {
        int a = 10;          // primitive
        Integer b = 10;      // object wrapper
        System.out.println(a);
        System.out.println(b.toString());
    }
}

12) What are the advantages of Java being partially object-oriented?

The biggest advantage is performance. Primitive types avoid object allocation overhead and reduce memory usage. If every number were an object, Java programs would create far more objects, increasing GC pressure and slowing down execution. This is especially important in high-throughput enterprise systems and low-latency services.

Another advantage is simpler interoperability with CPU-level operations. Arithmetic on primitives maps efficiently to machine instructions. Java still lets you work with objects when needed through wrappers and autoboxing, giving you flexibility without forcing object overhead everywhere.

public class Demo {
    public static void main(String[] args) {
        int primitiveSum = 10 + 20;          // fast, no allocations
        Integer boxedSum = Integer.valueOf(10) + Integer.valueOf(20); // involves boxing/unboxing
        System.out.println(primitiveSum);
        System.out.println(boxedSum);
    }
}

13) What is the use of object-oriented programming language in enterprise projects?

Enterprise projects are large, long-lived, and maintained by many developers. OOP helps by structuring code into clear models like services, repositories, controllers, and domain objects. Encapsulation ensures internal details stay protected. Abstraction allows teams to swap implementations without rewriting callers. Polymorphism enables flexible behavior through interfaces, which is heavily used in Spring and other enterprise frameworks.

OOP also supports testing and maintainability. When your design uses interfaces and clean boundaries, you can mock dependencies in unit tests, isolate modules, and scale the system without turning the codebase into a single giant file. That’s the core enterprise value: managing complexity as teams and requirements grow.

interface PaymentGateway {
    void pay(double amount);
}

class StripeGateway implements PaymentGateway {
    public void pay(double amount) {
        System.out.println("Paid via Stripe: " + amount);
    }
}

class CheckoutService {
    private final PaymentGateway gateway;

    CheckoutService(PaymentGateway gateway) {
        this.gateway = gateway;
    }

    void checkout(double amount) {
        gateway.pay(amount);
    }
}

14) Explain `public static void main` in Java

main is the JVM entry point. The JVM looks for a method with the exact signature public static void main(String[] args) to start executing your program. public ensures the JVM can access it from outside the class. static allows the JVM to call it without creating an object first. void means it returns nothing to the JVM.

String[] args provides command-line arguments. Even if you don’t use args, the signature must match what the JVM expects. Interviews often test whether you understand that the JVM is not “calling a random method” but searching for a very specific entry point.

public class Demo {
    public static void main(String[] args) {
        System.out.println("Args length: " + args.length);
        if (args.length > 0) {
            System.out.println("First arg: " + args[0]);
        }
    }
}

15) What will happen if we don't declare the main as a static?

The code can compile, but the program won’t start. The JVM tries to invoke main without creating an instance of the class. If main is not static, the JVM cannot call it directly, so it fails at runtime with an error indicating the main method is not found in the required form.

This is a common trick question because many people assume it’s a compilation problem. It’s usually a runtime startup problem because the entry point signature is not what the JVM expects.

public class Demo {
    public void main(String[] args) { // not static
        System.out.println("Won’t run as entry point");
    }
}

16) Can we override the main method?

Not in the true runtime-polymorphism sense, because main is static. Static methods are not overridden; they are hidden. If a subclass defines its own main, it doesn’t override the parent’s main. It simply defines another static method with the same name in the subclass.

The JVM will run whichever class you execute. If you run Parent, it uses Parent.main. If you run Child, it uses Child.main. This question tests whether you know the difference between overriding (runtime dispatch) and static method hiding (compile-time binding).

class Parent {
    public static void main(String[] args) {
        System.out.println("Parent main");
    }
}

class Child extends Parent {
    public static void main(String[] args) {
        System.out.println("Child main");
    }
}

17) Can we overload the main method?

Yes, you can overload main by changing the parameter list. Java treats it like any other method for overloading rules. But the JVM will only treat public static void main(String[] args) as the entry point. Overloaded versions won’t be called automatically.

A common interview follow-up is: how do you call the overloaded main? Answer: you must call it explicitly from the real entry-point main method.

public class Demo {
    public static void main(String[] args) {
        main(10);
        main("hello");
    }

    public static void main(int x) {
        System.out.println("Overloaded main with int: " + x);
    }

    public static void main(String s) {
        System.out.println("Overloaded main with String: " + s);
    }
}

18) Can primitive data types be null?

No, primitives cannot be null. A primitive variable always holds a value. For example, an int always contains some integer value, and if you don’t explicitly assign it, Java assigns a default value in fields (like 0 for int). Only reference types can hold null.

Wrapper classes can be null because they are objects. This becomes important with autoboxing and unboxing. Unboxing a null wrapper causes a NullPointerException, which is a classic interview edge case.

public class Demo {
    public static void main(String[] args) {
        Integer boxed = null;
        // int primitive = null; // compile-time error
        try {
            int primitive = boxed; // unboxing null -> NPE
        } catch (NullPointerException e) {
            System.out.println("NPE due to unboxing null");
        }
    }
}

19) Can we declare pointers in Java?

Java does not support explicit pointers like C or C++. You cannot access raw memory addresses or perform pointer arithmetic. Java uses references internally, but they are safe references, not pointers you can manipulate. This design prevents many security and memory corruption problems.

This is one of the reasons Java is popular in enterprise development. You get memory safety, strong type checks, and controlled object access. When interviewers ask about pointers, they want you to highlight that Java intentionally hides memory addresses to keep the runtime safe and portable.

public class Demo {
    static class User {
        String name;
        User(String name) { this.name = name; }
    }

    public static void main(String[] args) {
        User u1 = new User("Ramesh");
        User u2 = u1; // reference copy, not pointer arithmetic
        u2.name = "Updated";
        System.out.println(u1.name); // Updated
    }
}

20) Why do we use wrapper classes in collections?

Java Collections store objects, not primitives. You cannot store int, double, or char directly inside List, Set, or Map. Wrapper classes such as Integer, Double, and Character allow primitive values to be treated as objects.

This design ensures uniform behavior in collections and enables object-level features like generics, null handling, and method calls.

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10); // auto-boxing
        numbers.add(20);
        System.out.println(numbers);
    }
}

21) Difference between auto-boxing and unboxing?

Auto-boxing is automatic conversion of a primitive to its wrapper class. Unboxing is converting a wrapper object back to a primitive.

The compiler inserts conversion code automatically, which makes code cleaner but sometimes hides performance or null-related issues.

public class Demo {
    public static void main(String[] args) {
        Integer boxed = 10;   // auto-boxing
        int primitive = boxed; // unboxing
        System.out.println(primitive);
    }
}

22) Can auto-boxing/unboxing cause a NullPointerException?

Yes. If a wrapper object is null and Java tries to unbox it, a NullPointerException occurs.

This is common in enterprise applications when database values are nullable and mapped to wrapper types.

public class Demo {
    public static void main(String[] args) {
        Integer value = null;
        try {
            int x = value; // unboxing null
        } catch (NullPointerException e) {
            System.out.println("NPE occurred");
        }
    }
}

23) When might String Pool not be beneficial?

The String Pool saves memory by reusing literals. However, when creating many dynamic strings (e.g., in loops), pooling can increase memory retention and reduce performance.

For heavy string manipulation, StringBuilder is better because it avoids creating many intermediate objects.

public class Demo {
    public static void main(String[] args) {
        String result = "";
        for (int i = 0; i < 1000; i++) {
            result += i; // inefficient
        }
    }
}

24) When is StringBuffer better than String?

String is immutable. Every modification creates a new object. StringBuffer is mutable and thread-safe.

If multiple threads modify the same string, StringBuffer ensures synchronization.

public class Demo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello");
        sb.append(" World");
        System.out.println(sb);
    }
}

25) Why do we need packages in Java?

Packages organize classes, prevent naming conflicts, and provide access control.

In large enterprise systems, packages improve maintainability and modularity.

package com.example.service;

public class UserService {
}

26) Why use getter/setter instead of public fields?

Encapsulation protects internal state. If fields are public, any class can modify them without validation.

Getters and setters allow validation, logging, and future changes without breaking code.

class User {
    private int age;

    public void setAge(int age) {
        if (age < 0) throw new IllegalArgumentException();
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

27) Can a top-level class be private or protected?

No. A top-level class can only be public or package-private (default).

Private and protected are only valid for nested classes.

class DefaultClass {} // valid
// private class Test {} // invalid

28) Can a class exist without methods or fields?

Yes. Marker classes or placeholder classes are valid.

Java allows empty classes.

class EmptyClass {
}

29) How can we create singleton classes?

Singleton ensures only one instance exists.

The most robust way is using an enum or static initialization.

class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

30) Can we use a private constructor?

Yes. Private constructors prevent object creation from outside.

Used in Singleton, utility classes, and factory patterns.

class Utility {
    private Utility() {}
}

31) Can constructors be overloaded?

Yes. You can define multiple constructors with different parameters.

class User {
    String name;
    int age;

    User(String name) {
        this.name = name;
    }

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

32) Why are immutable objects useful in concurrency?

Immutable objects cannot change state after creation. Therefore, they are inherently thread-safe.

No synchronization is required because no thread can modify the object.

final class Person {
    private final String name;

    Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

33) How to create immutable classes?

Make class final, fields private final, no setters, and use defensive copies for mutable fields.

final class ImmutableUser {
    private final String name;

    ImmutableUser(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

34) Can a class extend itself?

No. This causes cyclic inheritance error.

// class A extends A {} // Compilation error

35) Why multiple inheritance not allowed in Java?

To avoid the Diamond Problem where ambiguity arises from multiple parent classes having same method.

Java solves this via interfaces.

36) How does method overloading relate to polymorphism?

Overloading is compile-time polymorphism. The method is selected based on parameters at compile time.

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

37) What is dynamic method dispatch?

Dynamic method dispatch is runtime polymorphism. The method call is resolved at runtime based on object type.

class Animal {
    void sound() { System.out.println("Animal sound"); }
}

class Dog extends Animal {
    void sound() { System.out.println("Bark"); }
}

public class Demo {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound(); // Bark
    }
}

38) Can constructors be polymorphic?

No. Constructors are not inherited, so they cannot be overridden.

39) Examples of abstraction in Java libraries?

Interfaces like List, Map, Set, and JDBC API are strong examples.

List<String> list = new ArrayList<>();

You program to interface, not implementation.

40) What happens if a class includes an abstract method?

The class must be declared abstract.

abstract class Shape {
    abstract void draw();
}

41) How abstraction helps modularity?

Abstraction hides implementation details and allows swapping implementations easily.

42) Interface vs extend class?

Use interface when defining contract. Extend class when sharing common behavior.

43) How to achieve multiple inheritance?

Using interfaces.

class A implements Runnable, Comparable<A> {
    public void run() {}
    public int compareTo(A o) { return 0; }
}

44) Can interface contain static method?

Yes (Java 8+). Static methods must be called using interface name.

interface Utility {
    static void print() {
        System.out.println("Static method");
    }
}

45) How encapsulation promotes security?

Encapsulation restricts direct access and protects object integrity.

46) How compiler determines overloaded method?

Based on method signature, argument types, and best match at compile time.

47) Can we overload methods only by return type?

No. Method signature must differ in parameters.

// int test() {}
// double test() {} // Not allowed

48) Rules for method overloading

Same method name
Different parameter list
Return type can differ

50) Rules for method overriding

Same method signature
Cannot reduce visibility
Cannot throw broader checked exception
Cannot override final method

51) How @Override helps?

It ensures method correctly overrides parent method. If signature is wrong, compiler throws error.

class Parent {
    void show() {}
}

class Child extends Parent {
    @Override
    void show() {}
}

52) What happens if a super class method is overridden by more than one subclass?

Each subclass provides its own implementation. When you call the method through a superclass reference, runtime polymorphism determines which implementation executes based on the object’s actual type.

There is no conflict between subclasses because method dispatch happens at runtime. Each subclass overrides independently.

class Parent {
    void show() {
        System.out.println("Parent");
    }
}

class ChildA extends Parent {
    void show() {
        System.out.println("ChildA");
    }
}

class ChildB extends Parent {
    void show() {
        System.out.println("ChildB");
    }
}

public class Demo {
    public static void main(String[] args) {
        Parent p1 = new ChildA();
        Parent p2 = new ChildB();
        p1.show(); // ChildA
        p2.show(); // ChildB
    }
}

53) What happens if you use super in a class that doesn't have a super class?

Every class in Java implicitly extends Object. So technically, every class has a superclass except Object.

However, you cannot use super inside a class that does not extend another class explicitly to access non-existing members. Attempting to reference something not present in the superclass causes compilation error.

class A {
    void display() {}
}

class B extends A {
    void test() {
        super.display(); // valid
    }
}

54) Can this or super be used in static methods?

No. Static methods belong to the class, not instances. Both this and super refer to instance context.

Using them in static methods results in compilation error.

class Test {
    static void show() {
        // System.out.println(this); // error
    }
}

55) How does super play a role in polymorphism?

super allows a subclass to call its parent’s implementation. This is useful when you override a method but still want to reuse parent logic.

Polymorphism chooses the overridden method at runtime, but super explicitly invokes parent behavior.

class Parent {
    void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    void greet() {
        super.greet();
        System.out.println("Hello from Child");
    }
}

56) Can a static block throw an exception?

Yes, but only unchecked exceptions. Checked exceptions must be handled inside the static block.

If a static block throws runtime exception, class initialization fails.

class Demo {
    static {
        if (true) throw new RuntimeException("Error in static block");
    }
}

57) Can we override static methods in Java?

No. Static methods are not overridden; they are hidden.

Method resolution happens at compile time based on reference type.

class Parent {
    static void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("Child");
    }
}

58) Can we print without main prior to Java 8?

Yes, using static blocks. When class loads, static block executes.

class Demo {
    static {
        System.out.println("Hello without main");
        System.exit(0);
    }
}

59) Common use cases for final variable?

Used for constants, preventing reassignment, method parameters, and thread-safe immutable fields.

final int MAX = 100;

60) How does final contribute to immutability and thread safety?

Final variables cannot be reassigned. When fields are final, object state cannot change after construction.

Immutable objects are inherently thread-safe because no thread can modify their state.

final class Person {
    private final String name;
    Person(String name) {
        this.name = name;
    }
}

61) Can a functional interface extend another interface?

Yes, if it still has only one abstract method.

interface A {
    void show();
}

@FunctionalInterface
interface B extends A {}

62) When is TreeSet better than HashSet?

When sorted order is required.

TreeSet maintains natural or custom ordering.

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        set.add(5);
        set.add(1);
        System.out.println(set); // sorted
    }
}

63) What happens when two keys have the same hash code?

They go into the same bucket. Equals method is used to differentiate keys.

64) HashMap changes in Java 8

Buckets converted to balanced tree when collision chain > 8
Improves worst-case performance from O(n) to O(log n)

65) How does ConcurrentHashMap improve performance?

Uses segment locking (Java 7) and bucket-level locking (Java 8). Allows concurrent reads and updates without locking the entire map.

65) How do design patterns affect performance?

Good patterns improve scalability and maintainability. Poor usage can introduce unnecessary abstraction overhead.

66) Which design pattern for DB connection management?

Singleton + Connection Pooling (e.g., HikariCP).

67) How to handle two threads updating same data structure?

Use synchronization, locks, or concurrent collections.

synchronized(this) {
    counter++;
}

68) Can we start a thread twice?

No. Calling start() twice throws IllegalThreadStateException.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide