Advanced Java Programming Training Course

Java developers looking to increase their understanding and abilities with the more advanced Java APIs and capabilities.

You should be comfortable with the topics in our Intro Java Programming training course or have similar experience, with at least 6 months' solid Java coding experience.

This advanced Java course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).

Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.

Modern Java Features and Best Practices

• Review of Core Java Fundamentals:

  • Object-Oriented Programming (OOP) principles: Encapsulation, Inheritance, Polymorphism, Abstraction.

  • Key language features: Collections, Streams (brief introduction if not covered in detail previously), Lambdas, Functional Interfaces.

• Java 8 and Beyond:

  • Streams API Deep Dive: Intermediate and terminal operations, lazy evaluation, parallel streams, performance considerations.

  • Functional Programming in Java: Advanced lambda expressions, method references, higher-order functions, immutability.

  • Optional Class: Effective use for handling nulls.

  • Date and Time API (java.time): Best practices and advanced usage.

• Java 9 and Later Enhancements:

  • Modules (Project Jigsaw): Understanding modularity, creating and using modules, benefits for large projects.

  • Private Interface Methods: Use cases and benefits.

  • Factory Methods for Collections: Convenience and immutability.

  • Reactive Streams and Flow API (java.util.concurrent.Flow): Introduction to reactive programming concepts.

• Code Style and Best Practices:

  • Effective use of annotations.

  • Writing clean, maintainable, and readable code.

  • Common design patterns in advanced Java.

Concurrency and Parallelism in Modern Java

• Advanced Thread Management:

  • Thread pools: ExecutorService, ForkJoinPool, best practices for different scenarios.

  • Callable and Future: Asynchronous task execution.

  • Synchronization primitives: Locks (ReentrantLock, ReadWriteLock), Semaphores, CountDownLatch, CyclicBarrier, Phaser.

  • Understanding and avoiding common concurrency issues (deadlock, livelock, race conditions).

• Concurrent Collections:

  • Thread-safe collections from java.util.concurrent.

  • Choosing the right concurrent collection for specific use cases.

• Reactive Programming with Project Reactor (or RxJava - Instructor Choice):

  • Introduction to reactive programming principles.

  • Working with Flux and Mono.

  • Operators for transforming, filtering, combining reactive streams.

  • Error handling and backpressure.

• Performance Optimization for Concurrent Applications:

  • Profiling and identifying bottlenecks.

  • Strategies for improving concurrency performance.

Data Handling and Persistence

• Advanced JDBC:

  • Connection pooling and data source management.

  • Transactions and isolation levels.

  • Batch processing.

  • Working with stored procedures.

• Object-Relational Mapping (ORM) with Hibernate (or JPA for specific / custom implementation):

  • Advanced mappings: Collections, inheritance, associations.

  • Querying strategies: HQL/JPQL, Criteria API.

  • Caching mechanisms (first-level, second-level).

  • Transaction management with ORM.

  • Performance optimization with ORM.

• NoSQL Databases and Java Integration (Introduction):

  • Overview of different NoSQL database types (e.g., document, key-value, graph).

  • Basic integration with a popular NoSQL database (e.g., MongoDB with the Java driver, Redis with Jedis/Lettuce). This can be tailored based on industry relevance and course length.

Building Robust and Scalable Applications

• Error Handling and Exception Management:

  • Best practices for designing exception hierarchies.

  • Effective logging strategies using modern logging frameworks (e.g., Logback, SLF4j).

  • Implementing robust error handling mechanisms.

• Testing Advanced Java Applications:

  • Advanced JUnit features (e.g., parameterized tests, theories, extensions).

  • Integration testing strategies.

  • Mocking frameworks (e.g., Mockito) for unit testing complex dependencies.

  • Contract testing (brief introduction).

• Security in Java Applications:

  • Common security vulnerabilities in Java web applications.

  • Basic authentication and authorization using Spring Security (or Java EE Security API).

  • Secure data handling practices.

Performance and Monitoring

• JVM Internals and Performance Tuning:

  • Garbage Collection (GC) algorithms and tuning strategies.

  • Memory management and heap analysis.

  • JVM monitoring tools (e.g., JVisualVM, JProfiler).

• Profiling Java Applications:

  • Using profiling tools to identify performance bottlenecks.

  • Techniques for optimizing CPU and memory usage.

• Monitoring and Observability:

  • Introduction to monitoring tools (e.g., Prometheus, Grafana).

  • Implementing application metrics and logging for observability.

• Performance Testing Strategies:

  • Introduction to load testing tools (e.g., JMeter).

• https://www.oracle.com/java/technologies/downloads/ - Get the Java JDK

• https://www.jetbrains.com/idea/ - popular Java IDE

• https://www.eclipse.org/ - another popular development environment