Java Programming (Core to Spring Boot)

Learn what Java is and where it is used, install the JDK, write and run your first programs, and work with variables, the eight primitive types, operators, casting and keyboard input. After this module you can write, compile and run small Java programs that read input and calculate results.

1. What Java is and where it is usedJava is a general-purpose, object-oriented programming language. Your code is compiled into bytecode, which runs on the Java Virtual Machine (JVM) on any operating system. It powers bank systems, large web backends, Android apps (alongside Kotlin) and big-data tools, which is why it remains one of the most hired-for languages in India.20 min
2. Installing the JDK and your first programInstall a current LTS JDK, check it with java -version, then write Hello.java: a public class named Hello with a main method that prints a line. Compile with javac Hello.java and run with java Hello, or run a single file directly with java Hello.java. Compile errors stop the build; run-time errors (exceptions) happen while the program runs.30 min
3. Variables and primitive typesA variable has a type, a name and a value, and its type never changes. Java has eight primitive types: byte, short, int, long (whole numbers), float, double (decimals), char (one character) and boolean. Everything else, such as String, is a reference type. Use final for constants and var to let the compiler infer a local variable's type.25 min
4. Operators and expressionsJava has arithmetic (+ - * / %), assignment (= += -=), increment (++ --), comparison (== != < >) and logical (&& || !) operators. Dividing two ints gives an int (7 / 2 is 3). Ints silently overflow when they pass about 2.1 billion. && and || short-circuit, and brackets make precedence clear.25 min
5. Type conversion and reading inputJava converts smaller types to bigger ones automatically (widening), but going the other way (narrowing) needs an explicit cast like (int) 9.99, which cuts off the decimals. Text is turned into numbers with Integer.parseInt and Double.parseDouble. Scanner reads keyboard input; watch out for the leftover newline after nextInt().25 min

Make decisions with if, the ternary operator and both kinds of switch, repeat work with every loop, organise code into methods with parameters and return values, and read errors and stack traces like a professional. After this module you can write complete console programs such as a grade calculator or an EMI table, split into clean methods.

1. Decisions: if, else and the ternaryif runs a block only when a boolean condition is true; else if and else handle the other cases, and only the first matching branch runs. Conditions must be real booleans in Java (if (count) does not compile). The ternary operator condition ? a : b picks one of two values in an expression.20 min
2. switch statements and switch expressionsswitch picks a branch by comparing one value with fixed cases. The classic form needs break, or execution falls through into the next case. Modern switch (Java 14+) uses arrows (case X ->), never falls through, can return a value as an expression, and must cover every possible case.25 min
3. Loops: for, while, do-while and for-eachfor loops count, while loops repeat until a condition is false, do-while runs at least once, and the enhanced for (for-each) walks through every element of an array or collection. break leaves a loop, continue skips to the next round, and a label lets break leave an outer loop.25 min
4. Methods: parameters, return values and overloadingA method is a named block of code inside a class, called with arguments and optionally returning a value. Java passes arguments by value: primitives are copied, and for objects the reference is copied, so a method can change an object's contents but not make the caller's variable point elsewhere. Overloading means several methods with the same name but different parameter lists.30 min
5. Reading errors and debuggingCompile errors (cannot find symbol, incompatible types, missing return) are found by javac before running; read the file, line and caret. Run-time exceptions print a stack trace: the first line names the exception, and the first "at" line in YOUR code shows where it happened. An IDE debugger with breakpoints lets you pause and inspect variables.20 min

Store lists in arrays and grids in 2D arrays, apply classic array algorithms, master Strings (immutability, the string pool, equals versus ==), build text efficiently with StringBuilder and printf, and understand wrapper classes and autoboxing. After this module you can process marks, seat maps and text data, and avoid the most famous Java interview traps.

