Programming & Development
Java
Learn Java for enterprise applications, Android development, and backend systems, using modern Java practices.
Prerequisites
No prior experience required — open to beginners.
Certificate
Awarded by Rescue Academy on successful completion of the program's assessments and final project.
Learn Online — Live Classes
Register, receive your schedule, and join live instructor-led Java classes on Zoom. Assignments, instructor feedback, and a certificate on completion.
Learn In Person
Attend Java classes in person in Juba with hands-on labs, instructor mentorship, and a certificate on completion.
What You'll Learn
- Syntax, variables, and strongly-typed data
- Control flow, methods, arrays and Strings
- Object-oriented programming: classes, inheritance, interfaces, polymorphism
- Collections, exceptions and file input/output
- Maven builds and unit testing with JUnit 5
- Generics, lambdas, streams and modern Java features
- Databases with JDBC, HTTP and JSON, and REST APIs with Spring Boot
Program Objectives
- Write clear, correct Java programs using modern language features
- Design object-oriented applications with interfaces, collections and exceptions
- Build, test and package projects with Maven and JUnit
- Store data in relational databases and work with web APIs and JSON
- Deliver a tested back-end REST service with Spring Boot
Who It's For
- Beginners who want a structured path into software development
- Students preparing for university computer science or software courses
- Developers in other languages who need Java for back-end or Android work
Where You'll Use It
- Back-end services and APIs for banks, telecoms, NGOs and government systems
- Business applications that manage records, stock, payments or appointments
- A foundation for Android app development
Curriculum
Instructor-led, practical training. Each level is a block of 4, 8 or 12 weeks; every module ends with a practical activity and an assessment, and every level with a project.
Module 1: Java Setup and First Programs 10 h
Install the tools, understand how Java code becomes a running program, and write programs that store and print values. 3 lessons
Module 2: Decisions, Loops and Methods in Java 11 h
Control the flow of a program with conditions and loops, read input with Scanner, and organise code into reusable methods. 3 lessons
Module 3: Arrays, Strings and ArrayList 10 h
Store many values in arrays and ArrayLists, process them with loops, and work with text using String methods. 3 lessons
Module 4: Classes and Objects in Java 11 h
Model real things as classes with fields, constructors and methods, and protect data with encapsulation. 3 lessons
Module 5: Console Application Project in Java 10 h
Plan and build a complete console application from requirements, using classes, collections, methods and input validation. 3 lessons
Level project: Shop Sales Recorder (console)
Module 1: Inheritance, Interfaces and Polymorphism 15 h
Reuse and extend code with inheritance, define contracts with interfaces and abstract classes, and write code that works with many types through polymorphism. 3 lessons
Module 2: The Java Collections Framework 16 h
Use List, Set and Map effectively, sort data with Comparable and Comparator, and understand equals and hashCode. 3 lessons
Module 3: Exceptions and File Input/Output in Java 16 h
Handle errors deliberately with exceptions, create your own exception types and read and write text and CSV files with java.nio.file. 3 lessons
Module 4: Packages and Builds with Maven 13 h
Organise code into packages with sensible access levels, and build, test and package projects with Maven. 3 lessons
Module 5: Unit Testing with JUnit 5 13 h
Write automated tests that check your code's behaviour, including edge cases and exceptions, and use them to fix bugs safely. 3 lessons
Module 6: Intermediate Java Project 17 h
Build the Community Library Loans System from design to tested, packaged application, applying every skill from this level. 3 lessons
Level project: Community Library Loans System
Module 1: Generics, Lambdas and Streams 22 h
Write reusable, type-safe code with generics, and process collections declaratively with lambdas and the Stream API. 4 lessons
Module 2: Modern Java Language and Design 20 h
Use records, enums and sealed types, design with immutability and SOLID principles, apply common patterns, and use concurrency safely. 4 lessons
Module 3: Databases with JDBC 24 h
Design a relational schema, access it from Java with JDBC and prepared statements, and keep data consistent with transactions. 4 lessons
Module 4: HTTP Clients and JSON in Java 20 h
Call web APIs with Java's HttpClient, convert between JSON and Java objects with Jackson, and handle slow or failing networks. 4 lessons
Module 5: REST APIs with Spring Boot 24 h
Build REST services with Spring Boot: controllers, services, data access, validation, error handling and tests. 4 lessons
Module 6: Java Capstone Project 30 h
Design, build, test, document and present the Clinic Appointment REST Service as a professional back-end project. 5 lessons
Level project: Clinic Appointment REST Service
Final practical project
Clinic Appointment REST Service
A Spring Boot back-end that manages patients and appointments for a small clinic, with database storage, validation, error handling, automated tests and documentation.
Deliverables
- Source code in a Git repository with a README
- REST endpoints for patients and appointments with documented examples
- Database schema and sample data using invented records
- Unit and integration test suite that passes from a clean checkout
Assessed on
- All user stories work through the API and follow the agreed contract
- Business rules such as no double booking are enforced and tested
- Database access is parameterised and transactional where needed
- The project builds, tests and runs from the README instructions
Worked Examples
A selection of the visual, practical examples used in this program's lessons — each teaches a different skill.
- Code example Weekly sales report with arrays Total, average and best day from a week of shop sales, using two parallel arrays and one loop. Beginner · Module 3 · Lesson 1
- Code example Ranking students with a Comparator chain Sort by average mark, highest first, and break ties alphabetically by name in one readable statement. Intermediate · Module 2 · Lesson 2
- Troubleshooting tree Which Java exception is this, and what should I do? From the first line of a stack trace to the right response: fix the code, handle the input, or handle the environment. Intermediate · Module 3 · Lesson 1
- Workflow What happens when you run mvn package The Maven build phases that run, in order, every time you package an application. Intermediate · Module 4 · Lesson 3
- Code example Sales per region with streams and groupingBy Group sales by region, total them in sorted order and find the top region — without writing a single loop. Advanced · Module 1 · Lesson 4
- Step-by-step Saving a patient safely with JDBC The sequence for one database write: configuration, connection, parameterised SQL, transaction and clean-up. Advanced · Module 3 · Lesson 2
Free Course: Java Starter
A free introduction to Java: setting up, writing your first class, control flow and methods, arrays and collections, and the basics of object-oriented programming. Free, self-study, about 6 hours — no certificate. The full program above is taught live by an instructor, with practical assignments, assessments and a certificate.
- 1Free lesson 1Java Fundamentals & Setup
- 2Free lesson 2Control Flow & Methods
- 3Free lesson 3Arrays & Basic Collections
- 4Free lesson 4Object-Oriented Programming Basics
- 5Free lesson 5Problem Solving with Java
- Final checkQuick Quiz — Java Basics
Tools & Technologies
Primary Tools
- JDK (Java 21 LTS or newer) — The Java Development Kit — compiling and running every program in this course Practice: Core language fundamentals through modern Java features
- IntelliJ IDEA — The IDE used throughout the program, including the debugger and code generation Practice: Writing, running, debugging and refactoring Java projects
- Maven — The build tool introduced at Intermediate level for dependencies, tests and packaging Practice: Building, testing and packaging multi-package projects
Supporting Tools
- JUnit 5 — Automated unit testing from Intermediate level onwards Practice: Writing tests for rules, edge cases and exceptions
- Git — Version control for every project Practice: Committing, branching and sharing code
- H2 or PostgreSQL — Relational databases used in the JDBC and Spring Boot modules Practice: Designing schemas and running parameterised queries
Professional / Industry Tools
- Spring Boot — The framework used to build REST APIs in the Advanced level and capstone Practice: Controllers, services, validation, error handling and API tests
- Jackson — JSON processing when calling and building web APIs Practice: Mapping JSON to Java records and back
Career Opportunities
- Junior Java / backend developer
- Android application developer (foundation)
- IT/software role in an enterprise, bank, or government office
- Freelance developer for local businesses and NGOs
Practical Projects
- Build a console or simple GUI application that models a real business process (e.g. enrollment or inventory)
- Build a small JDBC-backed application with a JUnit test suite
- Refactor a class to use an interface instead of inheritance where two unrelated classes need to share one behavior, and write JUnit tests confirming both implementations work
Problem-Solving Focus
Problem: A program compiles fine but throws a NullPointerException at runtime with a confusing stack trace
Approach: Read the stack trace from the top down to find the exact line and object that was null, then add defensive checks or Optional where a value might legitimately be absent.
Problem: Two classes need to share behavior, but rigid single inheritance makes it awkward to reuse code across unrelated class hierarchies
Approach: Use interfaces to define a shared behavior contract instead of forcing an inheritance relationship that doesn't actually make sense.
Problem: A collection-heavy program runs correctly but performs poorly at scale because the wrong collection type was chosen
Approach: Choose the collection type based on real usage patterns — frequent lookups favor HashMap, ordered iteration favors ArrayList, uniqueness favors HashSet — instead of defaulting to ArrayList for everything.
Problem: A class's behavior changes, and it's unclear whether existing functionality broke as a result
Approach: Write JUnit tests for the class's public behavior before refactoring, so a broken test catches the regression immediately instead of a user finding it later.
Ready to register for Java?
Register — Learn Online Register — Learn In Person WhatsApp: +211926196668 Email: rescueacademy26@gmail.com