Next Level Java 9 | Intermediate Java 9 Programming
Learn about the advantages of Java 9 that can help them improve performance and functionality of your Java 9 applications.
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
Duration
4 days/32 hours of instructionPricing
Starting at: $2495
GSA Price: $1870
Group Rate: $2395
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