Java Interview Notes - From Scratch to
Advanced (Detailed)
1. Introduction to Java
Java is a high-level, class-based, object-oriented programming language designed to
have as few implementation dependencies as possible.
Developed by James Gosling at Sun Microsystems in 1995, now owned by Oracle.
Key Features: Platform Independent (via JVM), Secure, Robust, Portable, High
Performance (JIT Compiler), Multithreaded, Distributed.
JVM (Java Virtual Machine) executes bytecode, JRE (Java Runtime Environment)
provides libraries, JDK (Java Development Kit) contains JRE + development tools.
Java Editions: Java SE (Standard Edition), Java EE (Enterprise Edition), Java ME (Micro
Edition).
Automatic memory management with Garbage Collection.
2. Java Basics
Primitive Data Types: byte (8-bit), short (16-bit), int (32-bit), long (64-bit), float (32-
bit), double (64-bit), char (16-bit Unicode), boolean (true/false).
Non-Primitive: String, Arrays, Classes, Interfaces.
Variable Types: Local (inside methods), Instance (object level), Static (class level).
Operators: Arithmetic (+, -, *, /, %), Relational (==, !=, >, <, >=, <=), Logical (&&, ||, !),
Bitwise (&, |, ^, ~, <<, >>, >>>), Assignment (=, +=, -=), Ternary (? :).
Type Casting: Implicit (widening), Explicit (narrowing).
Control Statements: if-else, switch-case (supports String, enum, int), loops (for, while,
do-while), break, continue.
3. OOP Concepts
Encapsulation: Wrapping data (variables) and code (methods) together into a single
unit, restricting direct access using access modifiers.
Inheritance: Reuse fields and methods from parent class (extends). Types: Single,
Multilevel, Hierarchical. Interfaces allow multiple inheritance.
Polymorphism: Method Overloading (compile-time), Method Overriding (runtime,
requires inheritance).
Abstraction: Hiding implementation details and showing only functionality. Achieved
using Abstract Classes and Interfaces.
Constructors: Automatically called when object is created. Types: Default,
Parameterized, Copy. Cannot be abstract, static, final.
Access Modifiers: public, private, protected, default (package-private).
4. Strings in Depth
Immutable: Any modification creates a new String object.
String Pool: Special memory region in heap to store string literals for reuse.
String Methods: length(), charAt(), substring(), contains(), equals(), equalsIgnoreCase(),
compareTo(), split(), replace(), trim().
StringBuilder: Mutable, faster (not thread-safe). StringBuffer: Mutable, thread-safe.
Important Interview Points: String immutability benefits (security, synchronization,
caching).
5. Arrays
Fixed-size, homogeneous collection of elements.
Declaration: int[] arr = new int[5]; Initialization: arr[0] = 1;
Multi-dimensional arrays: int[][] matrix = new int[3][3];
Methods from java.util.Arrays: sort(), binarySearch(), equals(), copyOf(), fill().
Enhanced for loop for traversal: for(int num : arr) { ... }
6. Collections Framework
Interfaces: Collection, List, Set, Queue, Map.
List Implementations: ArrayList (dynamic array, fast random access), LinkedList
(doubly linked, faster insertion/deletion), Vector (synchronized), Stack.
Set Implementations: HashSet (no duplicates, no order), LinkedHashSet (insertion
order), TreeSet (sorted, uses Red-Black Tree).
Map Implementations: HashMap (no order), LinkedHashMap (insertion order),
TreeMap (sorted keys), Hashtable (synchronized).
Queue Implementations: PriorityQueue, LinkedList, ArrayDeque.
Utility class Collections: sort(), reverse(), shuffle(), binarySearch(), max(), min().
Iterator and ListIterator for traversing collections.
7. Exception Handling
Purpose: To handle runtime errors and maintain normal program flow.
Checked Exceptions: Must be handled (IOException, SQLException).
Unchecked Exceptions: Runtime (NullPointerException, ArithmeticException).
Keywords: try, catch, finally, throw, throws.
Custom Exceptions: Extend Exception or RuntimeException.
Best Practices: Catch specific exceptions, use finally for resource cleanup.
8. Multithreading & Concurrency
Thread creation: Extend Thread class or implement Runnable interface.
Thread Lifecycle: New, Runnable, Running, Waiting, Terminated.
Synchronization: synchronized keyword, locks, to prevent race conditions.
volatile keyword: Ensures visibility of changes across threads.
Executor Framework: Thread pools for efficient thread management.
Concurrency utilities: CountDownLatch, CyclicBarrier, Semaphore,
ConcurrentHashMap.
9. Java Memory Management
Stack Memory: Stores method calls, local variables.
Heap Memory: Stores objects and class metadata.
Garbage Collection: Automatically removes unused objects. Algorithms: Serial, Parallel,
G1.
Memory Leaks: Caused by unused references.
10. Java 8+ Features
Lambda Expressions: (parameters) -> expression.
Functional Interfaces: Interface with single abstract method (Runnable, Callable,
Comparator).
Streams API: filter(), map(), reduce(), collect().
Default & Static Methods in Interfaces.
Optional class: Avoid null pointer exceptions.
Method References: ClassName::methodName.
11. File Handling & I/O
File class: file.createNewFile(), file.exists(), file.delete().
Reading: FileReader, BufferedReader, Scanner.
Writing: FileWriter, BufferedWriter, PrintWriter.
Serialization: ObjectOutputStream, ObjectInputStream.
Java NIO: Paths, Files, Channels, Buffers.
12. Important Keywords & Concepts
static, final, this, super, transient, volatile, synchronized.
break, continue, return, instanceof, assert.
Enums: Special classes for constants.
Wrapper Classes: Integer, Double, Boolean, etc. Autoboxing & Unboxing.
13. Design Patterns in Java
Singleton: One instance throughout application.
Factory: Creates objects without exposing creation logic.
Builder: Step-by-step object construction.
Observer: One-to-many dependency.
Strategy: Define a family of algorithms.
14. Common Interview Programs
Reverse String, Check Palindrome.
Fibonacci sequence (iterative & recursive).
Prime number check.
Factorial calculation.
Sorting: Bubble, Selection, Insertion, Merge, Quick.
Anagrams, String permutations.
Collections sorting using Comparator and Comparable.
