This course develops advanced programming skills using Java 21 JDK Platform. It covers advanced object-oriented design, generics and collections, exception handling, file processing, concurrency, database connectivity, and application troubleshooting. Participants learn to build and maintain reliable Java SE 7 applications and integrate their skills through a practical capstone project.

 

Duration 5 days – 35 hrs 

 

Objectives

• Apply advanced object-oriented principles to develop maintainable Java applications.
• Use generics and appropriate collection types to organize and process data.
• Apply Java 21 JDK language enhancements and robust exception-handling techniques.
• Manage files and directories using the NIO.2 API.
• Develop concurrent applications using executors, synchronization, and concurrent collections.
• Apply the Fork/Join framework to suitable parallel processing tasks.
• Implement database operations and transactions using JDBC.
• Use reflection and annotations for runtime inspection and metadata handling.
• Investigate application performance, memory usage, and threading issues.
• Integrate advanced Java features into a complete application.

 

Target Audience 

• Java developers seeking advanced Java JDK programming skills.
• Software engineers maintaining Java 21 JDK applications.
• Application developers working with file processing, concurrency, and database integration.
• Technical leads who need a deeper understanding of Java application behavior.
• Developers preparing to support or enhance existing Java 21 JDK systems.

 

 Prerequisites 

• Completion of a Java fundamentals course or equivalent practical experience.
• Proficiency in Java syntax, control flow, methods, classes, and interfaces.
• Working knowledge of inheritance, polymorphism, and encapsulation.
• Familiarity with basic exception handling, collections, and file input/output.
• Ability to compile, run, and debug Java applications using an IDE.
• Basic understanding of relational databases and SQL statements.

 

 

Course Outline 

Module 1: Advanced Object-Oriented Programming

• Review on Basic Java
  • Instance and static variables
  • Local scoped variables
  • Methods
  • Access and non-access modifiers
  • Primitive and reference variables
  • Program constructs and the Pattern Match project
  • Java Coding Standard version 2010
• The principles of OOP
• Applying abstraction and encapsulation
• The HAS-A relationships among classes
• Applying composition, inheritance, and polymorphism
• The Java design patterns 

 

Module 2: Exception Handling

• Throwables, Error, and Exceptions
• Checked and unchecked exceptions
• Ways of managing exceptions
  • Simple try-catch
  • Multiple catch implementation
  • Throwing and re-throwing

• • Try-with-resources and the AutoCloseable interface

• Risky methods
• Best practices in managing exceptions

 

Module 3: Advanced Generics and Collections

• Generic classes, interfaces, and methods
• Diamond syntax for generic object creation
• Bounded type parameters and wildcards
• Type erasure and generic type limitations
• Collection Framework
• Frozen collections
• Concurrent collections
• Java Data Structures (Stack and Queue)
• Sorting with Comparable and Comparator
• Collection performance and safe iteration

 

Module 4: JVM Diagnostics and Performance

• The Object and overriding equals(), hashCode(), and toString() correctly
• Designing immutable objects
• Using nested, inner, and anonymous classes
• The Enum classes
• JVM memory areas and garbage collection fundamentals
• Identifying unnecessary object retention
• Examining thread activity and thread dumps
• Monitoring applications with JConsole and VisualVM
• Using logging to investigate failures
• Identifying bottlenecks before making optimizations

 

Module 5: Thread Safety and Synchronization

• Creating lightweight processes
  • Thread
  • Runnable
• Thread lifecycle and shared mutable state
• Thread utilities for synchronization
• Synchronization techniques
  • Race conditions and memory visibility
  • Appropriate use of volatile
  • Synchronization and intrinsic locks
  • Mutual exclusion
• The Executor Framework and Concurrent APIs
  • Task cancellation, timeouts, and orderly shutdown
• Concurrent collections and blocking queues
• The Callable<T> task
• Asynchronous methods
  • Future<T>
  • CompletableFuture<T>
• Explicit locks and atomic variables
• Semaphores
• Deadlock prevention and thread interruption
• Coordination using latches, barriers, and semaphores

 

Module 6: Non-blocking Input/Output

• Review on the old IO APIs
• Object serialization, transient fields, and version compatibility
• Risks of deserializing untrusted data
• Working with Path, Paths, and Files and the NIO 2.0
  • Creating, copying, moving, and deleting files
  • Reading and updating file attributes
  • Traversing directory trees with file visitors
  • Filtering files and handling symbolic links
  • Monitoring directory changes with WatchService
• Byte streams, character streams, and character encoding
• Buffered input/output and resource management
• Data streams and random-access files
• Buffers and channels

 

Module 7: Parallel Processing with Fork/Join

• Divide-and-conquer task design
• ForkJoinPool and work stealing
• RecursiveTask and RecursiveAction
• Selecting task thresholds
• Combining results safely
• Recognizing workloads unsuitable for Fork/Join

 

Module 8: Reflection and Annotations

• Inspecting classes, methods, constructors, and fields
• Creating objects and invoking methods dynamically
• Defining custom annotations
• Annotation targets and retention policies
• Reading annotations at runtime
• Reflection limitations and maintainability considerations

  

Module 9: Advanced JDBC Programming

• JDBC architecture and database connections
• Prepared statements and parameterized queries
• Processing result sets and database metadata
• Batch operations
• Transactions, rollback, and savepoints
• Transaction isolation concepts
• JDBC 4.1 resource handling and RowSet fundamentals

 

Module 11: Designing Reliable Data Access

• Separating database logic through the Data Access Object pattern
• Mapping database records to Java objects
• Managing connection and statement lifecycles
• Defining transaction boundaries
• Handling database errors consistently
• Connection pooling concepts and DataSource

 

Module 12: Managing Java projects

• Using Maven for project structuring and building
• Packaging the projects
• Deployment to Git and Github
• Introduction to CI/CD
• Introduction to Jakarta EE for web development and API