Fast Track to Core Java 17 Programming for OO Developers (TT2104)

Gain the latest skills, techniques and best practices required to create robust, well designed and efficient modern Java applications



4 Days

Course Overview

Fast Track to Java 17 Programming for OO Developers is a four-day, engaging hands-on course that helps experienced object oriented developers (coming from C++, C#, etc.) quickly get up and running with programming in Java, using the latest coding skills. You’ll exit the course well-prepared to tackle real-world programming tasks, equipped with an in-depth knowledge of Java and a practical skill set to create robust, efficient, and secure Java applications.


Working in a skills-immersive, hands-on learning environment led by our expert instructor, you’ll explore the intricacies of the Java platform and the Java Standard Edition, working seamlessly with the Java Development Kit (JDK), and using the development environment (IDE) proficiently. The course emphasizes best practices in OO development, reinforcing core object-oriented principles such as inheritance, polymorphism, interfaces, and abstract classes, allowing you to design software applications, develop back-end systems, or contribute to enterprise-level projects.


The course centers around applying these skills to real-world challenges, ensuring you can leverage them in your role or project right after class. Throughout the course you'll build applications, create subclasses, and develop custom exception handling. You'll also gain proficiency in using Java's arrays, records, packages, and utility classes. The course also delves into the advanced features of Java programming, including working with generics, understanding functional programming with lambda expressions, and using the Collection API. You'll be proficient in the JDK, be able to navigate your course IDE, and will be able to develop complex Java programs.


You’ll exit this course equipped with the skills required to tackle a variety of programming challenges and create efficient, robust Java applications with ease.

Course Objectives


This course combines engaging instructor-led presentations and useful demonstrations with valuable hands-on labs and engaging group activities. Throughout the course you’ll:

  • Master the fundamentals of the Java platform and the Java Standard Edition. This foundation will empower you to make the most of these tools, and confidently navigate the Java ecosystem.
  • Get hands-on with the Java Development Kit (JDK) and become comfortable with the IDE / development environment. These are key tools that will become part of your everyday programming toolbox.
  • Understand and apply essential object-oriented principles such as inheritance, polymorphism, interfaces, and abstract classes. These are the building blocks of effective Java programming.
  • Engage in practical, real-world programming challenges through hands-on lab sessions. You'll become skilled in using arrays, records, packages, and utility classes, enhancing your ability to build robust and efficient Java applications.
  • Dive into advanced Java programming concepts, exploring the use of generics, lambda expressions, functional interfaces, and the Collection API. This will equip you to tackle complex programming tasks and take your coding skills to the next level.
  • Develop a deep understanding of exception handling in Java. Learn how to define your own exceptions, handle multiple exceptions, and use try/catch blocks. This will help you to create more reliable and fault-tolerant code.
  • Explore and understand the Java Modular System and its impacts on accessibility and visibility. You'll become adept at executing Java applications, defining modules, and dealing with dependencies.
  • Gain proficiency in working with collections in Java, which includes learning about the different collection implementations (Set, List, and Queue), using iterators, and sorting collections. This will enable you to manage data effectively in your Java programs.
  • Explore specific Java 17 features that are covered in the course including: Switch Expressions, Text blocks, Pattern matching for instanceof, Introduce records as carrier of immutable data


If your team requires different topics, additional skills or a custom approach, our team will collaborate with you to adjust the course to focus on your specific learning objectives and goals.

Course Prerequisites

This introductory-level course is an excellent fit for developers, software engineers, and IT professionals who have hands-on prior object-oriented programming experience (as in C++, C#, etc.) and are seeking to broaden their skills into Java programming.
To ensure a smooth learning experience and maximize the benefits of attending this course, you should have prior hands-on programming experience in another OO programming language such as C# or C++. This course is not for non-OO developers, or non-developers.
Related Courses
The following is a small subset of related courses. See the online catalog for a complete list of courses and learning paths. 
TT2000 Getting Started with Programming, OO, and Java Basics for Non-Developers 
TT2120 Basic Java Programming for Developers New to OO
TT2140 Fast Track to Core Java Programming for OO Developers 
TT2133 Migrating to Java 11
TT2135 Migrating to Java 17
TT2209 Intermediate Java Programming

Course Agenda

Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We will work with you to tune this course and level of coverage to target the skills you need most.

Java: A First Look 
1. The Java Platform
Introduce the Java Platform
Explore the Java Standard Edition
Discuss the lifecycle of a Java Program
Explain the responsibilities of the JVM
Executing Java programs
Garbage Collection
Documentation and Code Reuse
2. Using the JDK
Explain the JDK’s file structure
Use the command line compiler to compile a Java class
Use the command line Java interpreter to run a Java application class
3. The Eclipse Paradigm
Become more familiar with Eclipse workbench concepts
Explore the paradigm used by Eclipse, consisting of editors, views and perspectives in detail
Introduce some commonly used views
Explain Perspectives
Getting Started with Java 
4. Writing a Simple Class
Write a Java class that does not explicitly extend another class
Define instance variables for a Java class
Create object instances
Primitives vs Object References
Implement a main method to create an instance of the defined class
Java keywords and reserved words
5. Adding Methods to the Class
Write a class with accessor methods to read and write instance variables
Write a constructor to initialize an instance with data
Write a constructor that calls other constructors of the class to benefit from code reuse
Use the this keyword to distinguish local variables from instance variables
Essential Java Programming 
6. Language Statements
Arithmetic operators
Operators to increment and decrement numbers
Comparison operators
Logical operators
Return type of comparison and logical operators
Use for loops
Swtch Expressions
Switch Expressions and yield
7. Using Strings and Text Blocks
Create an instance of the String class
Test if two strings are equal
Perform a case-insensitive equality test
Contrast String, StringBuffer, and StringBuilder
Compact Strings
Text Blocks
Unicode support
8. Fields and Variables
Discuss Block Scoping Rules
Distinguish between instance variables and method variables within a method
Explain the difference between the terms field and variable
List the default values for instance variables
Final and Static fields and methods
9. Specializing in a Subclass
Constructing a class that extends another class
Implementing equals and toString
Writing constructors that pass initialization data to parent constructor
Using instanceof to verify type of an object reference
Pattern matching for instanceof
Overriding subclass methods
Safely casting references to a more refined type
Java Developer's Toolbox 
10. Using Arrays
Declaring an array reference
Allocating an array
Initializing the entries in an array
Writing methods with a variable number of arguments
11. Records
Data objects in Java
Introduce records as carrier of immutable data
Defining records
The Canonical constructor
Compact constructors
12. Java Packages and Visibility
Use the package keyword to define a class within a specific package
Discuss levels of accessibility/visibility
Using the import keyword to declare references to classes in a specific package
Using the standard type naming conventions
Visibility in the Java Modular System
Correctly executing a Java application class
The Java Modular System
Defining Modules
13. Utility Classes
Introduce the wrapper classes
Explain Autoboxing and Unboxing
Converting String representations of primitive numbers into their primitive types
Defining Enumerations
Using static imports
Deprecating classes and methods
Object Oriented Development 
14. Inheritance and Polymorphism
Write a subclass with a method that overrides a method in the superclass
Group objects by their common supertype
Utilize polymorphism
Cast a supertype reference to a valid subtype reference
Use the final keyword on methods and classes to prevent overriding
15. Interfaces and Abstract Classes
Define supertype contracts using abstract classes
Implement concrete classes based on abstract classes
Define supertype contracts using interfaces
Implement concrete classes based on interfaces
Explain advantage of interfaces over abstract classes
Explain advantage of abstract classes over interfaces
Exception Handling
16. Introduction to Exception Handling
Introduce the Exception architecture
Defining a try/catch blocks
Checked vs Unchecked exceptions
17. Exceptions
Defining your own application exceptions
Automatic closure of resources
Suppressed exceptions
Handling multiple exceptions in one catch
Enhanced try-with-resources
Helpful NullPointerException(s)
Advanced Java Programming 
18. Building Java Applications
Explain the steps involved in building applications
Define the build process
Introduce build scripts
Explain the standard folder layout
Resolving project dependencies
Tutorial: Importing code Using Maven
19. Introduction to Generics
Generics and Subtyping
Bounded Wildcards
Generic Methods
Legacy Calls To Generics
When Generics Should Be Used
20. Introducing Lambda Expressions and Functional Interfaces
Understanding the concept of functional programming
Understanding functional interfaces
Lambda's and type inference
21. Working with Lambda Expressions
Writing lambda expressions
Explore the difference between anonymous classes and lambda expressions
Consumer, Predicate and Function interfaces
Working with Collections 
22. Collections
Provide an overview of the Collection API
Review the different collection implementations (Set, List and Queue)
Explore how generics are used with collections
Examine iterators for working with collections
23. Using Collections
Collection Sorting
Using the Right Collection
Lambda expressions in Collections
Bonus Topics / Time Permitting
These topics will be included in your course materials but may or may not be presented during the live class depending on the pace of the course and attendee skill level and participation.
24. Sealed Classes
Introduce sealed classes
The sealed and permits modifier
Sealed interfaces
Sealed classes and pattern matching
25. Streams
Understanding the problem with collections in Java
Thinking of program solutions in a declarative way
Use the Stream API to process collections of data
Understand the difference between intermediate and terminal stream operations
Filtering elements from a Stream
Finding element(s) within a Stream
Collecting the elements from a Stream into a List
26. Collectors
Using different ways to collect the items from a Stream
Grouping elements within a stream
Gathering statistics about numeric property of elements in a stream

Course Materials

Course Materials: Each participant will receive a Student Guide with course notes, code samples, software tutorials, step-by-step written lab instructions, diagrams and related reference materials and resource links. Students will also receive the project files (or code, if applicable) and solutions required for the hands-on work.

Hands-on Setup Made Simple! Our dedicated tech team will work with you to ensure our ‘easy-access’ cloud-based or local installtion course environment is accessible, fully-tested and verified as ready to go well in advance of the course start date, ensuring a smooth start to class and effective learning experience for all participants. Please inquire for details and options.

Every-Course Extras = High-Value & Long-Term Learning Support! All courses also include our unique EveryCourse Extras package (Post-Course Resource Site access, Review Labs, Live Instructor Follow-on Support, Free *Live* Course Refresh Re-Takes, early access to Special Offers, Free Courses & more).

Raise the bar for advancing technology skills

Attend a Class!

Live scheduled classes are listed below or browse our full course catalog anytime

Special Offers

We regulary offer discounts for individuals, groups and corporate teams. Contact us

Custom Team Training

Check out custom training solutions planned around your unique needs and skills.

EveryCourse Extras

Exclusive materials, ongoing support and a free live course refresh with every class.

Attend a Course

Please see the current upcoming available open enrollment course dates posted below. Please feel free to Register Online below, or call 844-475-4559 toll free to connect with our Registrar for assistance. If you need additional date options, please contact us for scheduling.

Course Title Days Date Time Price
Fast Track to Core Java 17 Programming for OO Developers (TT2104) 4 Days Oct 16 to Oct 19 10:00 AM to 06:00 PM EST $2,395.00 Enroll
Fast Track to Core Java 17 Programming for OO Developers (TT2104) 4 Days Dec 4 to Dec 7 10:00 AM to 06:00 PM EST $2,395.00 Enroll
Fast Track to Core Java 17 Programming for OO Developers (TT2104) 4 Days Jan 16 to Jan 19 10:00 AM to 06:00 PM EST $2,395.00 Enroll
Fast Track to Core Java 17 Programming for OO Developers (TT2104) 4 Days Mar 26 to Mar 29 10:00 AM to 06:00 PM EST $2,395.00 Enroll
Fast Track to Core Java 17 Programming for OO Developers (TT2104) 4 Days May 14 to May 17 10:00 AM to 06:00 PM EST $2,395.00 Enroll

Mix, Match & Master!
2FOR1: Two Courses, One Price!

Enroll in *any* two public courses (for 2023 *OR* 2024 dates!) by October 31, for one price!  Learn something new, or share the promo!

Click for Details & Additional Offers

Learn. Explore. Advance!

Extend your training investment! Recorded sessions, free re-sits and after course support included with Every Course
Trivera MiniCamps
Gain the skills you need with less time in the classroom with our short course, live-online hands-on events
Trivera QuickSkills: Free Courses and Webinars
Training on us! Keep your skills current with free live events, courses & webinars
Trivera AfterCourse: Coaching and Support
Expert level after-training support to help organizations put new training skills into practice on the job

The voices of our customers speak volumes

Special Offers
Limited Offer for most courses.

SAVE 50%

Learn More