Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Deep explanation of JDK, JRE, and JVM — what each contains, how they relate, the JVM architecture with class loader, memory areas, execution engine, and practical differences for developers.
These three acronyms — JDK, JRE, and JVM — are the foundation of Java's platform. Understanding what each contains and how they relate is crucial for both development and interview success.
The Relationship: JDK ⊃ JRE ⊃ JVM
Think of it as concentric circles:
┌─────────────────────────────────────────────────────┐
│ JDK (Java Development Kit) │
│ ┌─────────────────────────────────────────────┐ │
│ │ JRE (Java Runtime Environment) │ │
│ │ ┌─────────────────────────────────────┐ │ │
│ │ │ JVM (Java Virtual Machine) │ │ │
│ │ │ - Class Loader │ │ │
│ │ │ - Memory Areas (Heap, Stack, etc.) │ │ │
│ │ │ - Execution Engine (JIT + GC) │ │ │
│ │ └─────────────────────────────────────┘ │ │
│ │ + Core Libraries (rt.jar / modules) │ │
│ │ + Configuration files │ │
│ └─────────────────────────────────────────────┘ │
│ + javac (compiler) │
│ + jdb (debugger) │
│ + javadoc (documentation generator) │
│ + jar (archive tool) │
│ + jshell (REPL) │
│ + other development tools │
└─────────────────────────────────────────────────────┘
JVM (Java Virtual Machine)
The JVM is an abstract computing machine that provides the runtime environment for executing Java bytecode. It's "virtual" because it doesn't correspond to any physical hardware — it's a software specification.
What the JVM Does
Example
public class JVMDemo {
public static void main(String[] args) {
// The JVM does all of this automatically:
// 1. Loads the class (ClassLoader)
System.out.println("Class loaded by: " +
JVMDemo.class.getClassLoader());
// 2. Verifies bytecode (Bytecode Verifier)
// 3. Allocates memory (Memory Manager)
int[] array = new int[1000]; // Heap allocation
// 4. Manages threads
System.out.println("Current thread: " +
Thread.currentThread().getName());
// 5. Garbage collects unused objects
Runtime runtime = Runtime.getRuntime();
System.out.println("Max memory: " + runtime.maxMemory() / (1024*1024) + " MB");
System.out.println("Free memory: " + runtime.freeMemory() / (1024*1024) + " MB");
// 6. Provides runtime services
System.out.println("Available processors: " + runtime.availableProcessors());
}
}
Output
Class loaded by: jdk.internal.loader.ClassLoaders$AppClassLoader@251a69d7 Current thread: main Max memory: 4096 MB Free memory: 252 MB Available processors: 8
JVM Architecture — Detailed Breakdown
1. Class Loader Subsystem
The Class Loader is responsible for loading .class files into memory:
Example
public class ClassLoaderDemo {
public static void main(String[] args) {
// Three types of ClassLoaders (hierarchical):
// 1. Bootstrap ClassLoader — loads core Java classes (java.lang.*)
// Written in C/C++, returns null when queried
System.out.println("String ClassLoader: " +
String.class.getClassLoader()); // null = Bootstrap
// 2. Platform/Extension ClassLoader — loads platform classes
System.out.println("Platform ClassLoader: " +
ClassLoader.getPlatformClassLoader());
// 3. Application/System ClassLoader — loads your classes
System.out.println("App ClassLoader: " +
ClassLoaderDemo.class.getClassLoader());
// Delegation model: child asks parent first
// App → Platform → Bootstrap
ClassLoader appLoader = ClassLoaderDemo.class.getClassLoader();
System.out.println("Parent of App: " + appLoader.getParent());
System.out.println("Parent of Platform: " + appLoader.getParent().getParent());
}
}
Output
String ClassLoader: null Platform ClassLoader: jdk.internal.loader.ClassLoaders$PlatformClassLoader@1d81eb93 App ClassLoader: jdk.internal.loader.ClassLoaders$AppClassLoader@251a69d7 Parent of App: jdk.internal.loader.ClassLoaders$PlatformClassLoader@1d81eb93 Parent of Platform: null
Class Loading Phases:
| Phase | What Happens |
|---|---|
| Loading | Reads .class file, creates Class object |
| Linking - Verification | Checks bytecode is valid and safe |
| Linking - Preparation | Allocates memory for static fields (default values) |
| Linking - Resolution | Resolves symbolic references to direct references |
| Initialization | Runs static initializers and assigns static field values |
2. JVM Memory Areas (Runtime Data Areas)
java example
public class MemoryAreasDemo {
// Static field → Method Area (shared across threads)
private static String appName = "MemoryDemo";
// Instance field → stored in Heap (when object is created)
private int instanceVar = 42;
public static void main(String[] args) {
// 'args' → Stack (local variable)
// 'obj' reference → Stack, actual object → Heap
MemoryAreasDemo obj = new MemoryAreasDemo();
int localVar = 100; // → Stack
String str = "Hello"; // → String Pool (part of Heap)
obj.demonstrate(localVar);
}
public void demonstrate(int param) {
// 'param' → new Stack frame
// 'temp' → Stack frame
int temp = param + instanceVar;
System.out.println("Result: " + temp);
// When this method returns, its stack frame is destroyed
}
}Output
Result: 142
JVM Memory Areas Explained:
| Area | Content | Shared? | Lifecycle |
|---|---|---|---|
| Method Area | Class metadata, static fields, constant pool, method bytecode | Yes (all threads) | Lives until class is unloaded |
| Heap | All objects and arrays | Yes (all threads) | Until garbage collected |
| Stack | Local variables, method parameters, return addresses | No (per thread) | Per method call (frame) |
| PC Register | Address of currently executing instruction | No (per thread) | Changes with each instruction |
| Native Method Stack | Data for native (C/C++) methods | No (per thread) | During native calls |
3. Execution Engine
The Execution Engine converts bytecode to native machine code:
Example
public class ExecutionEngineDemo {
public static void main(String[] args) {
// The Execution Engine has three components:
// 1. INTERPRETER — executes bytecode line by line (slow but quick start)
// Used for code executed only once
// 2. JIT COMPILER — compiles "hot" methods to native code (fast execution)
// A method becomes "hot" after being called many times
long start = System.nanoTime();
long sum = 0;
// After enough iterations, the JIT compiler optimizes this loop
for (int i = 0; i < 10_000_000; i++) {
sum += computeValue(i); // JIT will inline this method!
}
long elapsed = System.nanoTime() - start;
System.out.println("Sum: " + sum);
System.out.println("Time: " + elapsed / 1_000_000 + " ms");
System.out.println("(JIT made this faster than pure interpretation)");
// 3. GARBAGE COLLECTOR — reclaims memory from unreachable objects
System.gc(); // suggest GC (can't force it)
System.out.println("GC: " +
java.lang.management.ManagementFactory.getGarbageCollectorMXBeans());
}
// This method will be JIT-compiled after enough calls
private static int computeValue(int x) {
return x * 2 + 1;
}
}
Output
Sum: 100000000000000 Time: 23 ms (JIT made this faster than pure interpretation)
JRE (Java Runtime Environment)
The JRE is everything needed to RUN Java programs (but not develop them):
What's Inside the JRE
JRE/
├── bin/
│ ├── java ← Program launcher
│ ├── javaw ← Launcher without console (Windows)
│ └── keytool ← Security certificate tool
├── lib/
│ ├── modules ← Core library modules (Java 9+)
│ ├── security/ ← Security configuration
│ └── ... ← Configuration files
├── conf/
│ ├── security/ ← Security policies
│ └── logging.properties
└── legal/ ← License files
JRE Components
| Component | Purpose |
|---|---|
| JVM | Executes bytecode |
| Core Libraries | java.lang, java.util, java.io, etc. |
| java launcher | The java command to run programs |
| Configuration | security, networking, logging settings |
| Native libraries | Platform-specific implementations |
java example
// JRE provides all the standard libraries:
import java.util.*; // Collections, Date, etc.
import java.io.*; // File I/O
import java.net.*; // Networking
import java.math.*; // BigDecimal, BigInteger
import java.time.*; // Date/Time API
public class JRELibrariesDemo {
public static void main(String[] args) {
// All these work because JRE includes the standard library:
// Collections
List<String> list = new ArrayList<>(List.of("A", "B", "C"));
System.out.println("List: " + list);
// Date/Time
LocalDateTime now = LocalDateTime.now();
System.out.println("Now: " + now);
// Math
BigDecimal price = new BigDecimal("19.99");
BigDecimal tax = price.multiply(new BigDecimal("0.08"));
System.out.println("Tax: $" + tax);
// System info (from JRE)
System.out.println("Java Home: " + System.getProperty("java.home"));
}
}Output
List: [A, B, C] Now: 2024-01-15T14:30:00.123456 Tax: $1.5992 Java Home: /usr/lib/jvm/java-21-openjdk/
Note: Since Java 9's module system, a standalone JRE is no longer distributed separately. The JDK contains everything, and you can create custom runtime images with jlink.
JDK (Java Development Kit)
The JDK is the complete development environment — it includes the JRE plus development tools.
What's Inside the JDK (that's NOT in JRE)
JDK/ (everything in JRE plus:)
├── bin/
│ ├── javac ← Java Compiler
│ ├── jdb ← Java Debugger
│ ├── javadoc ← Documentation generator
│ ├── jar ← Archive tool
│ ├── jshell ← Interactive REPL (Java 9+)
│ ├── jlink ← Custom runtime image creator
│ ├── jpackage ← Native installer creator (Java 14+)
│ ├── jconsole ← JVM monitoring GUI
│ ├── jvisualvm ← Visual profiling tool
│ ├── jmap ← Memory mapping
│ ├── jstack ← Thread stack dump
│ ├── jstat ← JVM statistics
│ ├── javap ← Class file disassembler
│ └── ... ← Many more tools
├── include/
│ └── jni.h ← JNI headers (for native code)
└── lib/
└── src.zip ← Source code of standard library
Using JDK Tools
java example
// 1. javac — Compile source to bytecode
// $ javac HelloWorld.java
// → produces HelloWorld.class
// 2. java — Run the bytecode
// $ java HelloWorld
// → JVM executes the bytecode
// 3. javap — Disassemble class files (see bytecode!)
// $ javap -c HelloWorld.class
public class JDKToolsDemo {
public static void main(String[] args) {
System.out.println("Compile me with: javac JDKToolsDemo.java");
System.out.println("Run me with: java JDKToolsDemo");
System.out.println("Disassemble with: javap -c JDKToolsDemo.class");
System.out.println("Debug with: jdb JDKToolsDemo");
System.out.println("Monitor with: jconsole");
}
}Output
Compile me with: javac JDKToolsDemo.java Run me with: java JDKToolsDemo Disassemble with: javap -c JDKToolsDemo.class Debug with: jdb JDKToolsDemo Monitor with: jconsole
Seeing Bytecode with javap
java example
public class BytecodeDemo {
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = add(3, 4);
System.out.println(result);
}
}
// Compile: javac BytecodeDemo.java
// Disassemble: javap -c BytecodeDemo.class
// Output shows actual bytecode:Output
// javap -c BytecodeDemo.class output:
public static int add(int, int);
Code:
0: iload_0 // push first argument onto stack
1: iload_1 // push second argument onto stack
2: iadd // pop both, add them, push result
3: ireturn // return the int on top of stack
public static void main(java.lang.String[]);
Code:
0: iconst_3 // push constant 3
1: iconst_4 // push constant 4
2: invokestatic #2 // call add(int, int)
5: istore_1 // store result in local variable 1
6: getstatic #3 // get System.out
9: iload_1 // load the result
10: invokevirtual #4 // call println(int)
13: returnComparison Table
| Feature | JVM | JRE | JDK |
|---|---|---|---|
| Executes bytecode | ✅ | ✅ | ✅ |
| Standard libraries | ❌ | ✅ | ✅ |
Java launcher (java) | ❌ | ✅ | ✅ |
Java compiler (javac) | ❌ | ❌ | ✅ |
Debugger (jdb) | ❌ | ❌ | ✅ |
| javadoc | ❌ | ❌ | ✅ |
| jshell (REPL) | ❌ | ❌ | ✅ |
| Monitoring tools | ❌ | ❌ | ✅ |
| Who needs it? | Part of JRE | End users | Developers |
| Purpose | Execute | Run programs | Develop + Run |
JDK Distributions
Multiple vendors provide JDK implementations:
| Distribution | Vendor | License | Best For |
|---|---|---|---|
| Oracle JDK | Oracle | Commercial (free for dev) | Enterprise with support |
| OpenJDK | Oracle/Community | Open source (GPL v2) | Reference implementation |
| Amazon Corretto | Amazon | Free, open source | AWS deployments |
| Eclipse Temurin | Adoptium | Free, open source | General purpose |
| Azul Zulu | Azul Systems | Free + paid support | Enterprise |
| GraalVM | Oracle | Dual license | Polyglot, native compilation |
| Microsoft Build | Microsoft | Free, open source | Azure deployments |
java example
public class DistributionCheck {
public static void main(String[] args) {
// Check which distribution you're running:
System.out.println("Implementation: " +
System.getProperty("java.runtime.name"));
System.out.println("Version: " +
System.getProperty("java.runtime.version"));
System.out.println("Vendor: " +
System.getProperty("java.vendor"));
System.out.println("VM: " +
System.getProperty("java.vm.name"));
}
}Output
Implementation: OpenJDK Runtime Environment Version: 21.0.1+12-29 Vendor: Eclipse Adoptium VM: OpenJDK 64-Bit Server VM
JVM Languages
The JVM doesn't only run Java — any language that compiles to bytecode can run on it:
| Language | Paradigm | Use Case |
|---|---|---|
| Java | OOP, Functional | Enterprise, Android |
| Kotlin | OOP, Functional | Android (preferred), Backend |
| Scala | OOP, Functional | Big Data (Spark), Backend |
| Groovy | OOP, Scripting | Gradle build scripts, testing |
| Clojure | Functional, Lisp | Data processing |
| JRuby | OOP, Scripting | Ruby on JVM |
| Jython | OOP, Scripting | Python on JVM |
Common Mistakes
- Thinking you need both JDK and JRE installed — JDK already includes the JRE. You only need the JDK for development.
- Confusing JVM specification with implementation — "JVM" is a specification (a document). HotSpot, GraalVM, OpenJ9 are implementations of that specification.
- Thinking all JVMs are the same — Different implementations (HotSpot vs GraalVM vs OpenJ9) have different performance characteristics and features.
- Not understanding JIT compilation — The JVM starts by interpreting bytecode (fast startup) and then JIT-compiles hot code to native code (fast execution). This means Java programs get faster over time.
- Assuming JRE still exists as separate download — Since Java 11, Oracle no longer ships a standalone JRE. You either use the full JDK or create a custom runtime with
jlink. - Mixing up ClassLoaders — Bootstrap loads java.lang.*, Platform loads extension libraries, Application loads your code. Understanding delegation prevents ClassNotFoundException.
Best Practices
- Always install the JDK (not just JRE) — even for testing, you'll want tools like
javapandjshell - Use a mainstream distribution — Eclipse Temurin (Adoptium) or Amazon Corretto for free, production-ready JDKs
- Match JDK versions across development and production environments
- Use
jlinkto create minimal custom runtimes for deployment (reduces image size) - Monitor JVM with
jconsoleorjvisualvmto understand memory and thread behavior
Interview Questions
Q1: What is the difference between JDK, JRE, and JVM?
Answer: JVM (Java Virtual Machine) is the abstract machine that executes bytecode — it handles class loading, memory management, and execution. JRE (Java Runtime Environment) includes the JVM plus the standard libraries needed to run Java programs. JDK (Java Development Kit) includes the JRE plus development tools (compiler javac, debugger jdb, documentation tool javadoc, etc.) needed to write and compile Java programs.
Q2: Can Java run without JVM?
Answer: Traditional Java requires a JVM. However, GraalVM Native Image can compile Java directly to native executables (ahead-of-time compilation), eliminating the JVM at runtime. Also, some embedded Java implementations use alternative execution models. But standard Java programs require a JVM.
Q3: What are the main components of JVM architecture?
Answer: The JVM has three main subsystems: (1) Class Loader — loads, verifies, and prepares classes; (2) Runtime Memory Areas — Method Area (class data), Heap (objects), Stack (local variables/method calls), PC Register, Native Method Stack; (3) Execution Engine — Interpreter (line-by-line), JIT Compiler (hot code to native), Garbage Collector (memory reclamation).
Q4: What is JIT compilation?
Answer: JIT (Just-In-Time) compilation is the process where the JVM identifies "hot" methods (frequently called) and compiles their bytecode into native machine code at runtime. This eliminates the overhead of interpretation for hot code paths, allowing Java to achieve performance comparable to natively compiled languages. The JIT compiler also performs optimizations like inlining, loop unrolling, and escape analysis.
Q5: Why are there different JDK distributions? Which should I use?
Answer: Different vendors provide JDK distributions with varying licensing, support, and optimizations. Oracle JDK has commercial licensing for production. Eclipse Temurin (Adoptium) is the community-recommended free distribution. Amazon Corretto is optimized for AWS. GraalVM adds polyglot support and native compilation. For most developers, Eclipse Temurin or Amazon Corretto is the best free choice.
Summary
The JDK is what you install as a developer — it contains everything (compiler, debugger, JRE, JVM). The JRE is what end users need to run Java programs (JVM + libraries). The JVM is the engine that executes bytecode through class loading, memory management, and the execution engine (interpreter + JIT). Understanding this hierarchy clarifies how Java achieves platform independence and helps you make informed decisions about JDK distributions and deployment strategies.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for JDK, JRE, and JVM.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, fundamentals, introduction, jdk
Related Java Master Course Topics
Continue learning this concept
FundamentalsArray IntroductionComplete introduction to arrays in Java covering definition, memory layout, types of arrays, declaration, initialization, accessing elements, and real-world use cases with detailed examples.FundamentalsJava Compilation ProcessStep-by-step explanation of how Java source code becomes executable — from writing .java files through javac compilation, bytecode generation, class loading, verification, and JVM execution.FundamentalsFeatures of JavaA deep dive into all key features of Java programming language — platform independence, object-oriented nature, robustness, security, multithreading, and more with practical examples.FundamentalsYour First Java ProgramWrite, compile, and run your first Java program — a detailed walkthrough of Hello World, explaining every line, common errors beginners face, and how to progress beyond the basics.FundamentalsHistory of JavaThe complete history of Java programming language — from the Green Project at Sun Microsystems in 1991 to modern Java 21+ LTS releases, covering every major version and milestone.FundamentalsJava EditionsComplete guide to Java editions — Java SE, Java EE (Jakarta EE), Java ME, and JavaFX. Understand which edition to use for desktop, web, enterprise, mobile, and embedded development.