Skip to content
Search upcoming classes
Course Name
Location
Date
Price
Register
Limited time only! Get 2 courses for the price of one. Learn more

Next Level Java 9 | Intermediate Java 9 Programming

Next Level Java 9 | Intermediate Java 9 Programming is a four-day, hands-on fast-track course geared for developers who have prior working knowledge of basic Java 8 or Java 9.

In this java programming course, you will learn about the advantages of Java 9 that can help them improve performance and functionality of your Java 9 applications.  You will explore and learn how to leverage Modules, scale applications into multi-core environments, improve performance, and become a more effective Java 9 developer. 

Available formats for this course
In-Person
Live Online
Corporate
Corporate Online
Duration
4 days/32 hours of instruction

Starting at: $2495

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.

Next Level Java 9 | Intermediate Java 9 Programming Schedule

Location
Date
Price
Register
CPSFDC\Entity\Session::__set_state(array( 'sfId' => 'a011G00000TXsJYQA1', 'startDate' => '2020-11-02', 'startTime' => '10:00 AM', 'endDate' => '2020-11-05', 'endTime' => '6:00 PM', 'name' => 'TT2205VCL', 'standardCourseFee' => 2495.0, 'courseId' => 'TT2200', 'course' => 'a001G00000CCXO6QAP', 'courseSfId' => 'a001G00000CCXO6QAP', 'courseName' => 'Next Level Java 9 | Intermediate Java 9 Programming', 'instructorId' => '151136', 'instructorSfId' => 'a023700000Z1UwcAAF', 'instructorDisplayName' => 'Trivera', 'instructorName' => 'Trivera', 'locationCode' => 'VCL', 'sessionStatus' => 'O', 'city' => 'Live Online Training', 'state' => NULL, 'cityState' => 'Live, Online Training', 'locationSfId' => 'a0637000000tn2hAAA', 'subjectSfId' => 'a051G00000Jso5fQAB', 'subjectName' => 'Software Development', 'specialitySfId' => 'a051G00000Jso5pQAB', 'specialityName' => 'Java', 'expertiseSfId' => 'a051G00000JsoBZQAZ', 'expertiseName' => NULL, 'certificationSfId' => NULL, 'certificationBody' => NULL, 'certificationName' => NULL, 'pdus' => NULL, 'deliveryModalities' => array ( 0 => 'In-Person', 1 => 'Live Online', ), ))
Live, Online Training
Nov 2nd - 5th 10:00 AM - 6:00 PM ET
$2495
CPSFDC\Entity\Session::__set_state(array( 'sfId' => 'a011G00000TXsJZQA1', 'startDate' => '2020-12-07', 'startTime' => '10:00 AM', 'endDate' => '2020-12-10', 'endTime' => '6:00 PM', 'name' => 'TT2205VCL2', 'standardCourseFee' => 2495.0, 'courseId' => 'TT2200', 'course' => 'a001G00000CCXO6QAP', 'courseSfId' => 'a001G00000CCXO6QAP', 'courseName' => 'Next Level Java 9 | Intermediate Java 9 Programming', 'instructorId' => '151136', 'instructorSfId' => 'a023700000Z1UwcAAF', 'instructorDisplayName' => 'Trivera', 'instructorName' => 'Trivera', 'locationCode' => 'VCL', 'sessionStatus' => 'O', 'city' => 'Live Online Training', 'state' => NULL, 'cityState' => 'Live, Online Training', 'locationSfId' => 'a0637000000tn2hAAA', 'subjectSfId' => 'a051G00000Jso5fQAB', 'subjectName' => 'Software Development', 'specialitySfId' => 'a051G00000Jso5pQAB', 'specialityName' => 'Java', 'expertiseSfId' => 'a051G00000JsoBZQAZ', 'expertiseName' => NULL, 'certificationSfId' => NULL, 'certificationBody' => NULL, 'certificationName' => NULL, 'pdus' => NULL, 'deliveryModalities' => array ( 0 => 'In-Person', 1 => 'Live Online', ), ))
Live, Online Training
Dec 7th - 10th 10:00 AM - 6:00 PM ET
$2495

Learn more about corporate team training