Software Development
Java Programming Fundamentals
A hands-on introduction to modern Java for developers who need to write production code on Java 17 or 21. Participants work through types, collections, generics, exceptions, streams, Optional, and records until they can read and extend an existing codebase without guessing.
Overview
Practical learning for workplace transfer.
Teams that learn Java from scattered tutorials usually end up writing Java 7 inside a Java 21 runtime: mutable data everywhere, null checks spread through business logic, hand-written loops where a stream belongs, and a build that only works on one machine. This course closes that gap by teaching the language as it is written today. Participants begin with the type system and object model, move through collections, generics and error handling, then finish with records, sealed types, pattern matching and stream pipelines applied to real data-shaping tasks inside a Maven project.
Prerequisites
Basic programming experience in any language. No prior Java knowledge is assumed.
Objectives
- Write, build, and run modern Java applications at the Java 21 language level using Maven.
- Apply the type system, generics, and the collections framework to model data correctly.
- Handle failure with checked and unchecked exceptions, try-with-resources, and clear contracts.
- Transform data with lambdas, stream pipelines, and Optional instead of defensive null checks.
- Model immutable domain data with records, sealed types, and pattern matching in switch.
- Structure a Java project into packages and testable units a team can maintain over years.
Target audience
- Developers moving to Java from another programming language
- Junior software engineers joining an existing Java codebase
- Graduate and trainee engineers on an enterprise onboarding track
- Automation and test engineers who need to read and extend Java code
- Integration engineers working with Java-based enterprise platforms
- Technical support engineers who debug Java applications in the field
Program outline
A clear structure for the learning journey.
Program outline
Outline points are grouped in one designed block instead of being treated as separate module cards.
Module 1: The Java Platform and a Modern Project Setup
JDK, JVM, and bytecode: what actually runs when a Java program starts
The Java 17 and 21 LTS releases and the features each one made standard
Maven project layout, dependency scopes, and a build anyone can reproduce
Running, packaging, and debugging from both the IDE and the command line
Module 2: Types, Objects, and the Class Model
Primitives, wrappers, references, and the hidden cost of autoboxing
Classes, constructors, fields, and encapsulation that holds under change
Interfaces, abstract classes, and default methods compared in practice
Writing equals, hashCode, and toString correctly and consistently
Module 3: Collections, Generics, and Data Modelling
List, Set, Map, and Deque chosen by access pattern rather than by habit
Generics, type parameters, and bounded wildcards in everyday code
Immutable collections, defensive copying, and safe sharing between threads
Comparators, sorting, and the iteration-order guarantees each type makes
Module 4: Errors, Resources, and Failure Contracts
Checked versus unchecked exceptions and what each one communicates to a caller
try-with-resources and deterministic cleanup of files, streams, and connections
Designing exception types that carry usable diagnostic context
Logging, stack traces, and what should never appear inside a catch block
Module 5: Functional Java: Lambdas, Streams, and Optional
Lambdas, method references, and the standard functional interfaces
Stream pipelines: filter, map, flatMap, and the collectors teams actually need
Optional used as a return contract, never as a field or a parameter
When an ordinary loop is clearer, faster, and easier to debug than a stream
Module 6: Records, Sealed Types, and Pattern Matching
Records as immutable data carriers and the members the compiler generates
Sealed interfaces that make a domain's variants explicit and exhaustive
Pattern matching in instanceof and switch, including record patterns
Closing exercise: refactoring a small service to modern Java end to end
Materials provided
- Course workbook, annotated code samples, and reference notes
- Hands-on lab environment and starter repositories
- Exercises, checklists, and reusable code templates
- 4D Certificate of Completion
- Post-course technical guidance
Training Options
Programs can be delivered in-house, online, or in a blended format depending on your team's schedule, location, and learning objectives. When an external certificate or exam is included, certification rules and fees remain under the relevant awarding body's policies, while 4D provides the training and preparation support.
Why choose 4D
4D teaches Java on the release your team actually runs, with your build tooling and a codebase shaped like the one participants return to. Trainers are practising Java engineers, so the exercises target the review comments and maintenance problems that follow beginners into production rather than isolated syntax drills.
Related courses
Python Programming Fundamentals
A hands-on introduction to Python for engineers and analysts who need working code rather than tutorial fragments. Participants build fluency with data types, collections, functions, files, and error handling, then assemble a small program that reads real data and produces a usable report.
View courseIntermediate Python and Clean Code Practices
Designed for developers whose Python works but is difficult to change. The course covers dataclasses, generators, decorators, context managers, and type hints, then applies the refactoring moves that turn a nine-hundred-line module into small tested units guarded by black, ruff, and mypy.
View coursePython Automation and Scripting for Work Tasks
Aimed at teams losing hours every week to repetitive file, spreadsheet, and reporting work. Participants automate those tasks with Python: batch file handling, Excel and CSV processing, REST API calls, email alerts, and scheduled jobs that run unattended and report clearly when something fails.
View course