Overview
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.
In This Hands-on Java Programming Course, You Will Learn How To:
- 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
Part 1: Java 9 Updates
Lesson: 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
Lesson: 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)
Lesson: Why JigSaw?
- Problems with Classpath
- Encapsulation and the public access modifier
- Application memory footprint
- Java 8’s compact profile
- Using internal JDK APIs
Lesson: 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
Lesson: 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
Lesson: Working with Modules
- Being backwards compatible
- The ModulePath and ClassPath
- Unnamed Modules
- Automatic Modules
- The JLink tool
Exercise: Migrating to modules
Part 3: JShell
Lesson: 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
Lesson: 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
Lesson: 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
Lesson: Memory Management (Optional)
- Understand memory management in Java
- Discuss the various garbage collectors
- The Garbage-First (G1) Garbage Collector
Part 5: Multithreading and Concurrency
Lesson: 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
Lesson: 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
Lesson: 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
Lesson: Introspection and Reflection
- Reflection classes
- Introspection
- Dynamic invocation of methods
- Using annotations
- Type annotations
- Receiver parameter
Exercise: Introspection and Reflection
Exercise: Reflection Server
Lesson: Reference Objects
- List the kinds of object references available in Java
- Introduce Weak, Soft and PhantomReference
- Explain the ReferenceQueue
Part 7: Effective Java
Lesson: Objects, Declarations, and Initializations
- Abstraction and Responsibilities
- Low Coupling
- Programming principles
- Inheritance
Lesson: Exceptions
- Proper use of Exceptions
- Managing state in exceptional situations
- Checked vs. Unchecked Exceptions
Part 8: Writing High-Performance Applications
Lesson: Profiling 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
Lesson: 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
Lesson: 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
Lesson: 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
Lesson: Design Optimization Techniques
- List five ways to optimize Java program design
This course is available on our public schedule via Live Virtual Classroom:
Contact us here.