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
Step-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.
Java has a unique two-stage compilation process that sets it apart from both purely compiled languages (C/C++) and purely interpreted languages (Python/JavaScript). This process is the key to Java's "Write Once, Run Anywhere" promise.
Overview: From Source to Execution
| .java | ───────────→ | .class | ───────────→ | Output |
|---|---|---|---|---|
| Source | (compile) | Bytecode | (execute) | Result |
Let's trace this entire journey with a real example:
java example
// File: Greeting.java
public class Greeting {
private String name;
public Greeting(String name) {
this.name = name;
}
public String getMessage() {
return "Hello, " + name + "! Welcome to Java.";
}
public static void main(String[] args) {
Greeting g = new Greeting("Developer");
System.out.println(g.getMessage());
}
}Output
Hello, Developer! Welcome to Java.
Stage 1: Writing Source Code (.java)
The process begins with a .java source file:
- Written in human-readable text
- Must follow Java syntax rules
- Filename must match the public class name
- Uses Unicode encoding (supports any language in comments/strings)
Example
// File MUST be named: MathUtils.java (matches public class)
public class MathUtils {
public static int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
public static boolean isPrime(int n) {
if (n < 2) return false;
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
public static void main(String[] args) {
System.out.println("5! = " + factorial(5));
System.out.println("17 is prime: " + isPrime(17));
System.out.println("15 is prime: " + isPrime(15));
}
}
Stage 2: Compilation (javac)
The javac compiler transforms source code into bytecode:
Example
$ javac MathUtils.java
What javac Does Internally
The compiler performs multiple phases:
| Phase | What Happens |
|---|---|
| 1. Lexical Analysis | Breaks code into tokens (keywords, identifiers, operators) |
| 2. Parsing | Builds an Abstract Syntax Tree (AST) |
| 3. Semantic Analysis | Type checking, name resolution, access control |
| 4. Code Generation | Generates bytecode instructions |
| 5. Output | Writes .class file |
Compilation Errors
The compiler catches errors at this stage:
java example
public class CompileErrors {
public static void main(String[] args) {
// ERROR 1: Type mismatch
// int x = "hello"; // incompatible types: String cannot be converted to int
// ERROR 2: Undeclared variable
// System.out.println(y); // cannot find symbol: variable y
// ERROR 3: Missing semicolon
// int a = 5 // ';' expected
// ERROR 4: Access violation
// String.value; // value has private access in String
// ERROR 5: Checked exception not handled
// FileReader fr = new FileReader("test.txt");
// unreported exception FileNotFoundException
System.out.println("All errors are caught at compile time!");
}
}Compiler Options
Example
# Basic compilation
javac MyClass.java
# Specify output directory
javac -d out/ MyClass.java
# Include classpath dependencies
javac -cp lib/gson.jar MyClass.java
# Enable all warnings
javac -Xlint:all MyClass.java
# Target specific Java version
javac --release 11 MyClass.java
# Compile multiple files
javac -d out/ src/*.java
# Verbose output (see what compiler is doing)
javac -verbose MyClass.java
Stage 3: Bytecode (.class file)
The output of compilation is a .class file containing bytecode — an intermediate representation that's neither source code nor machine code.
Understanding Bytecode
java example
// Simple class to examine bytecode:
public class BytecodeExample {
public static int add(int a, int b) {
int sum = a + b;
return sum;
}
}Output
// Use: javap -c BytecodeExample.class to see bytecode:
public static int add(int, int);
Code:
0: iload_0 // Load first parameter (a) onto operand stack
1: iload_1 // Load second parameter (b) onto operand stack
2: iadd // Pop both values, add them, push result
3: istore_2 // Store result in local variable 2 (sum)
4: iload_2 // Load sum back onto stack
5: ireturn // Return int value from stackClass File Structure
Every .class file has this structure:
┌────────────────────────────────────┐
│ Magic Number: 0xCAFEBABE │ ← Identifies as Java class file
│ Minor Version │
│ Major Version │ ← Java version target
├────────────────────────────────────┤
│ Constant Pool │ ← Literals, class/method references
├────────────────────────────────────┤
│ Access Flags │ ← public, final, abstract, etc.
│ This Class reference │
│ Super Class reference │
├────────────────────────────────────┤
│ Interfaces │ ← Implemented interfaces
├────────────────────────────────────┤
│ Fields │ ← Field definitions
├────────────────────────────────────┤
│ Methods │ ← Method definitions + bytecode
├────────────────────────────────────┤
│ Attributes │ ← Source file, annotations, etc.
└────────────────────────────────────┘
java example
public class ClassFileDemo {
public static void main(String[] args) {
// Verify the magic number and version
System.out.println("Class file starts with: 0xCAFEBABE");
// The class file format version
// Java 8 = 52, Java 11 = 55, Java 17 = 61, Java 21 = 65
String version = System.getProperty("java.class.version");
System.out.println("Class file version: " + version);
System.out.println("Java version: " + System.getProperty("java.version"));
}
}Output
Class file starts with: 0xCAFEBABE Class file version: 65.0 Java version: 21.0.1
Why Bytecode (Not Native Code)?
| Approach | Advantage | Disadvantage |
|---|---|---|
| Compile to native (C/C++) | Maximum speed | Platform-specific, recompile for each OS |
| Interpret source (Python) | Cross-platform | Slow execution |
| Bytecode (Java) | Cross-platform + near-native speed | Needs JVM, startup overhead |
Stage 4: Class Loading
When you run java MathUtils, the JVM's Class Loader finds and loads the class:
java example
public class ClassLoadingDemo {
// Static initializer — runs when class is loaded
static {
System.out.println("1. ClassLoadingDemo class loaded!");
}
public static void main(String[] args) {
System.out.println("2. Main method executing");
// Force loading of another class
System.out.println("3. About to use Helper class...");
Helper.doSomething(); // Helper class loaded NOW (lazy loading)
}
}
class Helper {
static {
System.out.println(" -> Helper class loaded!");
}
static void doSomething() {
System.out.println("4. Helper doing something");
}
}Output
1. ClassLoadingDemo class loaded! 2. Main method executing 3. About to use Helper class... -> Helper class loaded! 4. Helper doing something
Key insight: Classes are loaded lazily — only when first referenced!
Stage 5: Bytecode Verification
Before execution, the JVM verifies the bytecode is safe:
java example
public class VerificationDemo {
public static void main(String[] args) {
// The verifier checks:
System.out.println("Bytecode verification ensures:");
System.out.println("✓ Stack doesn't overflow or underflow");
System.out.println("✓ All local variable accesses are valid");
System.out.println("✓ Types are correct for all operations");
System.out.println("✓ Method calls match signatures");
System.out.println("✓ Object fields are accessed legally");
System.out.println("✓ Return types match method declarations");
System.out.println("✓ No illegal type casts");
// This is WHY Java is secure — malicious bytecode is rejected
// before it can execute
}
}Output
Bytecode verification ensures: ✓ Stack doesn't overflow or underflow ✓ All local variable accesses are valid ✓ Types are correct for all operations ✓ Method calls match signatures ✓ Object fields are accessed legally ✓ Return types match method declarations ✓ No illegal type casts
Stage 6: Execution (Interpreter + JIT)
The JVM executes bytecode using a combination of interpretation and JIT compilation:
Example
public class ExecutionDemo {
public static void main(String[] args) {
// Phase 1: Interpreted (first few calls)
// The JVM interprets bytecode instruction by instruction
// This is slower but has zero compilation overhead
// Phase 2: JIT Compiled (after threshold reached)
// Once a method is called enough times (~10,000 by default),
// the JIT compiler converts it to native machine code
// Demonstrate the "warmup" effect:
System.out.println("=== Cold Start (Interpreted) ===");
long start1 = System.nanoTime();
for (int i = 0; i < 1000; i++) {
compute(i);
}
System.out.println("Time: " + (System.nanoTime() - start1) / 1000 + " μs");
System.out.println("\n=== After Warmup (JIT Compiled) ===");
// Run many times to trigger JIT
for (int i = 0; i < 100_000; i++) {
compute(i);
}
long start2 = System.nanoTime();
for (int i = 0; i < 1000; i++) {
compute(i);
}
System.out.println("Time: " + (System.nanoTime() - start2) / 1000 + " μs");
System.out.println("(Much faster after JIT compilation!)");
}
private static long compute(int x) {
long result = 0;
for (int i = 0; i < 100; i++) {
result += x * i;
}
return result;
}
}
Output
=== Cold Start (Interpreted) === Time: 1250 μs === After Warmup (JIT Compiled) === Time: 45 μs (Much faster after JIT compilation!)
JIT Compilation Tiers
Modern HotSpot JVM uses tiered compilation:
| Tier | Level | Description |
|---|---|---|
| Tier 0 | Interpreter | Line-by-line execution, profiling |
| Tier 1 | C1 (Client) | Quick compilation, basic optimizations |
| Tier 2 | C1 + profiling | With invocation counters |
| Tier 3 | C1 + full profiling | Detailed profiling data |
| Tier 4 | C2 (Server) | Aggressive optimization, maximum speed |
JIT Optimizations
Example
public class JITOptimizations {
public static void main(String[] args) {
// The JIT performs these optimizations:
// 1. METHOD INLINING — small methods are inserted at call site
int result = add(3, 4); // JIT replaces this with: int result = 3 + 4;
// 2. LOOP UNROLLING — reduces loop overhead
// for(i=0; i<4; i++) sum += arr[i];
// becomes: sum = arr[0] + arr[1] + arr[2] + arr[3];
// 3. DEAD CODE ELIMINATION — removes unreachable code
boolean debug = false;
if (debug) {
System.out.println("This is removed by JIT");
}
// 4. ESCAPE ANALYSIS — avoids heap allocation for local objects
Point p = new Point(1, 2); // JIT may allocate on stack instead of heap
int sum = p.x + p.y;
// 5. NULL CHECK ELIMINATION — removes proven-safe null checks
// 6. BOUNDS CHECK ELIMINATION — removes proven-safe array bounds checks
System.out.println("Result: " + result);
System.out.println("Sum: " + sum);
}
static int add(int a, int b) { return a + b; }
}
class Point { int x, y; Point(int x, int y) { this.x = x; this.y = y; } }
Output
Result: 7 Sum: 3
Complete Compilation-to-Execution Flowchart
| Developer writes | Calculator.java |
| │ javac │ Phase 1 | COMPILATION |
| ▼ Creates | Calculator.class (bytecode) |
| │ java │ Phase 2 | EXECUTION |
| │ 1. Class Load │ | Find and load .class |
| │ 2. Verify │ | Check bytecode safety |
| │ 3. Prepare │ | Allocate static memory |
| │ 4. Resolve │ | Link references |
| │ 5. Initialize │ | Run static blocks |
| │ 6. Execute │ | Interpret/JIT main() |
Comparing with Other Languages
Example
public class ComparisonDemo {
public static void main(String[] args) {
System.out.println("=== Compilation Approaches ===");
System.out.println();
System.out.println("C/C++ (AOT Compiled):");
System.out.println(" source.c → gcc → native binary (platform-specific)");
System.out.println(" + Fastest execution");
System.out.println(" - Recompile for each platform");
System.out.println();
System.out.println("Python (Interpreted):");
System.out.println(" script.py → python interpreter → execution");
System.out.println(" + No compilation step, cross-platform");
System.out.println(" - Slowest execution");
System.out.println();
System.out.println("Java (Hybrid: AOT + JIT):");
System.out.println(" Source.java → javac → bytecode → JVM (JIT) → native");
System.out.println(" + Cross-platform + near-native speed");
System.out.println(" - Startup overhead, memory usage");
}
}
Output
=== Compilation Approaches === C/C++ (AOT Compiled): source.c → gcc → native binary (platform-specific) + Fastest execution - Recompile for each platform Python (Interpreted): script.py → python interpreter → execution + No compilation step, cross-platform - Slowest execution Java (Hybrid: AOT + JIT): Source.java → javac → bytecode → JVM (JIT) → native + Cross-platform + near-native speed - Startup overhead, memory usage
Single-File Execution (Java 11+)
Starting with Java 11, you can skip explicit compilation for single-file programs:
java example
// Direct execution (Java 11+):
// $ java HelloDirect.java
// (javac runs internally, class file is not saved to disk)
public class HelloDirect {
public static void main(String[] args) {
System.out.println("No separate compilation needed!");
System.out.println("Java 11+ compiles and runs in one step");
System.out.println("Great for scripts and quick testing");
}
}Output
// Run directly: java HelloDirect.java No separate compilation needed! Java 11+ compiles and runs in one step Great for scripts and quick testing
Common Mistakes
- Thinking .java files run directly — Java source code MUST be compiled to bytecode first (either explicitly with
javacor implicitly withjavafor single files in Java 11+). - Confusing compiler errors with runtime errors — Compiler errors (syntax, types) prevent
.classfile generation. Runtime errors (NullPointerException, ArrayIndexOutOfBounds) happen during execution. - Not understanding that bytecode ≠ machine code — Bytecode is a platform-independent intermediate format. It's NOT executable by the CPU directly — the JVM must interpret or JIT-compile it.
- Thinking compilation happens once — There are TWO compilations:
javaccompiles source to bytecode (ahead-of-time), and JIT compiles bytecode to native code (at runtime). - Ignoring the classpath — When your code uses external libraries, the compiler AND the JVM need to know where to find them (
-cporCLASSPATH). - Forgetting class names are case-sensitive —
java Myclasswon't findMyClass.class. The case must match exactly.
Best Practices
- Use an IDE — Modern IDEs (IntelliJ, Eclipse) compile continuously as you type, showing errors instantly
- Understand compilation errors — Read the FIRST error carefully; later errors often cascade from it
- Use
-Xlint:all— Enable all compiler warnings to catch potential issues early - Target the right Java version — Use
--releaseflag to ensure compatibility with production JVM - Profile JIT behavior — Use
-XX:+PrintCompilationto see what the JIT compiler is doing
Interview Questions
Q1: Explain the Java compilation and execution process step by step.
Answer: (1) Developer writes .java source file. (2) javac compiler performs lexical analysis, parsing, type checking, and generates .class bytecode. (3) JVM's ClassLoader loads the .class file. (4) Bytecode Verifier checks the bytecode for safety and correctness. (5) Execution Engine interprets the bytecode or JIT-compiles hot code paths to native machine code for faster execution.
Q2: What is the difference between compiler errors and runtime errors?
Answer: Compiler errors are detected by javac during compilation — they prevent the .class file from being generated (syntax errors, type mismatches, missing imports). Runtime errors occur during program execution — the code is valid syntactically but encounters problems at runtime (NullPointerException, division by zero, ArrayIndexOutOfBoundsException).
Q3: What is bytecode and why is it important?
Answer: Bytecode is a platform-independent intermediate instruction set stored in .class files. It's important because it enables Java's "Write Once, Run Anywhere" — the same bytecode runs on any platform with a JVM. It's more compact than source code and faster to interpret than source, but still portable because it doesn't contain platform-specific instructions.
Q4: What is the role of JIT compiler in Java?
Answer: The JIT (Just-In-Time) compiler identifies "hot" methods (frequently executed code) and compiles their bytecode into optimized native machine code at runtime. This combines the portability of bytecode with near-native execution speed. JIT also performs advanced optimizations like method inlining, loop unrolling, dead code elimination, and escape analysis that aren't possible with ahead-of-time compilation.
Q5: Can Java code be compiled to native executables?
Answer: Yes, using GraalVM Native Image, Java code can be compiled ahead-of-time (AOT) into platform-specific native executables. This eliminates the JVM, provides instant startup time, and reduces memory usage. However, it has limitations (no runtime class loading, limited reflection). Standard Java still uses the JVM approach for maximum flexibility.
Summary
Java's compilation process is a carefully designed two-stage pipeline: javac compiles human-readable source code into platform-independent bytecode, and the JVM's execution engine (interpreter + JIT compiler) converts that bytecode into highly optimized native machine code at runtime. This hybrid approach gives Java both platform independence and high performance — the best of both compiled and interpreted worlds.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Java Compilation Process.
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, compilation
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.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.FundamentalsJava Program StructureComplete guide to Java program structure — package declarations, import statements, class definitions, methods, main method anatomy, and the rules for organizing Java source files.