Click any module to expand. Covers Java 8 (lambdas, streams), Java 11 (var, HTTP client), Java 14+ (records, pattern matching), and Java 17/21 (sealed classes, virtual threads). Not just legacy Java — modern Java as used in industry today.
JVM architecture, memory model, data types, operators, and writing your first Java program
What each component does: JDK (development kit), JRE (runtime), JVM (virtual machine). Class loading, bytecode verification, and JIT compilation. Why "Write Once, Run Anywhere" works — and where it doesn't.
Where objects live (heap), where local variables live (stack), where class metadata lives (method area). String pool in the heap. Understanding OutOfMemoryError and StackOverflowError — the interview favourites.
How Java automatically reclaims memory. Generational GC (Young, Old, Permanent/Metaspace). When objects become eligible for GC. System.gc() — why calling it is almost always wrong. finalize() deprecation.
8 primitive types (byte, short, int, long, float, double, char, boolean) — sizes and ranges. Implicit widening vs explicit narrowing. var keyword (Java 10) for local type inference. Literal formats (binary, hex, underscores).
Arithmetic, relational, logical, bitwise, ternary, instanceof. Operator precedence table. Short-circuit evaluation (&&, ||). Bitwise operations: AND, OR, XOR, shifts — tested in MCQs.
Integer, Double, Character, Boolean — converting primitives to objects. Autoboxing/unboxing (Java 5). Integer cache (-128 to 127) — the classic "==" vs .equals() trap. parseXxx() and valueOf() methods.
if/else, switch (traditional + switch expressions in Java 14), for, while, do-while. Enhanced for-each loop. Labelled break and continue for nested loops.
Working with collections of data and text manipulation — the most tested data types
Array declaration, initialisation, bounds checking (ArrayIndexOutOfBoundsException). 2D arrays for matrix operations. Jagged arrays (rows of different lengths). Arrays.sort(), Arrays.binarySearch(), Arrays.copyOf().
Why Java strings are immutable. How the string pool works. "Hello" == "Hello" vs new String("Hello") == new String("Hello") — the classic interview question. Memory implications of string concatenation in loops.
length(), charAt(), substring(), indexOf(), contains(), replace(), split(), trim(), strip() (Java 11), equals() vs ==. Regular expressions basics with Pattern and Matcher.
Mutable string alternatives for performance. StringBuilder (not thread-safe, faster) vs StringBuffer (thread-safe, slower). When to use each — string concatenation in loops MUST use StringBuilder.
Enum declaration, enum with fields/methods/constructors. Enum in switch statements. EnumSet and EnumMap. Why enums are preferred over static final constants — type safety and readability.
Math.pow(), Math.sqrt(), Math.random(), Math.max/min. Scanner for console input (nextInt(), nextLine() — the buffer pitfall). Formatting output with System.out.printf() and String.format().
Classes, objects, constructors, encapsulation, this/super, and static members
Class definition, instance variables, methods. Object creation with new. Stack vs heap allocation of objects. Reference variables vs objects — "the variable is not the object."
Constructor chaining with this(). No-arg constructor auto-generation rules. Copy constructors (Java doesn't have them built-in — how to implement). Constructor overloading.
this — refers to current object. this() — calls another constructor. super — refers to parent class. super() — calls parent constructor. Why super() must be the first statement. Interview favourite.
private, default (package-private), protected, public — scope rules across classes and packages. Getter/setter pattern. Why encapsulation matters for maintainability. Immutable class design.
Class-level vs instance-level. Static methods (can't access instance members). Static blocks for initialisation. Static import. The singleton pattern using static. Why main() is static.
final variable = constant. final method = can't override. final class = can't extend. final vs immutability (final reference ≠ immutable object). Blank final variables and initialisation.
Every class extends Object. toString(), equals(), hashCode() — the contract between equals and hashCode. clone() — shallow vs deep copy. getClass(), instanceof operator. Why you must override equals AND hashCode together.
Code reuse, method dispatch, interfaces, and designing extensible class hierarchies
Single inheritance (Java doesn't support multiple class inheritance). Constructor chaining in inheritance. Method hiding (static methods). Protected access across packages. When to use inheritance vs composition.
Rules for valid overriding: same signature, covariant return types, access can't be more restrictive, can't throw broader checked exceptions. @Override annotation — why you should ALWAYS use it.
Upcasting: automatic (Dog → Animal). Downcasting: explicit and dangerous (ClassCastException). instanceof check before downcasting. Pattern matching instanceof (Java 16): if (obj instanceof String s).
Compile-time: method overloading. Runtime: method overriding + dynamic method dispatch. Which method gets called when a parent reference holds a child object? The most asked OOP question.
abstract keyword on classes and methods. Can't instantiate abstract classes. Abstract vs concrete methods. When to use abstract classes vs interfaces. Template method pattern.
Interfaces as contracts. Multiple interface implementation (Java's answer to multiple inheritance). Default methods (Java 8) — why they were added. Static methods in interfaces. Private methods (Java 9). Functional interfaces.
sealed classes — restricting which classes can extend. permits clause. Records — immutable data carriers with auto-generated equals, hashCode, toString. record Point(int x, int y) {} — one line replaces 50.
Writing robust code that handles errors gracefullyn
Throwable → Error (JVM-level, unrecoverable) and Exception (application-level). RuntimeException (unchecked) vs checked exceptions. Common exceptions: NullPointerException, ArrayIndexOutOfBounds, ClassCastException, IOException.
Basic try-catch. Multi-catch (Java 7): catch(IOException | SQLException e). finally block — guaranteed execution (almost). try-with-resources (Java 7): AutoCloseable interface for automatic cleanup. Why finally beats return.
throw — creating and throwing exceptions. throws — declaring checked exceptions in method signatures. Creating custom exception classes. Checked vs unchecked — when to use which. The "throw early, catch late" principle.
The classic interview trilogy. final: constant/prevent-override/prevent-extend. finally: guaranteed cleanup block. finalize: deprecated garbage collection hook. Why they're asked together — and why finalize is gone in modern Java.
Member inner class (tied to outer instance). Static nested class (independent). Local inner class (inside a method). Anonymous inner class (inline implementation). When to use each. How lambdas replaced most anonymous classes.
Package declaration, import statements, static import. java.lang (auto-imported), java.util, java.io. Creating custom packages. Classpath and module path. Access control across packages.
The Java data structure toolkit — Lists, Sets, Maps, Queues, and type-safe generics
Collection interface → List, Set, Queue. Map interface (separate hierarchy). Iterable → Collection flow. Choosing the right collection: when to use ArrayList vs LinkedList vs HashSet vs TreeMap.
ArrayList (dynamic array, O(1) random access). LinkedList (doubly linked, O(1) insert/delete at ends). Vector (thread-safe, legacy). List.of() for immutable lists (Java 9). When to use which.
HashSet (O(1) lookup, no order). LinkedHashSet (insertion order preserved). TreeSet (sorted, O(log n), backed by red-black tree). Custom sorting with Comparator. Duplicate detection relies on equals/hashCode.
HashMap (O(1) get/put, no order). HashMap internal working: hashing, buckets, collision handling (linked list → tree in Java 8). LinkedHashMap (insertion order). TreeMap (sorted keys). Map.of() for immutable maps.
Queue interface (FIFO). ArrayDeque (double-ended, preferred over Stack). PriorityQueue (min-heap by default). Using PriorityQueue with custom Comparator for max-heap. Used in BFS, Dijkstra's, k-th largest problems.
Comparable: natural ordering (compareTo in the class itself). Comparator: external ordering (compare in a separate class or lambda). Sorting with Collections.sort() and List.sort(). Multi-field sorting. Interview staple.
Iterator interface (hasNext, next, remove). ListIterator (bidirectional). ConcurrentModificationException — why you can't modify a collection while iterating. Using Iterator.remove() safely. Spliterator for parallel processing.
Generic classes, methods, and interfaces. Bounded types (<T extends Comparable>). Wildcards: ? extends, ? super (PECS: Producer Extends, Consumer Super). Type erasure — how generics work at compile time but disappear at runtime.
Java 8+ functional features that changed how Java code is written
Syntax: (params) -> expression or (params) -> { statements }. Lambdas as implementations of functional interfaces. Capturing variables (effectively final requirement). Replacing anonymous classes with lambdas.
@FunctionalInterface annotation. Built-in interfaces: Predicate<T> (test), Function<T,R> (apply), Consumer<T> (accept), Supplier<T> (get), BiFunction, UnaryOperator. Composing functions with andThen, compose.
Four types: static (Math::max), instance on object (str::length), instance on class (String::toLowerCase), constructor (ArrayList::new). When to use method references vs lambdas — readability wins.
Creating streams: stream(), Stream.of(), Arrays.stream(), IntStream.range(). Intermediate operations: filter, map, flatMap, distinct, sorted, peek, limit, skip. Lazy evaluation — nothing executes until a terminal operation.
Terminal operations: forEach, collect, reduce, count, min, max, anyMatch, allMatch, findFirst. Collectors: toList, toSet, toMap, groupingBy, partitioningBy, joining, summarizingInt. The power of Collectors.groupingBy.
Eliminating NullPointerException with Optional. Creating: Optional.of(), Optional.ofNullable(), Optional.empty(). Consuming: ifPresent, orElse, orElseGet, orElseThrow. Chaining: map, flatMap, filter. Why Optional should be used for return types, not parameters.
Concurrency, file operations, annotations, and Java 11–21 features
Creating threads: extending Thread vs implementing Runnable. Thread lifecycle (NEW, RUNNABLE, BLOCKED, WAITING, TERMINATED). Thread.sleep(), join(), yield(). Why Runnable is preferred over Thread extension.
synchronized keyword (method-level and block-level). Intrinsic locks/monitors. Deadlock — what it is, how it happens, how to avoid it. volatile keyword. wait(), notify(), notifyAll() for inter-thread communication.
Why creating threads manually doesn't scale. ExecutorService, FixedThreadPool, CachedThreadPool, ScheduledExecutorService. Submitting tasks with submit() and invokeAll(). Shutting down gracefully.
Asynchronous programming without callback hell. supplyAsync, thenApply, thenAccept, thenCompose, thenCombine. Exception handling with exceptionally and handle. Composing multiple async operations.
Byte streams (FileInputStream/OutputStream), character streams (FileReader/Writer), buffered streams. Serialisation with Serializable and transient keyword. java.nio.file: Path, Files, Files.readAllLines(), Files.write().
Built-in: @Override, @Deprecated, @SuppressWarnings, @FunctionalInterface. Meta-annotations: @Retention, @Target. Creating custom annotations. Annotations in frameworks (Spring, JUnit) — why understanding them matters.
LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period. DateTimeFormatter for parsing and formatting. Why java.util.Date is legacy and java.time is the modern replacement.
Text blocks (Java 13): multi-line strings with """. Switch expressions (Java 14). Virtual threads (Java 21): lightweight threads for massive concurrency. Modules system (Java 9) overview. What's coming next in Java.
Design an employee/banking/vehicle hierarchy using inheritance, polymorphism, interfaces, and exception handling.
Implement a generic Stack and Queue using arrays and linked nodes — understanding what ArrayList and LinkedList do internally.
Anagram detection, palindrome checks, duplicate removal, sorting — all in Java with proper use of String methods and Collections.
Process employee/student datasets using filter, map, collect, groupingBy — the pattern used in every real Java backend.
Student record system with File I/O, Serialisation, exception handling, and menu-driven CLI — integrating all core concepts.
Build a simple task processing system using ExecutorService and CompletableFuture — understanding real-world concurrency patterns.
Expert trainers explain concepts, code live, and solve OOP design problems interactively. 3–5 sessions per week.
Daily Java problems on our platform — Collections-based, OOP-based, and algorithm problems with JDK 21 compiler and automated testing.
MCQ tests on OOP/Collections theory + timed coding challenges. Auto-evaluated with topic-wise analytics.
Student-wise dashboards tracking Java concept mastery, Collections fluency, and coding speed. TPOs see batch-level readiness.
Every major IT service company's technical screening includes Java-specific questions — OOP concepts, Collections, exception handling, multithreading. Students who can't answer these lose marks in sections their aptitude prep didn't cover.
Spring Boot, Hibernate, microservices — the enterprise world runs on Java. Students learning Core Java are building the foundation for the most in-demand backend skill stack. Full Stack Development tracks build directly on this module.
Android apps are built in Java (and Kotlin, which is Java-compatible). Students targeting mobile development roles at Samsung, Google, or app-focused startups need Core Java fluency.
Product companies like Amazon, Goldman Sachs, and Flipkart accept Java for coding interviews. Java's Collections (HashMap, TreeMap, PriorityQueue) are powerful tools for DSA problem-solving — competitive with C++ STL.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
