This course develops advanced programming skills using Java Platform, Standard Edition 7 (Java SE 1.7). 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 SE 7 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 SE programming skills.
• Software engineers maintaining Java SE 7 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 SE 7 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 

Day 1: Advanced Language Features and Object-Oriented Design

Module 1: Advanced Object-Oriented Programming

• Designing cohesive classes and interfaces
• Applying composition, inheritance, and polymorphism
• Using nested, inner, and anonymous classes
• Designing immutable objects
• Implementing equals(), hashCode(), and toString() correctly
• Applying Factory and Strategy design patterns

 Module 2: Java SE 7 Language Enhancements and Exception Handling

• Diamond syntax for generic object creation
• Strings in switch statements
• Binary literals and underscores in numeric literals
• Multi-catch and precise exception rethrowing
• Try-with-resources and the AutoCloseable interface
• Suppressed exceptions and custom exception design

 Module 3: Advanced Generics and Collections

• Generic classes, interfaces, and methods
• Bounded type parameters and wildcards
• Type erasure and generic type limitations
• Selecting lists, sets, maps, and queues
• Sorting with Comparable and Comparator
• Collection performance and safe iteration

  

Day 2: File Processing and Runtime Metadata

Module 4: Advanced Input/Output

• Byte streams, character streams, and character encoding
• Buffered input/output and resource management
• Data streams and random-access files
• Buffers and channels
• Object serialization, transient fields, and version compatibility
• Risks of deserializing untrusted data

 Module 5: File and Directory Management with NIO.2

• Working with Path, Paths, and Files
• 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

 Module 6: 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

  

Day 3: Multithreading and Concurrency

Module 7: Thread Safety and Synchronization

• Thread lifecycle and shared mutable state
• Race conditions and memory visibility
• Synchronization and intrinsic locks
• Appropriate use of volatile
• Explicit locks and atomic variables
• Deadlock prevention and thread interruption

 Module 8: Executors and Concurrent Utilities

• Tasks using Runnable and Callable
• Thread pools and ExecutorService
• Retrieving results with Future
• Task cancellation, timeouts, and orderly shutdown
• Concurrent collections and blocking queues
• Coordination using latches, barriers, and semaphores

 Module 9: 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

  

Day 4: Database Integration and Application Diagnostics

Module 10: 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: JVM Diagnostics and Performance

• 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

 

 Day 5: Application Integration and Capstone Project

Module 13: Application Structure and Packaging

• Organizing packages and application layers
• Externalizing application configuration
• Defining consistent error-handling and logging policies
• Managing startup, resource ownership, and shutdown
• Creating executable JAR files and manifests
• Managing classpaths and Java SE 7 compatibility

 Module 14: Capstone — Concurrent File Processing and Database Application

• Design a configurable batch application that processes files from an input directory
• Discover and read files using NIO.2
• Validate and transform records using generics and collections
• Process independent files through a bounded executor
• Store valid records using JDBC prepared statements and transactions
• Capture invalid records and processing errors
• Generate a consolidated processing report
• Implement resource cleanup and orderly application shutdown
• Package the application as an executable JAR
• Inspect runtime behavior using logging and JVM monitoring tools