Core Java Online Training

Operating systems basics, files and directories, environment variables, processes and services, ports and networking basics, client-server architecture, browser-server communication, HTTP/HTTPS basics, DNS, IP addresses, localhost, proxy concepts, and command line fundamentals.

Installing and configuring IntelliJ IDEA, Eclipse, Visual Studio Code, JDK installation, Maven installation, Git installation, Node.js and npm, Postman, Docker Desktop, AWS CLI, and Linux terminal.

Creating a Java project, Maven project structure, pom.xml anatomy, dependency management, build lifecycle (clean, compile, test, package, install), running and debugging applications, environment variables, .env concepts, and application configuration.

Hands-on practical: Initialize a multi-package Java project using Maven archetypes, configure dependencies, compile bytecode, and execute via CLI.

History of Java, JDK vs JRE vs JVM, Java architecture, Java compilation process, bytecode generation, JVM classloading & execution, Java editions, and project structure.

Variables, constants, primitive data types (byte, short, int, long, float, double, char, boolean), reference types, type casting and conversion, wrapper classes, autoboxing, unboxing, and local variable type inference (var).

Arithmetic, relational, logical, assignment, unary, ternary, bitwise, and shift operators with evaluation precedence.

if, if-else, nested conditions, classic switch, enhanced switch expressions with pattern preview, for, enhanced for-each, while, do-while, break, continue, and return.

Method declaration, parameters, return types, method overloading, varargs, static vs instance methods, pass-by-value mechanics, and recursion fundamentals.

One-dimensional arrays, multi-dimensional arrays, array traversal, searching, sorting, copying with System.arraycopy, and array manipulation utilities.

String creation, immutability concepts, String Constant Pool, comparison (== vs equals), String vs StringBuilder vs StringBuffer, common String APIs, parsing, and formatting.

Classes, objects, constructors (default, parameterized, copy), encapsulation, inheritance, polymorphism (compile-time vs runtime), abstraction, interfaces, abstract classes, method overriding, this, super, and final keywords.

public, private, protected, default/package-private access specifiers, package hierarchies, and static/named imports.

java.lang.Object methods (toString, equals, hashCode, clone), Math, Arrays, Objects, System, Integer, Long, Double, BigDecimal for precision, and UUID generation.

Errors vs exceptions, checked vs unchecked exceptions, try, catch, finally, throw, throws, custom business exceptions, exception hierarchies, multi-catch, and try-with-resources with AutoCloseable.

Collection hierarchy, List (ArrayList, LinkedList, Vector, Stack), Set (HashSet, LinkedHashSet, TreeSet), Map (HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap), Queue (PriorityQueue, ArrayDeque), Iterators, Comparable, Comparator, hashing, equals() and hashCode() contract.

Generic classes, generic methods, generic interfaces, type parameters, bounded types (<T extends Comparable<T>>), wildcards (?), upper bounded (extends), and lower bounded (super).

Lambda expressions, functional interfaces (@FunctionalInterface), Predicate, Consumer, Supplier, Function, BiFunction, method references (::), default and static interface methods, and java.util.Optional.

Stream creation, intermediate operations (filter, map, flatMap, sorted, distinct, limit, skip, peek), terminal operations (forEach, collect, reduce, count, min, max, findFirst, findAny), Collectors groupingBy, partitioningBy, and parallel stream performance.

LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period, and DateTimeFormatter formatting.

Process vs thread, Thread lifecycle, Runnable vs Callable, Future, ExecutorService, fixed/cached thread pools, synchronization, ReentrantLock, race conditions, deadlocks, atomic variables, concurrent collections, and CompletableFuture async chaining.

JVM architecture, ClassLoader subsystem, Heap, Stack, Metaspace, Garbage Collection mechanisms (Serial, Parallel, G1, ZGC), memory leak identification, StackOverflowError, OutOfMemoryError, and JVM monitoring tools.

JDBC architecture, JDBC Driver types, DriverManager, Connection, Statement, PreparedStatement, ResultSet navigation, and CRUD operations against MySQL/PostgreSQL.

setAutoCommit(false), commit(), rollback(), Savepoints, batch query processing, connection pooling concepts (HikariCP), SQL injection prevention via parameterized queries, and SQLException handling.

Build a Java-based Employee Management System implementing DAO pattern, connection pooling, and transactional CRUD.

Maven introduction, build lifecycles (clean, default, site), POM hierarchy, dependency management, transitive dependencies, dependency scopes (compile, provided, runtime, test, system), and resolving version conflicts.

Compiler and surefire test plugins, Maven build profiles, Maven repositories (Local, Central, Remote), multi-module parent POMs, and build packaging into runnable JAR and WAR files.

Git architecture, repositories, working tree, staging index, commit DAGs, branching models, merging, and rebasing.

clone, init, status, add, commit, push, pull, fetch, checkout, switch, merge, rebase, stash, reset (soft/mixed/hard), revert, cherry-pick, tag, log, and diff.

GitHub repositories, README creation, Pull Request (PR) reviews, branch protection rules, .gitignore best practices, and release management.

Design normalized database tables, configure Maven dependencies, and build thread-safe HikariCP connection pooled DAO repositories.

Implement domain services using Java 21 Records, Sealed Classes, Streams aggregation reports, and transactional rollback guards.

Document the GitHub repository with architecture diagrams, pass capstone unit scenarios, and complete the Core Java AI Viva session.