Next Level Java 9 | Intermediate Java 9 Programming

Part 1: Java 9 Updates
1.     Review of What is New in Java 9
•    Overview of 'smaller' Java 9 topics
•    Java versioning
•    The JDK/JRE file structure
•    Deprecation
•    The jdeprscan tool
•    Multi-Release JAR Files
•    HTML 5 compliant JavaDoc
•    Exercise: Creating a MRJar

2.     Milling Project Coin
•    Changes made to the language since Java 6
•    Multi-catch
•    Using effectively final variables in try-with-resources
•    Suppressed Exceptions
•    Binary literals
•    Reserved underscore (Java 9)
•    Type inference in anonymous classes (Java 9)
•    @SafeVargs (updates in Java 9)
•    Default and static methods in interfaces (Java 8)
•    Private methods in interfaces (Java 9)
•    Exercise: Try-With-Resources

Part 2: The Java Module system (Jigsaw)
1.     Why JigSaw?
•    Problems with Classpath
•    Encapsulation and the public access modifier
•    Application memory footprint
•    Java 8’s compact profile
•    Using internal JDK APIs

2.     Introduction to the Module System
•    Introduce Project Jigsaw
•    Classpath and Encapsulation
•    The JDK internal APIs
•    Java 9 Platform modules
•    Defining application modules
•    Define module dependencies
•    Implicit dependencies
•    Implied Readability
•    Exporting packages
•    Exercise: Defining Modules

3.     The Module Descriptor
•    Define module requirements
•    Explain qualified exports
•    Open modules for reflection
•    Use ServiceLoader
•    The provides and uses keywords
•    Exercise: Modules and the ServiceLoader

•    Exercise: Using Reflection on modules

4.     Working with Modules
•    Being backwards compatible
•    The ModulePath and ClassPath
•    Unnamed Modules
•    Automatic Modules
•    The JLink tool
•    Exercise: Migrating to modules

Part 3: JShell
1.     JShell
•    Introduction to JShell
•    Running Expressions in JShell
•    Importing packages
•    Defining methods and types
•    Using the JShell editor
•    Save and loading state
•    Exercise: Working with JShell

Part 4: More Java 9
1.    Other New Java 9 Features
•    Enhancements on the Optional class
•    Improvements made in the Process API
•    The Stack-Walking API
•    The HTTP2 Client
•    The Multi-Resolution API
•    Exercise: Working with Native processes
•    Exercise: HTTP Clients

2.     Performance Optimizations
•    Performance in Java 9
•    Compact Strings
•    String deduplication
•    Ahead-Of-Time Compilation
•    Hotspot Diagnostic commands
•    The G1 Garbage collector
•    Variable and Method Handles

3.     Memory Management (Optional)
•    Understand memory management in Java
•    Discuss the various garbage collectors
•    The Garbage-First (G1) Garbage Collector

Part 5: Multithreading and Concurrency
1.     Multithreading
•    Principles of Multithreading
•    Creating a Threaded Class
•    Basic Features of the Thread Class
•    Thread Scheduling
•    Thread Synchronization
•    Exercise: Simple Thread Class
•    Exercise: Simple Runnable Class

2.     Concurrent Java
•    Concurrent Locks are Explicit and Flexible
•    Executor Interfaces Provide Thread Management
•    Challenges for Concurrent Use of Collections
•    Concurrent Collections
•    Atomic Variables Avoid Synchronization
•    Exercise: Working with Concurrent Java
•    Exercise: Sleeping Threads
•    Exercise: Safe Data Access
•    Exercise: Producer/Consumer

3.     Java 8 Concurrency Updates
•    The common thread pool
•    Atomic variables
•    LongAdder and LongAccumulator
•    CompletableFuture
•    Non-blocking asynchronous tasks
•    Exercise: CompletableFuture

Part 6: Reflection and References
1.     Introspection and Reflection
•    Reflection classes
•    Introspection
•    Dynamic invocation of methods
•    Using annotations
•    Type annotations
•    Receiver parameter
•    Exercise: Introspection and Reflection
•    Exercise: Reflection Server

2.     Reference Objects
•    List the kinds of object references available in Java
•    Introduce Weak, Soft and PhantomReference
•    Explain the ReferenceQueue

Part 7: Effective Java
1.     Objects, Declarations, and Initializations
•    Abstraction and Responsibilities
•    Low Coupling
•    Programming principles
•    Inheritance

2.     Exceptions
•    Proper use of Exceptions
•    Managing state in exceptional situations
•    Checked vs. Unchecked Exceptions

Part 8: Writing High-Performance Applications
1.    rofiling and Benchmarking
•    List and describe the two types of benchmarks
•    Describe the criteria that should be considered when constructing a benchmark plan
•    Name the three most useful targets for profiling
•    List four common tools/techniques for profiling
•    Describe two strategies for improving performance as a result of profiling data
•    List and explain the five most common problem areas for good performance with Java

2.     Profiling Tools
•    Use the JDK to collect runtime profiling data
•    Successfully read the profiling data generated by the JDK to detect performance bottlenecks
•    Instrument your own code to collect method execution time data
•    Exercise: Using the JVM Profiling Tools and Visual VM

3.     Code Optimization Techniques
•    List three potential problems with strings
•    List two ways to optimize loops
•    Describe the advantages of private and final methods
•    List two advantages of collections over vectors and hashtables
•    List 4 other code and system optimizations
•    Exercise: Code Optimizations

4.     Code Optimization Myths
•    Debunk several myths of Java performance tuning
•    Synchronization trade-offs
•    Setting methods to be final
•    String is not always bad
•    Revisit the fundamentals of Java code performance
•    How to detect a performance myth

5.     Design Optimization Techniques
•    List five ways to optimize Java program design

This is an intermediate level Java SE (JSE) developer course, designed for: 

• Experienced Java 8 developers, or
• Basic-level Java 9 developers.
• Attendees should have working knowledge in developing basic Java 8 applications.

• Develop modular applications in Java
• Utilize the tooling that is provided in Java 9 to migrate, monitor and optimize applications
• Use the new JShell tool to quickly test java constructs
• Understand how the implementation of the String class has been updated to decrease the memory footprint
• Use the enhancements made to the Concurrency API, working with CompletableFuture instance of Thread pools