IBM Java Developer

Learn the language itself first. You set up a development environment, write programs with types, control flow, methods and arrays, use collections, and handle errors with exceptions.

• The JDK, the JVM and compiling code
• Variables, types and operators
• Conditions, loops and methods
• Arrays and the collections framework
• Strings and text handling
• Exceptions and error handling
• Building a project with Maven

You build A command-line Java program that processes input with collections and error handling.

Java organizes programs around objects. You design classes with encapsulation, build on them with inheritance and interfaces, use polymorphism and generics, and learn when each tool makes code clearer or worse.

• Classes, objects and constructors
• Encapsulation and access control
• Inheritance and method overriding
• Interfaces and abstract classes
• Polymorphism in practice
• Generics
• Composition against inheritance

You build A small class hierarchy modeling a real domain, with interfaces and polymorphic behavior.

Applications read and write data. You work with files and streams, parse structured text, and combine what you know into a complete program that keeps its data between runs.

• Reading and writing text files
• Streams, readers and writers
• The NIO file API
• Parsing CSV and JSON
• Serializing objects
• Structuring a multi-class application

You build A Java application that stores its data in files and reloads it on start.

Most Java services serve the web. You learn enough HTML, CSS and JavaScript to build a simple front end and to understand what a browser sends to and expects from a server.

• HTML structure and forms
• CSS styling and layout
• JavaScript basics
• The browser and the DOM
• HTTP requests and responses
• Calling a back-end API from a page

You build A simple web page that submits a form to a service and shows the response.

Teams and open-source projects run on version control. You commit, branch and merge with Git, and use GitHub for pull requests, issues and contributing to other people’s projects.

• Commits and history
• Branches and merges
• Resolving conflicts
• Pull requests and review
• Forking and contributing to open source
• Organizing a Java repository

You build A Java repository with pull requests and a contribution to another project.

Spring removes the plumbing from enterprise Java. You learn inversion of control and dependency injection, configure beans, and use Spring Boot to build REST services quickly while understanding what it does for you.

• Inversion of control and dependency injection
• Beans, configuration and scopes
• Spring Boot auto-configuration
• REST controllers and request mapping
• Validation and error responses
• Application properties and profiles

You build A Spring Boot REST service with validation and structured error responses.

Applications are only as good as their data layer. You design tables, query with SQL, connect from Java, and use Hibernate to map objects to rows, including relationships and transactions.

• Designing relational tables
• SQL queries and joins
• Connecting with JDBC
• Mapping entities with Hibernate
• Relationships between entities
• Transactions and consistency
• Using Spring Data repositories

You build A Spring application persisting related entities to a relational database.

Java applications now run in containers and clusters. You learn what cloud-native design asks of an application, how microservices and containers fit together, and how agile and DevOps practice shapes delivery.

• Principles of cloud-native applications
• Microservices and their boundaries
• Containerizing a Java application with Docker
• Configuration and statelessness
• Continuous integration and delivery in outline
• Agile and DevOps ways of working

You build A Spring Boot service packaged into a container image and run locally.

Maintainable systems are tested and structured with known patterns. You apply common design patterns, write unit and integration tests, and package and deploy a Java application.

• Creational, structural and behavioral patterns
• Choosing a pattern for a problem
• Unit testing with JUnit
• Mocking dependencies
• Integration tests for a Spring application
• Packaging and deploying the application

You build A tested application that uses two design patterns and deploys from a packaged artifact.

Design, build, test and deploy one Java application. You use objects, Spring, a database and containers together, and describe the design well enough that another developer could continue it.

• Designing the domain and the API
• Building the services and the data layer
• Testing the application
• Packaging and deploying it
• Documenting the design

You build A complete Spring Boot application with a database, tests and a container image.

AI assistants can speed up Java work if you keep control of the result. You use them to draft code, tests and explanations in Java and Spring, check each suggestion, and learn where they tend to go wrong.

• Where generative AI helps a Java developer
• Prompting for Spring code and tests
• Reviewing generated code before use
• Common errors in generated Java
• Security and licensing concerns
• Presenting your projects clearly to others

You build A Spring feature drafted with AI assistance, then reviewed and corrected.