Course Content
KM-01- Introduction to Java Programming
Module Code: 900102-000-00-KM-01 Credits: 2 Summary: This module introduces learners to the fundamentals of Java programming and basic computing concepts. It builds a strong foundation by covering essential topics such as how computers work, the Java environment, development tools, and core programming principles. Learners are also introduced to version control and the structure of Java programs, preparing them to begin writing, compiling, and managing simple applications.
0/13
KM-02- Principles of Programming with Java
Module Code: 900102-000-00-KM-02 NQF Level : NQF Level 4 Credits: 6 Credits This module builds the learner’s understanding of the principles of programming with the Java programming language. It covers Java program structure, variables, data types, arrays, strings, classes, conditionals, loops, algorithms, exception handling, file systems, multithreading, and the programming life cycle.
0/29
KM-03: Principles of Object-Oriented Programming with Java
his module introduces learners to the core principles and structure of Object-Oriented Programming (OOP) using Java. Learners will explore how object-oriented concepts are used to design scalable, reusable, and maintainable software applications in modern software development environments. The module covers the foundational concepts of OOP, including classes, objects, methods, inheritance, abstraction, encapsulation, polymorphism, aggregation, association, and composition. Learners will also examine the advantages of applying object-oriented principles in real-world software projects and enterprise application development. Through theoretical understanding and contextual programming examples, learners will develop the ability to analyse object-oriented structures, identify relationships between objects, and apply OOP principles to solve programming problems effectively. This module supports learner progression into intermediate and advanced Java development by building strong foundational knowledge required for application development, GUI systems, REST APIs, enterprise systems, and software engineering workflows.
0/4
KM-04- Principles of Intermediate Programming with Java
Module Code: 900102-000-00-KM-04 NQF Level: 4 Credits: 6 Curriculum Title: Java Programmer Curriculum Code: 900102-000-00-00 Module Summary This module focuses on building an understanding of the principles of intermediate programming with Java. Learners are introduced to more advanced Java concepts, including collections, generics, functional programming, concurrency, concurrent collections, and atomic operations.
0/9
KM-05- REST API and Modularization
Module Code: 900102-000-00-KM-05 NQF Level: 4 Credits: 2 Module Summary The main focus of this knowledge module is to build an understanding of the functionalities of REST API and modularization and when to use them. Learners will develop knowledge of REST API concepts, functions, features, and implementation approaches used in Java applications. The module also introduces Java modularization concepts, including module structures, dependency management, encapsulation, and modern Java features such as Local Variable Type Inference, Switch Expressions, Text Blocks, and Records. The module prepares learners to understand modern Java application development practices and modular software design.
0/5
PM-01- Getting Started with Java
Module Code: 900102-000-00-PM-01 NQF Level: 4 Credits: 3 Module Summary The main focus of this practical module is to introduce learners to the practical application of basic computer skills, Java installation and setup, Integrated Development Environments (IDEs), Java class creation, and Git commands. Learners will perform practical activities that involve setting up Java development environments, creating and running Java programs, navigating IDEs, and applying basic source code management practices using Git. The module prepares learners for practical Java software development activities in modern programming environments.
0/10
PM-02- Programming with Java
Module code: 900102-000-00-PM-02 NQF Level: 4 Credits: 8 Module Summary This module introduces learners to practical Java programming skills used in software development. Learners develop the ability to create and run Java programs, work with variables and data types, use arrays and ArrayLists, create and manage classes and objects, and apply core programming concepts such as loops, conditionals, algorithms, exception handling, and multithreading. The module also covers string manipulation, file handling, wrapper classes, and the programming lifecycle used to develop complete software solutions. By the end of the module, learners will be able to design, write, test, and troubleshoot Java applications using structured programming techniques and object-oriented programming principles.
0/44
PM-03- Object-Oriented Programming with Java
Module code: 900102-000-00-PM-03 NQF Level: 4 Credits: 4 Module Summary This practical module introduces learners to Object-Oriented Programming (OOP) using Java. Learners will apply practical Java programming skills to design classes, create objects, apply inheritance, use constructors, manage object state, and develop reusable Java applications. The module focuses on practical implementation of OOP principles including: * encapsulation, * inheritance, * polymorphism, * and abstraction. Learners will also compile, execute, and organize Java programs correctly within Java file systems and directories. The module prepares learners for real-world Java software development environments through hands-on practical activities and problem-solving scenarios.
0/2
PM-04- Intermediate Programming with Java
Module code: 900102-000-00-PM-04 NQF Level: 4 Credits: 6 Module Summary This practical module introduces learners to intermediate Java programming concepts and practical software development techniques using modern Java functionalities. Learners will apply Java collections, generics, functional programming concepts, and concurrency techniques to create efficient and scalable Java applications. The module focuses on practical implementation of: * Java collections and data structures, * generics and type safety, * functional programming using lambda expressions and streams, * and concurrent programming using synchronization and concurrent collections. Learners will develop hands-on Java applications that manage collections, process data functionally, and handle concurrent operations safely within multi-threaded environments. The module prepares learners for real-world Java software development by strengthening problem-solving abilities, improving software performance, and introducing enterprise-level programming techniques commonly used in modern Java applications.
0/8
PM-05- Getting Started with REST API and Modularization
Module code: 900102-000-00-PM-05 NQF Level: 4 Credits: 4 Module Summary This practical module introduces learners to REST API development and Java modularization using modern Java technologies and frameworks. Learners will develop practical skills in connecting Java applications to databases, creating RESTful web services, implementing CRUD operations, and deploying databases using Docker. The module focuses on practical implementation of: * JDBC database connectivity, * REST API development using Java and Spring Boot, * CRUD operations using HTTP methods, * Docker containerization, * Java modularization, * and modern Java APIs. Learners will build practical Java applications that connect to MySQL databases, manage data using REST APIs, split applications into Java modules, and apply modern Java functionalities for cleaner and more scalable code. The module prepares learners for enterprise-level Java software development environments where REST APIs, modular applications, and containerized systems are widely used in modern software engineering.
0/4
PM-06- Keystone Project with Java
Module code:900102-000-00-PM-06 NQF Level: 4 Credits: 8 Module Summary This practical module provides learners with the opportunity to complete a comprehensive Keystone Project using the Java programming language. Learners will apply all the programming knowledge and practical skills acquired throughout the qualification to design, develop, test, and execute real-world Java applications. The module focuses on practical implementation of: * core Java programming, * arrays and objects, * conditions and loops, * GUI development, * game development, * and complete Java application solutions using frameworks and environments of the learner’s choice. Learners will complete practical exercises, build an operable Java game, and develop a contextual GUI-based solution within a selected sector such as: * retail, * healthcare, * IoT, * cloud computing, * mobile development, * or network systems. The module prepares learners for real-world software development environments by strengthening problem-solving abilities, practical development experience, creativity, and application deployment skills using Java technologies and frameworks.
0/6
Java Programmer Skills Programme