1. ArraysAn array holds a fixed number of values of one type, numbered from index 0 to length - 1. New arrays are filled with default values (0, false or null). Reading outside the range throws ArrayIndexOutOfBoundsException. java.util.Arrays gives toString, sort, fill, copyOf and equals. Arrays are objects, so assigning one to another variable shares it.25 min
2. Two-dimensional arrays and array algorithmsA 2D array is an array of arrays, written int[][], perfect for grids such as a cinema seat map or marks of students across subjects. Classic algorithms on arrays include linear search, binary search (only on sorted data), reversing, finding max and min, and counting frequencies.30 min
3. Strings in depthA String is an immutable object: methods like toUpperCase return a new String. String literals are kept in a shared string pool, which is why == sometimes seems to work, but == compares references, so always compare text with equals or equalsIgnoreCase. Key methods: length, charAt, substring (end exclusive), indexOf, contains, split, strip, replace and isBlank.30 min
4. StringBuilder and formattingJoining Strings with + inside a loop creates a new String every time, which is slow for big loops. StringBuilder is a mutable buffer: append, insert, reverse, then toString once. printf and String.format format numbers and text (%d, %s, %.2f, %,d, %n), and text blocks (""" … """) write multi-line text cleanly.25 min
5. Wrapper classes and autoboxingEach primitive has a wrapper class (int → Integer, double → Double, char → Character, boolean → Boolean) so it can be used where an object is needed, such as in collections. Java converts automatically (autoboxing and unboxing). Watch two traps: unboxing a null throws NullPointerException, and == on Integer objects compares references (true for -128 to 127 because of a cache, false for 128).25 min

Start object-oriented programming: define classes with fields and methods, create objects with constructors, protect data with encapsulation, understand static and final, and give classes proper toString, equals and hashCode, or let records do it for you. After this module you can model real things such as bank accounts, products and orders as clean Java classes.

1. Classes and objectsA class is a blueprint that describes data (fields) and behaviour (methods). An object is one thing built from that blueprint with new, holding its own field values. Variables hold references to objects; a reference can be null. Calling methods on objects with the dot operator is the heart of object-oriented programming.25 min
2. Constructors and thisA constructor is a special method with the class's name and no return type that runs when you write new. It sets up a valid object from the start. this.field = field separates a field from a parameter of the same name, constructors can be overloaded, and this(...) calls another constructor. If you write any constructor, Java no longer adds the default no-argument one.25 min
3. Encapsulation: private fields, getters and settersEncapsulation means hiding an object's data (private fields) and allowing changes only through methods that enforce the rules. Getters read values; setters or, better, meaningful methods like deposit and withdraw change them with checks. Immutable classes (final fields, no setters) are the simplest and safest of all.25 min
4. static members and finalstatic fields and methods belong to the class, not to any one object: one shared copy for everyone, used as ClassName.member. They suit counters, constants and utility methods like Math.max. final means "assigned once": final variables become constants, final methods cannot be overridden, and final classes cannot be extended.20 min
5. toString, equals, hashCode and recordsEvery class inherits toString, equals and hashCode from Object. Override toString for readable output, and override equals and hashCode TOGETHER so that equal objects have equal hash codes, or HashSet and HashMap will misbehave. Records (Java 16+) generate all three, plus the constructor and accessors, for simple immutable data classes.30 min

Reuse and specialise classes with inheritance, let one variable hold many kinds of objects with polymorphism, define partial blueprints with abstract classes and contracts with interfaces, and organise code into packages with the right access levels. After this module you can design small class hierarchies, such as payment methods or notification channels, the way real Java codebases do.

1. Inheritance with extendsA subclass extends a superclass to reuse its fields and methods and add or change behaviour. It models an "is-a" relationship: a SavingsAccount is an Account. The subclass constructor calls the parent constructor with super(...). A Java class can extend only one class, and every class ultimately extends Object.25 min
2. Overriding and polymorphismA subclass can override an inherited method with its own version, marked @Override. Polymorphism means a parent-type variable can hold any subclass object, and calling a method runs the subclass's version chosen at run time (dynamic dispatch). instanceof with pattern matching safely checks and casts to a subclass when needed.30 min
3. Abstract classesAn abstract class is a partial blueprint: it cannot be instantiated with new, and it can declare abstract methods (no body) that every concrete subclass must implement. It can also hold fields, constructors and finished methods. It suits families of classes that share state and some steps but differ in others.20 min
4. InterfacesAn interface is a contract: a set of method signatures that implementing classes promise to provide. A class can implement many interfaces. Interfaces can also have default methods (with bodies), static methods and constants. Programming to interfaces, as in List<String> list = new ArrayList<>(), keeps code flexible. Sealed types (Java 17) limit which classes may implement them.30 min
5. Packages and access modifiersPackages group related classes into folders with names like com.shop.billing, avoid name clashes and control visibility. You use classes from other packages with import (java.lang is imported automatically). Java has four access levels: public (everywhere), protected (package plus subclasses), default/package-private (same package only) and private (same class only).20 min

Handle failures properly with try, catch, finally, checked and unchecked exceptions, custom exceptions and try-with-resources; write type-safe reusable code with generics; and avoid NullPointerException with Optional and null checks. After this module you can write robust Java code that fails clearly and reuses logic safely across types.

