Duration: Instructor-led 4-days 

Description: 

This course is intended for experienced Java developers who want to go beyond the basics and explore the deeper aspects of the language and its ecosystem. You’ll dive into advanced object-oriented concepts, concurrency, JVM tuning, design patterns, memory management, and build tools. You’ll also learn how to create secure, modular, testable, and production-ready applications using modern Java techniques and libraries. 

Through a mix of lecture, discussion, and hands-on labs, this course will help you write better code, debug more effectively, and architect more scalable solutions. 

Prerequisites: 

• Solid experience with Java SE (Java 8 or later) 

• Familiarity with core OOP principles (inheritance, polymorphism, encapsulation) 

• Basic understanding of collections, exception handling, and file I/O 

• Experience working with Maven or Gradle (preferred) 

Key Takeaways: 

• Deep understanding of the JVM, memory management, and performance tuning 

• Proficiency in advanced Java language features and concurrency APIs 

• Ability to apply design patterns effectively in real-world codebases 

• Skills to build modular, testable applications using modern Java practices 

• Tools and techniques for building and securing Java applications in production environments 

Module 1: Advanced Java Language Features 

Topics: 

• Advanced use of generics 

• Lambda expressions and streams (Java 8+) 

• Method references and functional interfaces 

• Optional, records, sealed classes (Java 14+) 

• Working with the java.time API 

• Exception handling best practices 

Hands-on Labs: 

• Create custom generic classes and methods 

• Chain stream operations for data processing 

• Use functional interfaces for cleaner code 

• Refactor legacy code using modern Java features 

• Build a mini-functional data processing pipeline 

Module 2: Concurrency, Multithreading, and the JVM 

Topics: 

• Java memory model and thread safety 

• Thread lifecycle and Executor framework 

• Futures, CompletableFuture, and asynchronous programming 

• Thread pools and scheduling 

• Deadlock, race conditions, and how to prevent them 

• JVM internals: heap, stack, garbage collection, class loading 

• Basic JVM tuning 

Hands-on Labs: 

• Implement a multithreaded application using ExecutorService 

• Use CompletableFuture to parallelize I/O tasks 

• Detect and fix concurrency bugs 

• Visualize thread behavior using JConsole and VisualVM 

• Simulate memory leaks and analyze garbage collection logs 

Module 3: Design Patterns, Testing, and Modularization 

Topics: 

• Creational, structural, and behavioral design patterns 

• Dependency injection with Spring (core concepts) 

• Writing modular code with Java Modules (JPMS) 

• Unit testing with JUnit 5 and Mockito 

• Test coverage, assertions, parameterized tests 

• Clean code practices and SOLID principles 

Hands-on Labs: 

• Refactor code using the Strategy, Singleton, and Observer patterns 

• Write unit tests for business logic and edge cases 

• Mock dependencies using Mockito 

• Modularize a sample project using JPMS 

• Apply clean code techniques to a legacy code snippet 

Module 4: Building and Deploying Production-Grade Applications 

Topics: 

• Working with Maven/Gradle for builds and dependency management 

• Creating RESTful APIs using Spring Boot 

• Exception handling and logging (SLF4J, Logback) 

• Securing Java applications (input validation, authentication basics, OWASP) 

• Performance tuning and profiling 

• Packaging and deploying with Docker 

Hands-on Labs: 

• Build and run a REST API with Spring Boot 

• Add logging, error handling, and validation layers 

• Secure endpoints with basic authentication 

• Profile the application using JVisualVM 

• Containerize the application with Docker and run it locally