Java SE 25: Programming I

This entry-level course introduces programmers to Java concepts, language constructs, and data types. It covers exception handling, lambda expressions, and modular programming, with a focus on developing programs using the latest major versions of the JDK. Learners will practice skills through hands-on labs in each lesson.

Prerequisites

It is recommended that learners have previously studied programming languages or have existing knowledge of Java programming.

Target audience

This course is designed for:

• Developer
• Implementer
• System Integrator
• Systems Administrator

By the end of this course, learners will be able to:

• Write Java code that uses variables, arrays, conditional, and loop constructs to achieve program objectives
• Identify modular programming principles
• Access and create static fields and methods
• Encapsulate a class using access modifiers and overloaded constructors
• Manipulate numeric, text, and string data using appropriate Java operators
• Set environment variables to allow the Java compiler and runtime executables to function properly
• Create simple Java classes and use object references to access fields and methods in a class
• Demonstrate polymorphism by implementing a Java interface
• Handle a checked exception in a Java application
• Use a predicate lambda expression as the argument to a method
• Define and implement a simple class hierarchy that supports application requirements

Course Introduction

Course goals

Audience

Course structure

Introduction to Java

• What is Java?
• How Java works
• Object-oriented principles
• Classes and objects
• Inheritance
• Java APIs
• Java keywords, reserved words, and special identifiers
• Java naming conventions
• Java basic syntax rules
• Defining a Java class
• Accessing classes across packages
• Implementing encapsulation with access modifiers
• Creating a Java program with main method
• Compiling and executing a Java program
• Comments and documentation
• Code snippets in Javadoc
• External snippets

Primitive Types, Operators, and Flow Control Statements

• Java primitives
• Declaring and initializing primitive variables
• Primitive declarations and initializations: restrictions
• Java operators
• Assignment and arithmetic operators
• Arithmetic operations and type casting
• More mathematical operations
• Binary number representation
• Bitwise logical operators
• Equality, relational, and conditional operators
• Short-circuit evaluation
• Flow control using if/else construct
• Ternary operator
• Flow control using switch construct
• Switch expressions yield a value
• Using JShell (REPL tool)
• JShell commands
• Code snippets

Text, Date, Time, and Numeric Objects

• String initialization and operations
• String indexing
• Mutable text objects
• Text blocks
• Wrapper classes for primitives
• Representing numbers using BigDecimal class
• Method chaining
• Local date and time API
• Instants, durations, and periods
• Zoned date and time
• Representing languages and countries
• Formatting and parsing numeric, date, and time values
• Localizable resources
• Formatting message patterns

Classes and Objects

• UML introduction
• Modelling classes, interactions, and activities
• Designing classes
• Creating objects
• Defining instance variables and methods
• Object creation and access
• Local variables and recursive object reference
• Local variable type inference
• Defining constants
• Static context and access
• Combining static and final
• Other static context use cases
• IntelliJ IDE introduction

Improved Class Design

• Overload methods
• Variable number of arguments
• Defining and reusing constructors
• Access modifiers summary
• Defining encapsulation and immutability
• Constants and immutability
• Enumerations and complex enumerations
• Java memory allocation and cleanup
• Parameter passing

Implement Inheritance and Use Records

• Extending classes
• Object class
• Reusing parent class code through inheritance
• Instantiating classes and accessing objects
• Rules of reference type casting
• Verifying object type before casting
• Pattern matching for instanceof
• Reference code within the current or parent object
• Defining subclass constructors
• Flexible constructor bodies
• Class and object initialization
• Overriding methods and using polymorphism
• Reusing parent class logic in overwritten method
• Defining abstract, final, and sealed classes and methods
• Overriding Object class operations: toString, equals, hashCode
• Comparing string objects
• Java records and custom record constructors
• Record patterns
• Pattern matching for switch
• Factory methods

Interfaces and Generics

• Java interfaces
• Multiple inheritance problem
• Implement interfaces
• Default, private, and static methods in interfaces
• Interface hierarchy
• Default methods inheritance
• Interface as a type
• Functional interfaces
• Generics and their use
• Examples of Java interfaces: Comparable, Comparator, Cloneable
• Composition pattern

Arrays and Loops

• Arrays and their declaration, creation, and initialization
• Multidimensional arrays
• Copying array content
• Arrays class
• Loops and processing arrays by using loops
• Complex for loops
• Embedded loops
• Break and continue

Collections

• Introduction to Java Collection API
• Collection API interfaces and implementation classes
• Creating and managing List, Set, and Deque objects
• Creating and managing HashMap objects
• Iterating through collections
• Sequenced collections
• Other collection behaviours
• Using java.util.Collections class
• Accessing collections concurrently
• Preventing collections corruption
• Legacy collection classes

Nested Classes and Lambda Expressions

• Types of nested classes
• Static nested classes
• Member inner classes
• Local inner classes
• Anonymous inner classes
• Anonymous inner classes and functional interfaces
• Understanding lambda expressions
• Defining lambda expression parameters and body
• Using method references
• Default and static methods in functional interfaces
• Using default and static methods of the Comparator and Predicate interfaces

Java Streams API

• Characteristics of streams
• Creating streams using Stream API
• Stream pipeline processing operations
• Using functional interfaces
• Primitive and bi-argument variants of functional interfaces
• Performing actions, filtering, and mapping with stream pipeline elements
• Joining streams using flatMap
• Other intermediate stream operations
• Custom intermediate stream operations: gatherers
• Short-circuit terminal operations
• Processing streams using count, min, max, sum, average
• Aggregating stream data using reduce
• General logic of the collect operation
• Using basic collectors
• Performing conversion, grouping, or partitioning of stream content
• Mapping and filtering with respect to groups or partitions
• Gatherers
• Parallel stream processing and guidelines
• Restrictions on parallel stream processing
• Spliterator and its characteristics

Exception Handling, Logging, and Debugging

• Using Java Logging API
• Logging method categories
• Guarded logging
• Log writing handling and configuration
• Describing Java exceptions
• Creating custom exceptions
• Throwing and catching exceptions
• Exceptions and the execution flow
• Helpful NullPointerExceptions
• Example throwing unchecked and checked exceptions
• Handling exceptions
• Resource auto-closure and suppressed exceptions
• Handling exception cause
• Java debugger and debugger actions
• Manipulating program data in debug mode
• Validating program logic using assertions
• Program flow with and without exceptions

Exams and assessments

This course will help learners prepare for the Java SE 25 Developer Professional exam which is available separately.

Hands-on learning

Learners practice the skills learned in each lesson through hands-on labs.