Introduction to Core Java 21 Programming Developers Workshop

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.

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.

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.

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