1. Exceptions: try, catch and finallyAn exception is an object that signals a problem and interrupts normal flow. try wraps code that may fail, catch handles a specific exception type, and finally always runs for clean-up. All exceptions descend from Throwable: Error (serious JVM problems, do not catch) and Exception (problems your program can handle). Catch the most specific types first.25 min
2. Checked vs unchecked exceptions and throwing your ownChecked exceptions (like IOException) must be caught or declared with throws, so the compiler forces callers to think about them. Unchecked exceptions (RuntimeException and its subclasses) usually signal bugs or bad input and need no declaration. You raise your own with throw new …, create custom exception classes for domain problems, and wrap low-level exceptions with a cause.25 min
3. try-with-resources and clean-upFiles, network connections and database connections must be closed, or the program runs out of them. try-with-resources (try (Resource r = …) { … }) closes every resource automatically at the end of the block, in reverse order, even when an exception is thrown. Any class that implements AutoCloseable can be used this way.20 min
4. GenericsGenerics let classes and methods work with any type while keeping type safety: List<String> only accepts Strings and needs no casts. You write generic classes (Box<T>), generic methods (<T> T first(List<T> list)), bounded types (<T extends Number>) and wildcards (List<? extends Number>). Generics are erased at run time, so you cannot use primitives as type arguments or create new T().30 min
5. Avoiding NullPointerExceptionNullPointerException (NPE) happens when you call a method or read a field on null. Prevent it by validating inputs with Objects.requireNonNull, returning empty collections instead of null, and using Optional<T> as a method return type when a value may be absent. Optional offers orElse, orElseThrow, map and ifPresent; it is not meant for fields or parameters.20 min

Use the Java collections framework like a professional: List (ArrayList, LinkedList), Set (HashSet, LinkedHashSet, TreeSet), Map (HashMap, LinkedHashMap, TreeMap), sorting with Comparable and Comparator, and queues, stacks and priority queues. After this module you can pick the right collection for any job and explain how HashMap works in an interview.

1. Collections overview and ListThe collections framework gives ready-made data structures behind common interfaces: List (ordered, allows duplicates), Set (no duplicates), Queue/Deque (processing order) and Map (key → value). ArrayList is the default List: fast random access, growing automatically. LinkedList is rarely better. List.of makes small unmodifiable lists. Never remove items inside a for-each loop; use removeIf or an Iterator.30 min
2. Sets: HashSet, LinkedHashSet and TreeSetA Set stores each element at most once. HashSet is the fastest and has no guaranteed order, LinkedHashSet keeps insertion order, and TreeSet keeps elements sorted. Uniqueness relies on equals and hashCode (or compareTo for TreeSet). contains is very fast for HashSet. addAll, retainAll and removeAll give union, intersection and difference.20 min
3. Maps: HashMap, LinkedHashMap and TreeMapA Map stores key → value pairs with unique keys: a PIN code to a city, a SKU to stock. HashMap is the everyday choice (fast, no order), LinkedHashMap keeps insertion order and TreeMap keeps keys sorted. getOrDefault, merge and computeIfAbsent make counting and grouping short. HashMap uses hashCode to choose a bucket and equals to find the key inside it.30 min
4. Sorting with Comparable and ComparatorSorting needs a rule for which object comes first. A class can define its natural order by implementing Comparable (compareTo). For any other order, pass a Comparator, most easily built with Comparator.comparing(...).thenComparing(...).reversed(). Sort with list.sort(comparator) or Collections.sort.25 min
5. Queues, stacks and priority queuesA Queue processes elements first-in, first-out (FIFO) with offer, poll and peek. ArrayDeque works as both a fast queue and a stack (push, pop, peek; last-in, first-out). PriorityQueue always gives the smallest element first (a min-heap) or the most important one with a Comparator. Choose collections by how you will use them.25 min

Write behaviour as data with lambdas and method references, process collections declaratively with the Stream API and Collectors, and read and write files with java.nio.file. After this module you can turn a CSV of orders into a sales report per city in a few clear lines of modern Java.

