💡 Top 10 Core Java Interview Questions

Welcome back to The Code Hut! 🚀 Whether you’re preparing for a Java interview or brushing up your knowledge, these are the most common core Java questions you should know. Each question includes a short explanation or code example.

1. What is the difference between JDK, JRE, and JVM? 🖥️

JVM: Runs Java bytecode and provides platform independence.
JRE: JVM + libraries required to run Java programs.
JDK: JRE + development tools like compiler and debugger.

2. Explain Java memory model (Heap vs Stack) 🧠

Heap: Stores objects and instance variables; garbage-collected.
Stack: Stores method calls, local variables; follows LIFO.

3. What are Java access modifiers? 🔒

Access levels: private, default, protected, public. They control visibility of classes, methods, and fields.

4. Difference between == and equals() ⚖️


String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);      // false, compares references
System.out.println(a.equals(b)); // true, compares values

5. Difference between abstract class and interface 🏗️

Abstract class can have fields and method implementations; interface defines a contract (Java 8+ allows default methods). Classes can implement multiple interfaces but extend only one abstract class.

6. What is a Java Stream? 🌊

Streams allow functional-style operations on collections:


List nums = List.of(1, 2, 3, 4);
nums.stream()
    .filter(n -> n % 2 == 0)
    .forEach(System.out::println); // 2 4

7. Difference between checked and unchecked exceptions ⚠️

Checked: Must be handled or declared (e.g., IOException).
Unchecked: Runtime exceptions, not required to be handled (e.g., NullPointerException).

8. What are Java 8 functional interfaces? 🧩

Interfaces with a single abstract method, used for lambdas: Runnable, Callable, Function, Predicate.

9. Explain final, finally, and finalize 🔄

final: Constants, methods that cannot be overridden, classes that cannot be extended.
finally: Block executed after try/catch.
finalize: Method called by GC before object destruction (deprecated).

10. Difference between String, StringBuilder, and StringBuffer ✏️

String: Immutable.
StringBuilder: Mutable, not thread-safe.
StringBuffer: Mutable, thread-safe.

✅ Conclusion

These are the most frequently asked core Java questions in interviews. Make sure you understand these concepts and practice coding examples to boost your confidence for any Java interview.

Labels for this post: Java, Interview Prep, Core Java

Comments

Post a Comment

Popular posts from this blog

🛠️ The Code Hut - Index

🌐 Distributed Systems Series 📖 Distributed Systems with Java (Series Intro) 📖 Intro to Distributed Systems ☁️ Cloud-Native Considerations ⚠️ Distributed System Anti-Patterns 🧪 Testing Strategies for Distributed Systems 🛡️ Advanced Fault Tolerance 🔗 Distributed Transactions Deep Dive 📈 Microservices Scaling Patterns 🔔 Monitoring & Alerting 📡 Event-Driven Architecture 🔐 Security in Distributed Systems 👀 Observability ⚡ Caching Strategies 📊 Consistency Models 🔍 Service Discovery & Load Balancing 💪 Resilience Patterns 💬 Communication Patterns 🧱 Fault Tolerance & Reliability 🔄 Transactions & Sagas 🤝 Consensus & Coordination 🔒 Concurrency & Locking 🏗️ Microservices & Architecture 🧩 Key Microservices Design Patterns 📐 Applying SOLID Principles 🌐 RESTful API Fundamentals — Designing Clean, Resource-Oriented Endpoints ⚡ REST vs gRPC in Java: Choosing the Right Com...
Read more

🛡️ Resilience Patterns in Distributed Systems

Welcome back to The Code Hut Distributed Systems series! In this post, we’ll explore patterns that help distributed systems remain resilient under failure conditions. 💪⚡ 🌐 Why Resilience Patterns Matter In distributed systems, failures are inevitable. Resilience patterns help: ❌ Prevent cascading failures ⚡ Maintain availability 😊 Improve user experience during partial outages 1. 🛑 Circuit Breaker A circuit breaker stops requests to a failing service to prevent overwhelming it and allows the system to recover gracefully. Circuit breaker states: Closed: Requests flow normally. Open: Requests fail immediately; fallback triggers. Half-Open: A few trial requests check if the service has recovered. Example with Resilience4j: // Using Resilience4j circuit breaker CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("service"); Supplier decorated = CircuitBreaker .decorateSupplier(circuitBreaker, () -> remoteService.cal...
Read more

🛡️ Thread-Safe Programming in Java: Locks, Atomic Variables & LongAdder

Writing thread-safe code in Java requires understanding locks, atomic variables, and concurrent utilities. In this post, we'll explore ReentrantLock, synchronized blocks, AtomicLong, LongAdder , and when to use each. 1. 🔑 Synchronized Blocks The simplest way to make a section of code thread-safe is the synchronized keyword. It locks on an object monitor. public class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } ✅ Easy to use for simple critical sections ❌ Locks the entire object, can reduce concurrency 2. 🔄 ReentrantLock More flexible than synchronized blocks. Supports tryLock , timed locks, and interruptible locks. import java.util.concurrent.locks.ReentrantLock; ReentrantLock lock = new ReentrantLock(); lock.lock(); try { // critical section } finally { lock.unlock(); } ✅ Better for advanced locking strategies, fairnes...
Read more