TT2100: Introduction to Core Java 21 Programming Developers Workshop
About this Course
The Core Java Programming Developer’s Workshop is a five-day, hands-on training program designed to help developers with prior programming experience transition to Java with confidence. This lab-intensive course focuses on building practical skills in writing efficient, maintainable, and scalable Java applications. You’ll learn to design robust object-oriented systems, manage program complexity, and apply advanced techniques to streamline development and boost performance.
Guided by experienced Java professionals, you’ll develop expertise in structuring and optimizing code, debugging real-world issues, and leveraging modern programming features introduced in Java 21. Hands-on labs will deepen your understanding of essential skills like handling exceptions, implementing reusable code, managing application dependencies, and using tools like IntelliJ IDE to enhance productivity. The course emphasizes adapting your existing programming knowledge to Java’s unique capabilities, preparing you to solve real-world challenges effectively.
By the end of the workshop, you’ll have the confidence to work on Java or Full Stack projects across versions 8, 11, 17, and 21, from enterprise systems to innovative applications. This course equips you with practical, job-ready skills to excel in Java development and make an immediate impact in today’s fast-paced software landscape.
NOTE: All of our Java courses are available in a variety or Java versions, IDEs and tools. Please inquire for details and options. Also, if you are new or newer to programming, please consider our TT2000 Gentle Introduction to Programming, OO and Java Basics as an alternative course.
Audience Profile
The ideal audience for this introductory-level course includes experienced developers with a background in another programming language, who are new to Java and eager to expand their expertise. Participants should have a basic understanding of programming concepts. This course is not for non-developers. Please contact us for details so we can assist you in choosing if this is the right course for you.
At Course Completion
This course is rich with hands-on activities and examples, combining robust real-world hands-on labs with expert instruction, engaging activities and group discussions and review. You'll learn and practice new skills under the guidance of our expert instructor, who will prepare you to apply these in the job, role or project with confidence.
Working in a hands-on learning environment led by our expert instructor you will explore:
Object-Oriented Programming (OOP): Grasp the fundamentals of OO programming and understand its advantages in modern software development.
Java Language Essentials: Learn the core concepts, strengths, and weaknesses of the Java language, and how it relates to the OO programming paradigm and the Object Model.
Exception Handling: Master Java's exception handling mechanisms.
Modular System (Project Jigsaw): Work with Java's modular system to better structure and maintain applications.
Key OO Concepts: Use classes, inheritance, and polymorphism effectively.
Advanced Language Features: Explore collections, generics, autoboxing, enumerations, and data processing using Lambda expressions and the Stream API.
Interface Features: Implement abstract, static, and private methods in interfaces.
Modern Java Enhancements: Dive into newer features such as switch expressions, text blocks, pattern matching for instanceof, and the introduction of records for immutable data handling.
Java Tooling: Utilize the comprehensive set of tools available within the programming environment for Java development.
Java 21 Feature: Pattern Matching in Switch: This feature allows type checks and object deconstruction directly within a switch, simplifying complex conditional logic and reducing boilerplate code.
Java 21 Feature: Record Patterns: Record patterns enable concise deconstruction of records in switch expressions or other patterns, streamlining immutable data handling with fewer lines of code.
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.
Outline
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. Topics, agenda and labs may adjust during live delivery based on audience skill-level, needs and participation.
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
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
Documentation and Code Reuse
3. Using the IntelliJ IDE
Introduce the IntelliJ IDE
The Basics of the IntelliJ interface
IntelliJ Projects and Modules
Creating and running Java applications
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
Introducing annotations
Deprecating classes and methods
6. Object-Oriented Programming
Real-World Objects
Classes and Objects
Object Behavior
Methods and Messages
7. Language Statements
Arithmetic operators
Operators to increment and decrement numbers
Comparison operators
Logical operators
Return type of comparison and logical operators
Use for loops
Switch Expressions
Switch Expressions and yield
8. 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
9. 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
10. 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
Overriding subclass methods
Pattern matching for instanceof
Safely casting references to a more refined type
11. Using Arrays
Declaring an array reference
Allocating an array
Initializing the entries in an array
Writing methods with a variable number of arguments
12. Records
Data objects in Java
Introduce records as carrier of immutable data
Defining records
The Canonical constructor
Compact constructors
13. 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
Introduce the Java Modular System
Visibility in the Java Modular System
14. 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
Introduce the Date/Time API
LocalDate / LocalDateTime etc.
Apply text formatting
Using System.out.printf
15. 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
16. 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
17. Sealed Classes
Introduce sealed classes
The sealed and permits modifier
Sealed interfaces
Sealed classes and pattern matching
18. Pattern Matching
Pattern Matching in switch statements
Pattern Matching and sealed classes
Record Patterns
19. Introduction to Exception Handling
Introduce the Exception architecture
Defining a try/catch blocks
Checked vs Unchecked exceptions
20. 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)
21. 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
22. Introduction to Generics
Generics and Subtyping
Bounded Wildcards
Generic Methods
23. Introducing Lambda Expressions and Functional Interfaces
Understanding the concept of functional programming
Understanding functional interfaces
Lambda's and type inference
24. 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
Sequenced Collections
25. Using Collections
Collection Sorting
Comparators
Using the Right Collection
Lambda expressions in Collections
Sequenced Sets
26. 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
27. 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
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.
28. Introduction to Annotations
Discuss how annotations work in Java
Understand what is required to work with Java's annotations
Use annotations
Other technologies that are using annotations
29. Java Data Access JDBC API
Connecting to a database using JDBC
Executing a statement against a database that returns a ResultSet
Setting up and working with PreparedStatements
Extracting multiple rows of data from a ResultSet
Inserting, updating and deleting rows in a table
Prerequisites
In order to gain the most from this course, you should currently in a technical role and have some prior hands-on experience with basic programming constructs from another object oriented languages, like C# or C++.
You should have the following incoming skills:
Basic Programming Knowledge: Familiarity with core programming concepts such as variables, loops, conditionals, and functions, gained from experience with any programming language.
Understanding of Technical Workflows: Ability to use command-line tools, navigate file structures, and set up development environments.
Alternative Courses
If you are new to programming, or coming from basic scripting skills or a non-OO language (like C or COBOL), we recommend taking the Getting Started with Programming, OO & Java Basics for Non-Developers (TT2000) course instead to refresh or enhance your OO basics skills while learning Java. Please see the Related Courses section for alternative paths.