1. Lambdas and functional interfacesA lambda is a short, anonymous function: (a, b) -> a + b. It can be used wherever a functional interface (an interface with exactly one abstract method) is expected, such as Comparator, Runnable, Predicate, Function, Consumer and Supplier. Lambdas can read local variables only if those are effectively final.25 min
2. Method referencesA method reference is a shorter lambda that just calls an existing method: String::length instead of s -> s.length(). There are four kinds: static (Integer::parseInt), on a particular object (System.out::println), on an arbitrary object of a type (String::toUpperCase), and constructors (ArrayList::new). Use them when they make code clearer.20 min
3. Streams: filter, map and collectA stream is a pipeline that processes elements from a source (a collection, an array, a file) through intermediate steps (filter, map, sorted, distinct, limit) to one terminal step (toList, count, sum, reduce, forEach). Streams are lazy and can be used only once. They describe WHAT you want, instead of writing loops.30 min
4. Collectors: grouping and summarisingcollect(...) with the Collectors class turns a stream into maps and summaries: groupingBy (group by a key), counting, summingInt/summingDouble, averagingDouble, partitioningBy (split by true/false), joining (one string) and toMap. These replace many lines of map-building loops in reports.25 min
5. Reading and writing filesModern Java file I/O uses java.nio.file: Path.of("data", "orders.csv") builds a path, Files.readString / Files.readAllLines read small files, Files.writeString writes, and Files.lines streams big files line by line (close it with try-with-resources). Always specify UTF-8 where it matters and handle IOException.30 min

Run work in parallel safely: create threads, understand race conditions and fix them with synchronized, volatile and atomic variables, use thread pools, futures and CompletableFuture, choose concurrent collections, and use Java 21 virtual threads for high-concurrency I/O. After this module you can write and reason about the concurrent code found in every Java backend.

1. Threads: doing things at the same timeA thread is an independent path of execution inside a program. Java programs start with the main thread and can create more with Thread and Runnable, so slow tasks do not block others and multi-core CPUs are used fully. Call start(), not run(), to begin a new thread; join() waits for a thread to finish.25 min
2. Race conditions and synchronizedWhen threads share changing data, their steps can interleave and corrupt it: count++ is really read, add, write, so two threads can lose updates. This is a race condition. synchronized lets only one thread at a time run a block guarded by a lock, volatile makes a variable's latest value visible to all threads, and acquiring locks in different orders can cause deadlock.30 min
3. Executors, futures and CompletableFutureInstead of creating threads by hand, submit tasks to an ExecutorService (a thread pool) that reuses a fixed number of threads. submit returns a Future whose get() waits for the result. CompletableFuture chains asynchronous steps (supplyAsync, thenApply, thenCombine, exceptionally) without blocking, and allOf waits for many. Always shut pools down.30 min
4. Atomic variables and concurrent collectionsjava.util.concurrent offers thread-safe building blocks: AtomicInteger and AtomicLong for lock-free counters, ConcurrentHashMap for shared maps (with atomic merge and compute), CopyOnWriteArrayList for rarely-changed lists, BlockingQueue for producer-consumer pipelines and CountDownLatch to wait for several tasks. Immutable objects need no synchronisation at all.25 min
5. Virtual threads (Java 21)Virtual threads (final in Java 21) are lightweight threads managed by the JVM, not the operating system. You can run hundreds of thousands of them, each doing simple blocking code (calling a database or an HTTP API), while a few OS threads carry them. They make high-concurrency I/O easy, but they do not make CPU-heavy work faster.25 min

Connect Java to a database with JDBC and PreparedStatement, block SQL injection, build projects with Maven and Gradle, and prove your code works with JUnit tests and Mockito mocks. After this module you can set up a real Java project that talks to a database, builds with one command and has an automated test suite.

1. JDBC: talking to a databaseJDBC (Java Database Connectivity) is the standard API for SQL databases. You get a Connection (from DriverManager or, in real apps, a connection pool), run SQL with a PreparedStatement and ? placeholders, read rows from a ResultSet, and close everything with try-with-resources. Group related changes in a transaction with commit and rollback.30 min
2. SQL injection and safe queriesSQL injection happens when user input is pasted into SQL text, letting an attacker change the query itself, for example logging in without a password or reading other customers' data. The fix is to always use PreparedStatement with ? parameters (or an ORM that does), never string concatenation. Add defence in depth: least-privilege database users, input validation and no secrets in logs.20 min
3. Maven: building and dependenciesMaven is a build tool: it downloads libraries (dependencies) from Maven Central, compiles your code, runs tests and packages a JAR, all from one pom.xml file and a standard folder layout. Commands follow a lifecycle: mvn compile, test, package, install. The Maven Wrapper (./mvnw) lets anyone build without installing Maven.25 min
4. Gradle in briefGradle is the other major Java build tool. It uses a build script (build.gradle in Groovy or build.gradle.kts in Kotlin) instead of XML, is fast thanks to incremental builds and caching, and is the standard for Android. Dependencies use configurations like implementation and testImplementation; tasks run with ./gradlew build or ./gradlew test.20 min
5. Unit testing with JUnitJUnit is the standard Java testing framework. A test is a method annotated @Test that arranges data, acts by calling your code, and asserts the result with assertEquals, assertTrue or assertThrows. @BeforeEach sets up fresh objects, @ParameterizedTest runs one test with many inputs, and Mockito replaces slow or external dependencies with mocks. Tests run with mvn test or ./gradlew test.30 min

