Intermediate to advanced Java development focuses on building robust, scalable, and maintainable applications using modern Java programming techniques. Developers will strengthen their skills in advanced OOP, collections, streams, concurrency, database integration, testing, design patterns, performance, and secure application development.
Duration 5 Days – 35 hrs.
Overview
This instructor-led course develops the practical skills required to build robust, maintainable, and high-performing Java applications. It progresses from intermediate Java programming concepts to advanced techniques, including object-oriented design, generics, collections, functional programming, multithreading, database integration, testing, design patterns, and application performance.
The course combines technical discussions, demonstrations, hands-on exercises, and a practical application project. It focuses primarily on modern Core Java and prepares participants for enterprise Java development and further study of frameworks such as Spring Boot.
Objectives
- Apply advanced object-oriented programming principles in Java applications.
- Use interfaces, abstract classes, inheritance, composition, and polymorphism effectively.
- Work confidently with generics, collections, records, enums, and annotations.
- Process data using lambda expressions, functional interfaces, and the Stream API.
- Implement reliable exception-handling and resource-management strategies.
- Read from and write to files using modern Java I/O and NIO APIs.
- Develop concurrent applications using threads, executors, and synchronization tools.
- Connect Java applications to relational databases using JDBC.
- Apply commonly used software design patterns.
- Write automated unit tests using JUnit.
- Improve code quality through refactoring and clean-code practices.
- Diagnose basic performance, memory, and concurrency issues.
- Build a modular, maintainable Java application using industry-standard practices.
Target Audience
- Java developers with foundational programming experience
- Junior developers progressing toward intermediate or senior roles
- Software engineers and application developers
- Backend developers
- Full-stack developers working with Java
- Technical professionals maintaining Java applications
- Developers preparing to work with Spring, Spring Boot, or enterprise Java platforms
Prerequisites
- Basic to intermediate Java programming knowledge
- Experience with variables, operators, loops, methods, arrays, and classes
- Basic understanding of object-oriented programming
- Familiarity with exception handling and Java collections
- Basic knowledge of SQL and relational databases
- Experience using an IDE such as IntelliJ IDEA, Eclipse, or Visual Studio Code
Recommended but not mandatory:
- At least three to six months of Java development experience
- Basic familiarity with Git and Maven or Gradle
Course Outline
Day 1 – Advanced Object-Oriented Java and Application Design
Module 1: Java Development Environment Review
- Java Development Kit and Java Virtual Machine
- Java compilation and execution process
- Organizing Java projects and packages
- Using IDE debugging and refactoring tools
- Overview of modern Java language features
- Build tools: Maven and Gradle overview
Module 2: Advanced Object-Oriented Programming
- Encapsulation, inheritance, abstraction, and polymorphism
- Method overloading and overriding
- Abstract classes and interfaces
- Interface default and static methods
- Composition versus inheritance
- Immutability and defensive copying
- Working with nested and anonymous classes
- Enums, records, and sealed classes
Module 3: SOLID and Clean-Code Principles
- Single Responsibility Principle
- Open/Closed Principle
- Liskov Substitution Principle
- Interface Segregation Principle
- Dependency Inversion Principle
- Naming, method design, and class organization
- Identifying code smells
- Refactoring poorly structured Java code
Hands-on Exercise: Refactor an existing Java application using object-oriented and SOLID principles.
Day 2 – Generics, Collections, Functional Programming, and Streams
Module 4: Generics and Type Safety
- Generic classes, interfaces, and methods
- Type parameters and bounded types
- Wildcards: ?, ? extends, and ? super
- Generic type inference
- Type erasure and its implications
- Designing reusable generic components
Module 5: Java Collections Framework
- List, Set, Queue, Deque, and Map
- ArrayList versus LinkedList
- HashSet, LinkedHashSet, and TreeSet
- HashMap, LinkedHashMap, and TreeMap
- Comparable and Comparator
- Iterators and collection traversal
- Immutable and unmodifiable collections
- Selecting the appropriate collection
- Performance characteristics of collections
Module 6: Lambda Expressions and Functional Interfaces
- Functional programming concepts
- Lambda expression syntax
- Built-in functional interfaces
- Predicate, Function, Consumer, and Supplier
- Method and constructor references
- Creating custom functional interfaces
Module 7: Stream API
- Creating and processing streams
- Intermediate and terminal operations
- Filtering, mapping, sorting, and reducing
- Collectors and grouping operations
- FlatMap and nested data structures
- Optional for null-safe processing
- Sequential versus parallel streams
- Stream performance considerations
Hands-on Exercise: Build a data-processing component using collections, lambdas, and streams.
Day 3 – Exception Handling, File Processing, and Concurrency
Module 8: Advanced Exception Handling
- Checked and unchecked exceptions
- Designing custom exceptions
- Exception propagation and wrapping
- Multi-catch and try-with-resources
- Exception-handling best practices
- Logging errors without exposing sensitive information
Module 9: Java I/O and NIO
- Byte streams and character streams
- Buffered file operations
- Working with Path and Files
- Reading and writing text and binary files
- Directory traversal
- File attributes and monitoring
- Object serialization considerations
- Processing large files efficiently
Module 10: Multithreading and Concurrency
- Processes, threads, and task execution
- Creating and managing threads
- Runnable and Callable
- Thread lifecycle and interruption
- Race conditions and thread safety
- Synchronization and locks
- Atomic variables
- ExecutorService and thread pools
- Future and CompletableFuture
- Concurrent collections
- Avoiding deadlocks
- Virtual threads overview
- Concurrency testing and debugging
Hands-on Exercise: Develop a multithreaded file-processing or task-execution application.
Day 4 – Database Integration, Testing, and Design Patterns
Module 11: Database Programming with JDBC
- JDBC architecture and components
- Establishing database connections
- Executing SQL statements
- Working with ResultSet
- PreparedStatement and parameterized queries
- Preventing SQL injection
- Insert, update, delete, and batch operations
- Transaction management
- Commit, rollback, and savepoints
- Connection pooling concepts
- Data Access Object pattern
Module 12: Automated Testing with JUnit
- Importance of automated testing
- Unit, integration, and system testing
- Structuring JUnit test cases
- Assertions and exception testing
- Test lifecycle methods
- Parameterized tests
- Test fixtures and test isolation
- Mocking concepts and dependency isolation
- Test-driven development overview
- Measuring test coverage
Module 13: Java Design Patterns
- Purpose and categories of design patterns
- Singleton pattern and its limitations
- Factory Method and Abstract Factory
- Builder pattern
- Strategy pattern
- Observer pattern
- Adapter pattern
- Facade pattern
- Template Method pattern
- Repository and Data Access Object patterns
- Selecting patterns based on application requirements
- Avoiding unnecessary pattern implementation
Hands-on Exercise: Develop and test a database-driven Java module using JDBC and appropriate design patterns.
Day 5 – Performance, Security, Architecture, and Capstone Project
Module 14: Java Performance and Memory Management
- JVM runtime architecture
- Stack, heap, and metaspace
- Object creation and garbage collection
- Common causes of memory leaks
- String and collection performance
- Basic application profiling
- CPU and memory monitoring
- Identifying inefficient algorithms
- Performance testing principles
- JVM tuning overview
Module 15: Secure Java Development
- Input validation and output handling
- Preventing SQL injection
- Safe exception and error handling
- Password and sensitive-data handling
- Secure file processing
- Dependency and library management
- Logging security considerations
- Principle of least privilege
- Overview of common Java application vulnerabilities
Module 16: Maintainable Java Application Architecture
- Separation of concerns
- Layered application architecture
- Domain, service, and data-access layers
- Dependency management
- Configuration management
- Logging strategies
- Package and module organization
- Introduction to modular Java applications
- Preparing Core Java applications for Spring Boot
Module 17: Capstone Project
Participants will build or enhance a Java application that incorporates:
- Advanced object-oriented design
- Generics and collections
- Lambda expressions and streams
- Exception handling and logging
- File or database processing
- Multithreading or asynchronous processing
- Unit testing
- Design patterns
- Clean-code and security practices
Project Activities:
- Requirements analysis
- Application design
- Coding and integration
- Testing and debugging
- Code review and refactoring
- Project presentation and instructor feedback
Recommended Software and Tools
- A supported Long-Term Support version of the Java Development Kit
- IntelliJ IDEA, Eclipse, or Visual Studio Code
- Maven or Gradle
- Git
- JUnit
- MySQL, PostgreSQL, or another relational database
- Database client or administration tool
