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