Build a real REST API the way most Java teams do: understand dependency injection, create a Spring Boot app, write controllers with validation and proper status codes, split code into controller, service and repository layers, and store data with JPA and Spring Data repositories. After this module you can build and explain a small production-style Spring Boot backend.

1. Spring and dependency injectionSpring is a framework whose core is an Inversion of Control (IoC) container: instead of your classes creating their own dependencies with new, Spring creates objects (beans) and passes ("injects") the dependencies they need. Classes marked @Component, @Service or @Repository become beans, and constructor injection is the recommended style. This makes code loosely coupled and easy to test.25 min
2. Creating a Spring Boot appSpring Boot makes Spring easy to start: generate a project at start.spring.io, add starters such as spring-boot-starter-web, and run it. Auto-configuration sets up sensible defaults, an embedded Tomcat server listens on port 8080, and settings live in application.properties or application.yml, with profiles for dev and prod. Spring Boot 3 and later need Java 17 or newer.25 min
3. Building a REST APIA @RestController maps HTTP requests to Java methods: @GetMapping, @PostMapping, @PutMapping and @DeleteMapping, with @PathVariable, @RequestParam and @RequestBody for inputs. Objects are converted to and from JSON automatically. ResponseEntity sets status codes (201 Created, 404 Not Found), @Valid with jakarta.validation annotations checks input, and @RestControllerAdvice turns exceptions into clean error responses.30 min
4. Layers: controller, service and repositorySpring Boot backends are usually split into layers: controllers handle HTTP (parsing input, choosing status codes), services hold the business rules, and repositories talk to the database. DTOs carry data across the API boundary, entities map to tables. Each layer can be tested on its own: @WebMvcTest for controllers, plain unit tests for services, @DataJpaTest for repositories.25 min
5. JPA and Spring Data repositoriesJPA (Jakarta Persistence) maps Java classes to database tables, and Hibernate is the usual implementation. An @Entity class with an @Id becomes a table; Spring Data JPA turns an interface extending JpaRepository into a working repository with save, findById and findAll, and generates queries from method names like findByCityAndPriceLessThan. Watch out for lazy loading and the N+1 query problem.30 min

Write maintainable object-oriented code with the SOLID principles and the most used design patterns, understand JVM memory and garbage collection, practise the questions Java interviews ask most, and plan your projects and career. After this module you can discuss design and JVM topics confidently and walk into a Java developer interview prepared.

1. SOLID principlesSOLID is five guidelines for object-oriented design: Single responsibility (one reason to change), Open/closed (extend without editing), Liskov substitution (subclasses must keep the parent's promises), Interface segregation (small focused interfaces) and Dependency inversion (depend on abstractions, not concrete classes). They keep large codebases changeable.30 min
2. Common design patternsDesign patterns are named, proven solutions to common design problems. Java developers meet Singleton (one instance), Factory (create objects without exposing which class), Builder (create objects with many optional fields readably), Strategy (swap algorithms) and Observer (notify many listeners of an event) constantly, including inside Spring itself.30 min
3. JVM memory and garbage collectionEach thread has a stack for method calls and local variables; all objects live on the shared heap. The garbage collector (G1 by default since Java 9) frees objects that are no longer reachable, so you never free memory yourself. Class metadata lives in Metaspace. Too little heap gives OutOfMemoryError; too-deep recursion gives StackOverflowError. -Xms and -Xmx set the heap size.25 min
4. Java interview questionsJava interviews in India and abroad repeat a core set of questions: JDK vs JRE vs JVM, == vs equals, String immutability, HashMap internals, ArrayList vs LinkedList, checked vs unchecked exceptions, final/finally/finalize, abstract class vs interface, overloading vs overriding, why main is static, streams vs collections, and synchronized vs volatile. Answer each in two or three sentences with one example.30 min
5. Projects and a Java careerJava leads to backend developer, Spring Boot microservices, Android (with Kotlin), QA automation with Selenium and big-data roles. Build three solid projects (for example a library manager, a Spring Boot expense API with a database, and a multithreaded file processor), publish them on GitHub with good READMEs, prepare for the usual interview rounds, and keep salary expectations honest.25 min