JAVA TRAINING PROGRAM
Complete Training Syllabus
Core Java | OOP | JSP | JDBC | SQL | Collections | Exception Handling | Spring | MVC | REST API
Level: Beginner to Advanced | Format: Instructor-Led
📘 PROGRAM OVERVIEW
This comprehensive Java training program is designed to take learners from fundamental Java
concepts all the way to building enterprise-level applications using Spring Framework, MVC
Architecture, and REST APIs. The curriculum is structured across 12 weeks, combining theory, hands-
on coding, and real-world projects.
Program Highlights:
• 5 Core Modules covering all major Java topics
• Weekly practice problems and coding challenges
• Real-world projects and mini-applications
• Industry-standard tools: IntelliJ IDEA, Maven, MySQL, Postman
• Final capstone project: Full-stack Spring Boot REST API application
Prerequisites:
• Basic programming knowledge (any language)
• Understanding of basic computer science concepts
• No prior Java experience required
MODULE 1: Core Java Fundamentals
1.1 Introduction to Java
• History and evolution of Java
• JDK, JRE, JVM - Architecture and differences
• How Java code compiles and runs (Bytecode, ClassLoader)
• Setting up the development environment (JDK + IDE)
• Writing and running your first Java program
• Understanding main() method and program structure
1.2 Java Basics
• Data Types: Primitive (byte, short, int, long, float, double, char, boolean)
• Variables: Declaration, initialization, scope
• Literals, Constants (final keyword)
• Type Casting: Implicit (Widening) and Explicit (Narrowing)
• Operators: Arithmetic, Relational, Logical, Bitwise, Ternary, Assignment
• Input/Output: Scanner class, [Link]/printf
1.3 Control Flow Statements
• Conditional: if, if-else, if-else-if ladder, switch-case
• Loops: for, while, do-while
• Enhanced for-each loop
• Break, continue, return statements
• Labeled loops
1.4 Arrays
• Single-dimensional arrays: declaration, initialization, traversal
• Multi-dimensional arrays (2D and 3D arrays)
• Array manipulation: sorting, searching, copying
• Arrays class utility methods ([Link], [Link], [Link])
• Jagged arrays
1.5 Methods (Functions)
• Defining and calling methods
• Parameters: pass-by-value vs pass-by-reference
• Return types and void methods
• Method overloading
• Variable arguments (varargs)
• Recursion: concept and examples
1.6 Strings in Java
• String class: immutability, String pool
• StringBuilder and StringBuffer: differences and usage
• Important String methods: length, charAt, substring, indexOf, replace, split, trim, equals,
compareTo
• String formatting with printf and format
• Regular Expressions basics with Pattern and Matcher
Topics Covered Learning Outcomes
• JDK/JVM/JRE setup Write basic Java programs,
• Variables, Data Types, Operators understand variable types and
• Control Flow - if/else, loops control flow
• Basic I/O with Scanner
• Methods and Recursion Build simple console programs
• Arrays (1D and 2D) using arrays, strings and methods
• String class and methods
• StringBuilder vs StringBuffer
MODULE 2: Object-Oriented Programming (OOP)
2.1 Classes and Objects
• Defining a class: attributes and behaviors
• Creating objects: new keyword, heap memory
• Instance variables vs class (static) variables
• Constructors: default, parameterized, copy constructors
• Constructor chaining using this()
• this keyword: referring to current instance
2.2 Encapsulation
• Access Modifiers: private, default, protected, public
• Getter and Setter methods (JavaBeans convention)
• Data hiding and security through encapsulation
• Package concept and import statements
2.3 Inheritance
• extends keyword and IS-A relationship
• Single, multilevel, and hierarchical inheritance
• super keyword: accessing parent class members
• Method overriding: rules and @Override annotation
• Covariant return types
• Constructor inheritance and super()
• Why Java doesn't support multiple class inheritance
2.4 Polymorphism
• Compile-time polymorphism: Method Overloading
• Runtime polymorphism: Method Overriding
• Upcasting and Downcasting
• Dynamic method dispatch
• instanceof operator
2.5 Abstraction
• Abstract classes: abstract keyword
• Abstract methods: declaration without body
• Concrete vs Abstract classes
• Interfaces: interface keyword, implementing interfaces
• Default and static methods in interfaces (Java 8+)
• Functional interfaces and @FunctionalInterface
• Multiple interface implementation
• Abstract class vs Interface - when to use what
2.6 Advanced OOP Concepts
• Static members: static variables, static methods, static blocks
• Final keyword: final variable, final method, final class
• Inner classes: static nested, inner, local, anonymous
• Lambda expressions (Java 8+)
• Generics: generic classes, methods, wildcards
• Enumerations (enum)
Weeks Topics Covered Learning Outcomes
• Classes, Objects, Constructors Design classes using
• Encapsulation and Access Modifiers OOP principles,
Week 3 implement inheritance
• Inheritance and super keyword
• Method Overriding hierarchies
• Polymorphism and Dynamic Dispatch Use abstraction,
• Abstract Classes and Interfaces polymorphism; apply
Week 4 generics and lambda
• Inner Classes and Anonymous Classes
• Generics and Enums basics
MODULE 3: Collections Framework & Exception
Handling
3.1 Exception Handling
• What is an Exception? Checked vs Unchecked exceptions
• Exception hierarchy: Throwable, Exception, Error, RuntimeException
• try-catch-finally block
• Multiple catch blocks and catching multiple exceptions
• throw and throws keywords
• Creating custom (user-defined) exceptions
• try-with-resources (AutoCloseable interface)
• Exception chaining
3.2 Collections Framework Overview
• Need for Collections over arrays
• Collection interface hierarchy
• Iterable, Collection, List, Set, Queue, Map interfaces
• Iterator and ListIterator
3.3 List Implementations
• ArrayList: dynamic array, random access, performance
• LinkedList: doubly linked list, insertion/deletion performance
• Vector and Stack (legacy)
• CopyOnWriteArrayList (thread-safe)
• Common operations: add, remove, get, set, contains, size, sort
3.4 Set Implementations
• HashSet: hash table backed, no duplicates, O(1) operations
• LinkedHashSet: maintains insertion order
• TreeSet: sorted order (Red-Black tree), NavigableSet
• EnumSet: for enum types
3.5 Map Implementations
• HashMap: key-value pairs, hash table, null key allowed
• LinkedHashMap: maintains insertion order
• TreeMap: sorted by keys, NavigableMap
• Hashtable vs HashMap (legacy, thread-safe)
• ConcurrentHashMap: thread-safe HashMap alternative
• [Link] interface: iterating maps
3.6 Queue and Deque
• Queue interface: offer, poll, peek
• PriorityQueue: heap-based priority ordering
• Deque interface: ArrayDeque
• Stack operations using Deque
3.7 Collections Utility Class & Java 8 Stream API
• [Link], shuffle, reverse, min, max, frequency
• Comparable vs Comparator interfaces
• Stream API: filter, map, reduce, collect, forEach
• Optional class
• Method references
Weeks Topics Covered Learning Outcomes
• Exception types and hierarchy Handle exceptions
• try-catch-finally, throw/throws gracefully; create and
Week 5 throw custom exceptions
• Custom exceptions
• try-with-resources
• List: ArrayList, LinkedList Use Collections
• Set: HashSet, TreeSet effectively, apply Stream
Week 6 API for data processing
• Map: HashMap, TreeMap
• Stream API and Comparators
MODULE 4: JSP, JDBC & SQL
4.1 JDBC - Java Database Connectivity
• JDBC Architecture: Driver Manager, Connection, Statement, ResultSet
• JDBC Driver types (Type 1 to Type 4)
• Steps to connect Java to a database
• Statement vs PreparedStatement vs CallableStatement
• Executing queries: executeQuery, executeUpdate, execute
• ResultSet: navigating rows and columns
• Connection pooling: DataSource, connection pool concept
• Transaction management: commit, rollback, setAutoCommit
• Stored procedures and functions via CallableStatement
4.2 SQL Fundamentals
• DDL: CREATE, ALTER, DROP, TRUNCATE
• DML: INSERT, UPDATE, DELETE
• DQL: SELECT with WHERE, ORDER BY, GROUP BY, HAVING
• Joins: INNER, LEFT, RIGHT, FULL OUTER, CROSS JOIN
• Subqueries: correlated and non-correlated
• Constraints: PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK
• Indexes: creating, types, performance impact
• Views, Stored Procedures, Triggers, Functions
• Normalization: 1NF, 2NF, 3NF, BCNF
4.3 JSP - JavaServer Pages
• Servlet lifecycle and architecture
• HTTP: GET vs POST requests
• Servlet configuration: [Link] and @WebServlet annotation
• Request, Response, Session, Application scopes
• HttpServletRequest and HttpServletResponse methods
• Request dispatching: forward and redirect
• Session management: HttpSession, cookies
• JSP Basics: scriptlets, expressions, declarations
• JSP Directives: page, include, taglib
• Implicit objects: request, response, session, application, out, pageContext
• JSTL (JSP Standard Tag Library)
• EL (Expression Language)
• MVC pattern with Servlets and JSP
MODULE 5: Spring Framework, MVC & REST API
5.1 Spring Framework Core
• Introduction to Spring: problems it solves
• Spring Architecture and modules overview
• Inversion of Control (IoC) and Dependency Injection (DI)
• ApplicationContext and BeanFactory
• Bean lifecycle: instantiation, initialization, destruction
• Bean scopes: singleton, prototype, request, session
• XML-based and Annotation-based configuration
• @Component, @Service, @Repository, @Controller stereotypes
• @Autowired, @Qualifier, @Primary
• @Value and @PropertySource for externalized config
• Spring AOP: Aspect, Advice, Pointcut, JoinPoint
5.2 Spring Boot
• Spring Boot vs Spring Framework
• Auto-configuration and starter dependencies
• spring-boot-starter-web, starter-data-jpa, starter-security
• [Link] / [Link] configuration
• Embedded server (Tomcat) and JAR deployment
• @SpringBootApplication annotation
• Profiles: @Profile, [Link]
• Actuator: health, metrics, info endpoints
5.3 Spring MVC
• DispatcherServlet and request lifecycle
• @Controller and @RequestMapping
• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
• @PathVariable and @RequestParam
• Model, ModelAndView, ViewResolver
• Thymeleaf template engine integration
• Form handling and @ModelAttribute
• Data validation: @Valid, @NotNull, BindingResult
• Interceptors: HandlerInterceptor
5.4 Spring Data JPA & Hibernate
• ORM concept and Hibernate as JPA provider
• @Entity, @Table, @Id, @GeneratedValue, @Column
• Relationships: @OneToOne, @OneToMany, @ManyToMany
• CascadeType and FetchType (EAGER vs LAZY)
• Spring Data JPA Repository: JpaRepository, CrudRepository
• Custom queries with @Query and JPQL
• Named queries and native queries
• Pagination and Sorting: Pageable, Sort
5.5 REST API Development
• REST principles: stateless, uniform interface, resource-based
• HTTP methods: GET, POST, PUT, PATCH, DELETE
• HTTP status codes: 200, 201, 400, 401, 403, 404, 500
• @RestController and @ResponseBody
• @RequestBody with JSON deserialization
• ResponseEntity: controlling status codes and headers
• Exception handling: @ExceptionHandler, @ControllerAdvice
• Global exception handling with @RestControllerAdvice
• Validation of request body with @Valid
• API documentation with Swagger / OpenAPI 3
• Consuming REST APIs with RestTemplate and WebClient
• CORS configuration
• Basic Spring Security: authentication, authorization
• JWT (JSON Web Token) based authentication
TOOLS & TECHNOLOGY STACK
Category Tool / Technology Purpose
Language Java 17 (LTS) Primary programming language
IDE IntelliJ IDEA / Eclipse Development environment
Build Tool Maven / Gradle Dependency management
Database MySQL 8.x Relational database
ORM Hibernate / Spring Data JPA Object-relational mapping
Framework Spring Boot 3.x Application framework
Testing JUnit 5, Mockito Unit and integration testing
API Testing Postman REST API testing
Version Control Git + GitHub Source code management
API Docs Swagger / OpenAPI 3 API documentation
Frontend (basic) Thymeleaf / JSP Server-side templates