Intermediate Java Programming Online – Uganda & East Africa

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this course, the learner will be able to:
• Organise medium-sized Java projects into packages.
• Apply access control and encapsulation effectively.
• Design object-oriented programs using composition, inheritance and polymorphism.
• Use interfaces, abstract classes and nested classes.
• Model data using records, enums and sealed types.
• Create reusable components using Java generics.
• Select and apply appropriate Java collection types.
• Write lambda expressions and use functional interfaces.
• Process collections with the Java Stream API.
• Apply Optional appropriately.
• Work with dates and times using the Java Date-Time API.
• Design and use custom exceptions.
• Read and write files using modern Java I/O.
• Serialise and parse structured program data using appropriate designs.
• Configure Java projects using Maven or Gradle.
• Write automated tests using JUnit.
• Use annotations and introductory reflection.
• apply Git and GitHub in a Java project.
• Refactor Java code using clean-code principles.
• Build a complete intermediate-level Java application.

Modules

1. 1

   Java Fundamentals Review

   Variables and data types.Conditions and loops.Arrays and strings.Methods.Classes and objects.Inheritance and interfaces.Exceptions.Collections.File handling.Identifying knowledge gaps before intermediate programming.
2. 2

   Packages and Project Organisation

   Meaning and purpose of packages.Creating packages.Importing classes.Package naming conventions.Organising source files.Separating application responsibilities.Source and test directories.Avoiding unnecessary dependencies.Structuring medium-sized Java projects.
3. 3

   Access Control and Encapsulation

   Public access.Private access.Protected access.Package-private access.Fields and methods.Immutable object design.Defensive copying.Validating object state.Reducing unnecessary exposure.Designing maintainable class APIs.
4. 4

   Advanced Object-Oriented Programming

   Reviewing inheritance and polymorphism.Composition versus inheritance.Method overriding.Covariant return types.The Object class.Overriding equals.Overriding hashCode.Overriding toString.Object identity and equality.Designing class relationships.Avoiding fragile inheritance structures.
5. 5

   Interfaces and Abstract Design

   Interface contracts.Default interface methods.Static interface methods.Private interface methods.Abstract classes.Template-method concepts.Multiple interface implementation.Dependency inversion principles.Creating replaceable components.Selecting interfaces or abstract classes.
6. 6

   Nested and Inner Classes

   Static nested classes.Inner classes.Local classes.Anonymous classes.Accessing enclosing members.Appropriate uses of nested classes.Replacing some anonymous classes with lambdas.Maintaining readability.
7. 7

   Records, Enums and Sealed Types

   Creating records.Record components.Compact constructors.Record validation.Enum constants.Enum fields and methods.Sealed classes.Sealed interfaces.Permitted subclasses.Modelling controlled hierarchies.Using records and sealed types for data-oriented programming.
8. 8

   Java Generics

   Generic classes.Generic interfaces.Generic methods.Type parameters.Bounded type parameters.Multiple bounds.Wildcards.Upper-bounded wildcards.Lower-bounded wildcards.Generic type inference.Type erasure.Designing reusable generic components.
9. 9

   The Java Collections Framework

   Collection interfaces and implementations.Lists.Sets.Queues.Deques.Maps.Iterators.Comparable.Comparator.Sorting collections.Immutable and unmodifiable collections.Choosing the correct collection type.Understanding collection performance.
10. 10

    Lambda Expressions

    Functional-programming concepts.Lambda syntax.Parameters and return values.Variable capture.Effectively final variables.Method references.Constructor references.Replacing anonymous classes with lambdas.Writing readable lambda expressions.
11. 11

    Functional Interfaces

    Meaning of a functional interface.The @FunctionalInterface annotation.Predicate.Function.Consumer.Supplier.Unary and binary operators.Combining functional interfaces.Creating custom functional interfaces.Using functions as behaviour.
12. 12

    Java Stream API

    Meaning and purpose of streams.Creating streams from collections.Intermediate operations.Terminal operations.Using filter.Using map.Using flatMap.Sorting stream elements.Removing duplicates.Matching and finding elements.Reducing values.Collecting results.Stream pipelines.Avoiding common Stream API mistakes.
13. 13

    Collectors and Data Aggregation

    Collecting into lists and sets.Joining strings.Counting values.Summing and averaging.Grouping data.Partitioning data.Mapping collected values.Creating summary statistics.Multi-level grouping.Designing business reports with collectors.
14. 14

    Optional and Null Handling

    Problems caused by null references.Creating Optional values.Empty and present values.Retrieving optional data.Transforming optional values.Filtering optional values.Providing default values.Throwing exceptions for missing values.Situations where Optional should not be used.Designing clearer return values.
15. 15

    Date and Time API

    Working with dates.Working with times.Date and time combinations.Time zones.Durations.Periods.Parsing dates and times.Formatting dates and times.Comparing temporal values.Calculating schedules and deadlines.Avoiding common date-handling errors.
16. 16

    Advanced Exception Handling

    Checked exceptions.Unchecked exceptions.Creating custom exceptions.Exception propagation.Multi-catch blocks.Try-with-resources.Exception chaining.Designing clear error messages.Recoverable and unrecoverable failures.Avoiding exception misuse.Creating domain-specific error models.
17. 17

    Modern File Handling with NIO

    The Path interface.The Files class.Creating and deleting files.Creating directories.Reading complete files.Reading files line by line.Writing and appending data.Copying and moving files.Listing directory contents.Walking directory trees.File attributes.Safe resource handling.
18. 18

    Intermediate Capstone Project

    Learners will designimplementtest and document a complete Java application.Suggested projects include:SACCO member and savings-management system.Tour booking and quotation engine.School records-processing system.Small-business inventory application.Employee payroll-processing system.Agricultural produce record system.Hotel reservation-management program.Transport route and fare-management system.Clinic appointment-record system.Library lending-management system.