Next Level Java 9 Programming | Intermediate Java 9
Course Objectives: What You’ll Learn
This “skills-centric” course is about 50% hands-on lab and 50% lecture, designed to train attendees in basic OO coding and Java development skills, coupling the most current, effective techniques with the soundest industry practices. Throughout the course students will be led through a series of progressively advanced topics, where each topic consists of lecture, group discussion, comprehensive hands-on lab exercises, and lab review.
Our engaging instructors and mentors are highly-experienced practitioners who bring years of current "on-the-job" application development experience into every classroom. Working within in an engaging, hands-on learning environment, guided by our expert team, attendees will learn 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
Specific Java 9 features that are covered in the course include:
- The Java Module System (project Jigsaw)
- JShell
- Updated try-with-resources
- Performance enhancements in Java 9
- Multi-Release Jar files
Audience & Pre-Requisites: Who Should Attend
This is an intermediate level Java SE (JSE) developer course, designed for basic-level Java developers comfortable with Java 8 or should have a working knowledge in developing basic Java 9 applications.
Related Courses – Suggested Learning Path
Take Before: Students should have development skills at least equivalent to the following course(s) or should have attended as a pre-requisite:
- TT2100-J9 Java 9Programming Fundamentals for OO Experienced Developers
- TT2120-J9 Java 9 and OO Programming Essentials for Developers New to OO
Take After: Our core Java training courses provide students with a solid foundation for continued learning based on role, goals, or their areas of specialty. Our object oriented, Java developer learning paths offer a wide variety of follow-on courses such as:
- Specialized or continued Java & JEE training: Spring, Hibernate; JSF, Struts, Design Patterns & more
- Java Web Development, JEE Foundation training
- Agile development, TDD / Test Driven Development, JUnit / Unit Testing training
- Secure Java Coding / Java Security and secure application development training
- Web Services, REStful Services, Microservices courses
- Mobile developer / Android training
- Please contact us for recommended next steps tailored to your longer-term education, project, role or development objectives.
Course Agenda
Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We’ll work with you to tune this course and level of coverage to target the skills you need most.
Session: 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
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)
Session: 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
Lesson: The Module Descriptor
- Define module requirements
- Explain qualified exports
- Open modules for reflection
- Use ServiceLoader
- The provides and uses keywords
Lesson: Working with Modules
- Being backwards compatible
- The ModulePath and ClassPath
- Unnamed Modules
- Automatic Modules
- The JLink tool
Session: JShell
Lesson: JShell
- Introduction to JShell
- Running Expressions in JShell
- Importing packages
- Defining methods and types
- Using the JShell editor
- Save and loading state
Session: 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
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
Session: Multithreading and Concurrency
Lesson: Multithreading
- Principles of Multithreading
- Creating a Threaded Class
- Basic Features of the Thread Class
- Thread Scheduling
- Thread Synchronization
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
Lesson: Java 8 Concurrency Updates
- The common thread pool
- Atomic variables
- LongAdder and LongAccumulator
- CompletableFuture
- Non-blocking asynchronous tasks
Session: Reflection and References
Lesson: Introspection and Reflection
- Reflection classes
- Introspection
- Dynamic invocation of methods
- Using annotations
- Type annotations
- Receiver parameter
Lesson: Reference Objects
- List the kinds of object references available in Java
- Introduce Weak, Soft and PhantomReference
- Explain the ReferenceQueue
Session: 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
Session: 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
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
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
Sorry! It looks like we haven’t updated our dates for the class you selected yet. There’s a quick way to find out. Contact us at 502.265.3057 or email info@training4it.com
Request a Date