📘LESSON 1

3.1 Lesson Outcomes

After completing this lesson, learners will be able to:

  • Explain the purpose of the Java main method.
  • Describe the role of the Java Virtual Machine (JVM).
  • Create a simple Java class declaration.
  • Run Java applications using the main() method.
  • Pass arguments into the main() method.
  • Explain the relationship between Java classes and the JVM.

3.2 Overview

Java applications rely on a structured execution process controlled by the Java Virtual Machine (JVM). Every Java application begins with a class declaration and starts execution from the main() method.

This lesson introduces learners to the structure of Java programs and explains how the JVM processes and executes Java applications. Learners will explore the purpose of Java classes, how the main() method works, and how command-line arguments are passed into Java applications.

These concepts form the foundation of all Java programming and are essential for developing desktop applications, enterprise systems, web applications, Android applications, and cloud-based Java solutions.


KT0101 — A Simple Java Class Declaration

A Java class is a blueprint used to define the structure and behaviour of objects in a Java application.

Every Java program is built using classes. A class contains:

  • variables,
  • methods,
  • constructors,
  • and program logic.

The class keyword is used to declare a Java class.


Structure of a Simple Java Class

 
public class Main {

}
 

Explanation of the Structure

Component Description
public Access modifier allowing access from outside the class
class Keyword used to declare a Java class
Main Name of the class
{} Body of the class containing code

