Foundational Java

Foundational Java

Unlock Core Skills in 3 Days (or 6 x half days)

From Syntax to Spring: Rapid, Real-world Java for Industry Professionals

Java isn't going anywhere. It's still the backbone of enterprise apps, microservices, and backend systems that actually need to work under pressure. This three-day course cuts through the noise and teaches you the Java skills that matter in real production environments: core syntax and OOP fundamentals, build tools, concurrency, modern APIs, and the frameworks teams actually use day to day. With 30+ years in the trenches, the instructor focuses on how Java works in actual projects, not textbook examples. By the end, you'll know how to write, build, test, and ship Java code the right way.

Learning Outcomes

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

• Write Java programs that use basic syntax: variables, control flow (if/else, loops), methods/functions and simple I/O.
• Set up and use a Java IDE (such as IntelliJ IDEA, Eclipse or VS Code) and build tools (Maven or Gradle) plus version control via Git.
• Understand and apply object-oriented programming (OOP) concepts: classes, objects, inheritance, polymorphism, encapsulation, interfaces, and design basics.
• Use standard Java APIs (collections, streams, java.time, etc.), manage exceptions effectively, write simple lambda expressions and understand multithreading basics.
• Build a small service-style application using the Spring Framework (e.g., Spring Boot), integrate data persistence using Java Persistence API (JPA), and write unit tests using JUnit (or equivalent).
• Independently code simple Java programs, use build and dependency management tools, and have a foundation to extend into more advanced Java development.

Prerequisites

• Basic understanding of programming concepts (variables, functions, control flow) in any language.
• A computer/laptop with Java SE (e.g., JDK 17 or later) installed and permissions to install software.
• Internet connectivity to download dependencies, libraries and frameworks.
• Optional but helpful: prior exposure to version control (Git) and a relational database (for persistence).

Detailed Training Outline

Below is the full outline of topics and sub-topics that will be covered over the three days. Each day builds on the previous, taking you from syntax and tooling all the way to framework integration and concurrency.

Fundamentals and Tooling

• Introduction to Java environment
  • JDK installation and versioning (JDK 17+ or later), note that modern Java continues to evolve (e.g., features in recent releases such as virtual threads, structured concurrency)
  • Setting up an IDE (IntelliJ, Eclipse, VS Code), configuring the project, compiling and running a simple “Hello World” program.
  • Discuss folder/project structure, package naming, simple command-line compilation/IDE run.
• Basic Java syntax
  • Variables, data types (primitive types, wrappers, String), literals, constants.
  • Operators: arithmetic, relational, logical, bitwise.
  • Control flow: if-else, switch (including modern switch enhancements), loops (for, enhanced for, while, do-while).
  • Methods (functions): declaration, arguments, return types, scope, overloading.
  • Basic I/O and simple exception handling: try-catch, finally, throws.
• Working in the IDE / simple program creation
  • Create small console applications: e.g., compute factorial, iterate collections, simple input/output from console.
  • Using IDE features: debugging, breakpoints, stepping through code, inspecting variables.
• Version control and build tools
  • Git basics: repository init/cloning, commit, branch, merge, push/pull (remote repository concept).
  • Build tools introduction: Maven vs Gradle – project structure, dependency declaration, build lifecycle.
  • Hands-on: create project using Maven (pom.xml) or Gradle (build.gradle), add a dependency (e.g., JUnit) and build/compile/run tests.
  • Best practices: dependencies, plugin use, project modularity.

Object-Oriented Programming and Standard APIs

• Deep dive into OOP with Java
  • Classes and objects: fields, constructors, methods.
  • Encapsulation (private/protected/public), getters/setters.
  • Inheritance: extends, super, method overriding.
  • Polymorphism, abstract classes, interfaces, default/static methods in interfaces.
  • Composition vs inheritance; design-thinking for simpler, maintainable code.
• Java standard APIs and modern language features
  • Collections framework: List, Set, Map; working with generics; iteration, traversal.
  • Java 8+ features: Lambda expressions, functional interfaces, streams, method references.
  • Date/Time API (java.time), optional, typesafe handling.
  • Exception handling best practices: checked vs unchecked exceptions, custom exceptions, resource-management (try-with-resources).
  • Introduction to concurrency: threads, Runnable/Callable, simple synchronization; note modern enhancements in Java around virtual threads and structured concurrency.
• Hands-on coding and small project
  • Build a small application that uses collections + streams + lambdas (e.g., filter/process a list of objects).
  • Add exception handling and thread example (spawn simple threads, show synchronization issues and how to avoid them).
• Build and run with the tools
  • Integrate the application into the Maven/Gradle build.
  • Use Git to track code changes, revert, branch for feature work, merge back.

Frameworks, Persistence, Testing & Deployment Readiness

• Introduction to Spring Framework and Spring Boot
  • What is Spring, what problems does it solve (dependency injection, inversion of control).
  • Setting up a Spring Boot project (e.g., with Spring Initializr), key annotations (@SpringBootApplication, @Component, @Service, @Repository, @RestController).
  • Building REST endpoints, wiring components, basic configuration.
• Persistence with JPA (Java Persistence API)
  • What is JPA, how it integrates with Spring.
  • Entities: @Entity, @Id, fields, relationships (one-to-many, many-to-one).
  • Spring Data JPA repositories, CRUD operations, custom queries.
  • Database setup: in-memory (H2) or light SQL for demo purposes.
• Unit testing and integration testing with JUnit
  • Writing tests with JUnit (setup, teardown, assertions).
  • Testing Spring components (context-loading test, mock beans).
  • Test-first thinking, test coverage, continuous integration readiness.
• Threads, concurrency in framework context
  • Apply threading concepts in a Spring context: e.g., asynchronous methods (@Async), task executors.
  • Exception handling in multi-threaded applications.
• Build tool advanced features, deployment readiness
  • Using Maven/Gradle for packaging (jar/war), dependency scopes, plugin usage (e.g., Spring Boot Maven plugin).
  • Build profiles (development vs production), build reproducibility (recent concerns about build integrity in Java ecosystem).
  • Git best practices in team/enterprise context (branching models, pull requests, code reviews).
• Final hands-on: small end-to-end application
  • Using Spring Boot + JPA + REST endpoints + unit tests + build tool + Git version control.
  • Deploy/run locally, test endpoints, simulate multi-threaded access (e.g., concurrent requests).
• Review, next steps, branching into advanced topics
  • Discussion of modern Java features (JDK 25, virtual threads, structured concurrency) and why staying current matters.
  • How to continue: microservices, reactive programming, cloud/deployment, scaling.
  • Q&A, wrap-up, resources for further learning.

This three-day intensive will give you hands-on confidence in writing Java code, using the tools and frameworks that matter in industry, and understanding the architecture of a simple Java-powered system. With the instructor’s extensive industry background, you’ll get insights drawn from real projects — not just textbook examples.