Rules for Java Class Names

Java class names:

  • must begin with a letter,
  • cannot contain spaces,
  • should use PascalCase naming convention,
  • and should clearly describe the purpose of the class.

Examples of valid class names:

  • Student
  • Employee
  • BankAccount
  • ProductManager

Examples of invalid class names:

  • 1Student
  • student name
  • @Class

Importance of Java Classes

Classes help developers:

  • organize code,
  • reuse functionality,
  • simplify maintenance,
  • and build scalable applications.

Without classes, Java applications cannot function properly because Java is a class-based programming language.


Example of a Simple Java Class

 
public class Student {

}
 

KT0102 — The main() Method

The main() method is the starting point of a Java application.

When a Java application runs, the JVM searches for the main() method and starts executing code from that method.

Without the main() method, a Java application cannot start execution normally.


Syntax of the main() Method

 
public static void main(String[] args) {

}
 

Components of the main() Method

Component Purpose
public Allows JVM to access the method
static Allows method execution without creating an object
void Indicates the method does not return a value
main Special method name recognized by JVM
String[] args Stores command-line arguments

Why the main() Method is Important

The main() method:

  • acts as the entry point of the application,
  • controls application startup,
  • and allows developers to execute program instructions.

Every standalone Java application requires a main() method.


Example of the main() Method

 
public class Main {

public static void main(String[] args) {

System.out.println("Java Application Started");
}
}
 

KT0103 — Running the main() Method

Java applications go through two important stages:

  1. Compilation
  2. Execution

The Java compiler converts Java source code into bytecode, and the JVM executes the bytecode.


Steps to Run a Java Program

Step 1 — Write the Java Program

 
public class Main {

public static void main(String[] args) {

System.out.println("Hello World");
}
}
 

Step 2 — Save the File

The file name must match the class name.

Example:

 
Main.java
 

Step 3 — Compile the Program

 
javac Main.java
 

The compiler generates:

 
Main.class
 

Step 4 — Run the Program

 
java Main
 

Output

 
Hello World
 

Role of the JVM During Execution

The JVM:

  • loads Java bytecode,
  • verifies code security,
  • manages memory,
  • and executes Java instructions.

The JVM allows Java applications to run on multiple operating systems.


KT0104 — Passing Arguments to the main() Method

The main() method can receive input values called command-line arguments.

These arguments are passed into the String[] args parameter during execution.


Why Command-Line Arguments are Useful

Command-line arguments allow applications to:

  • receive user input,
  • process external data,
  • and customize execution behaviour.

Example of Passing Arguments

 
public class Main {

public static void main(String[] args) {

System.out.println("Welcome " + args[0]);
}
}
 

Running the Program

 
java Main Bukhosi
 

Output

 
Welcome Bukhosi
 

Multiple Arguments Example

 
public class Main {

public static void main(String[] args) {

System.out.println(args[0]);
System.out.println(args[1]);
}
}
 

Command

 
java Main Java Programming
 

Output

 
Java
Programming
 

KT0105 — The Java Main Class

The main class is the class containing the main() method.

The JVM starts application execution from this class.

Large Java applications may contain many classes, but only one class normally acts as the application entry point.


Characteristics of the Java Main Class

The main class:

  • contains the main() method,
  • controls application startup,
  • coordinates program execution,
  • and may call other classes and methods.

Example of a Java Main Class

 
public class Main {

public static void main(String[] args) {

Student learner = new Student();

learner.study();
}
}
 

Supporting Class Example

 
public class Student {

void study() {

System.out.println("Student is studying");
}
}
 

Real-World Example

In a banking system:

  • Main.java starts the application,
  • Customer.java manages customer data,
  • Account.java manages accounts,
  • Transaction.java processes transactions.

The main class controls the overall application flow.


3.5 Key Notes / Summary

  • Java applications are built using classes.
  • The main() method is the entry point of a Java application.
  • The JVM executes compiled Java bytecode.
  • Java programs must be compiled before execution.
  • Command-line arguments are stored in String[] args.
  • The main class controls application startup and execution.
  • Java supports platform independence through the JVM.
Scroll to Top