3.1 Lesson Outcomes
After completing this lesson, learners will be able to:
- Create Java modules.
- Build service and consumer applications.
- Split Java applications into JARs and modules.
- Apply modern Java APIs.
- Use collection, file, predicate, and string utility methods.
3.2 Overview
Java modularization allows developers to split applications into smaller reusable modules. Modules improve:
- project organization,
- maintainability,
- scalability,
- and application security.
Modern Java versions also introduce new APIs that simplify:
- file handling,
- collection management,
- string manipulation,
- and functional programming.
This lesson introduces learners to practical Java modularization and modern Java API usage.
Understanding modularization is important because enterprise Java systems are commonly built using modular software architecture.
Case Study / Scenario
You are a Java developer working for a South African e-commerce platform. Your manager requests the following:
- Create a modular application using:
- a Service module,
- and a Consumer module.
- Explore modern Java APIs for:
- collections,
- files,
- strings,
- and predicates.
The goal is to create cleaner, scalable, and modular Java applications.
PA0201 — Java Modularization
Java modules organize applications into separate reusable units.
Step 1 — Create Service Module
Directory Structure:
service/
src/service/module-info.java
src/service/com/example/service/MessageService.java
module-info.java
module com.example.service {
exports com.example.service;
}
MessageService.java
package com.example.service;
public class MessageService {
public String getMessage() {
return “Hello from Service!”;
}
}
Step 2 — Create Consumer Module
Directory Structure:
consumer/
src/consumer/module-info.java
src/consumer/com/example/consumer/ConsumerApp.java
module-info.java
module com.example.consumer {
requires com.example.service;
}
ConsumerApp.java
package com.example.consumer;
import com.example.service.MessageService;
public class ConsumerApp {
public static void main(String[] args) {
MessageService service = new MessageService();
System.out.println(service.getMessage());
}
}
Expected Output:
Hello from Service!
Step 3 — Build JARs and Run Modules
Build Service Module:
javac -d out/service
src/service/module-info.java
src/service/com/example/service/MessageService.java
jar –create –file service.jar -C out/service .
Build Consumer Module:
javac -d out/consumer –module-path service.jar
src/consumer/module-info.java
src/consumer/com/example/consumer/ConsumerApp.java
Run Modules:
java –module-path service.jar:out/consumer
–module
com.example.consumer/com.example.consumer.ConsumerApp
Practical Activity
Learners must:
- create modules,
- build service and consumer applications,
- compile modular applications,
- and execute Java modules.
PA0202 — Explore New Java API
Modern Java APIs simplify common programming tasks.
List, Set and Map — copyOf Methods
copyOf() creates unmodifiable copies of collections.
Java Example:
import java.util.List;
import java.util.Set;
import java.util.Map;
public class CollectionCopy {
public static void main(String[] args) {
List names = List.of(“Alice”, “Bob”);
List copyNames = List.copyOf(names);
Set numbers = Set.of(1,2,3);
Set copyNumbers = Set.copyOf(numbers);
Map<String, Integer> scores =
Map.of(“Alice”, 90, “Bob”, 80);
Map<String, Integer> copyScores =
Map.copyOf(scores);
System.out.println(copyNames);
System.out.println(copyNumbers);
System.out.println(copyScores);
}
}
Expected Output:
[Alice, Bob]
[1, 2, 3]
{Alice=90, Bob=80}
Practical Activity
Learners must:
- create collection copies,
- apply copyOf methods,
- and display collection outputs.
Files — readString and writeString Methods
Modern Java simplifies file handling.
Java Example:
import java.nio.file.Files;
import java.nio.file.Path;
public class FileExample {
public static void main(String[] args)
throws Exception {
Path filePath = Path.of(“example.txt”);
Files.writeString(filePath, “Hello File!”);
String content = Files.readString(filePath);
System.out.println(content);
}
}
Expected Output:
Hello File!
Practical Activity
Learners must:
- write text to files,
- read file contents,
- and display file output.
Predicate.not() Method
Predicate.not() reverses conditions.
Java Example:
import java.util.List;
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args) {
List names =
List.of(“Alice”, “”, “Bob”);
names.stream()
.filter(Predicate.not(String::isBlank))
.forEach(System.out::println);
}
}
Expected Output:
Alice
Bob
Practical Activity
Learners must:
- apply Predicate.not(),
- filter collections,
- and display results.
String Utility Methods
Modern Java includes useful string utility methods.
Java Example:
public class StringUtilExample {
public static void main(String[] args) {
String text = “ Hello Java “;
System.out.println(text.strip());
System.out.println(“abc”.repeat(3));
System.out.println(””.isBlank());
}
}
Expected Output:
Hello Java
abcabcabc
true
Practical Activity
Learners must:
- apply strip(),
- apply repeat(),
- apply isBlank(),
- and display outputs.
AK0201 — Principles and Functionalities of Java Modularization
Java Modularization Feature — Function
Modules — Organize applications
exports — Expose packages
requires — Import modules
JAR Files — Package applications
copyOf() — Create unmodifiable collections
readString() — Read file contents
writeString() — Write text to files
Predicate.not() — Reverse conditions
Practical Activity
Learners must:
- explain modularization concepts,
- identify Java API functions,
- and apply modular application structures.
IAC0201 — Expected Results with Modularization in Java are Achieved
Expected Results
- Modules compile and execute successfully.
- Service and Consumer modules communicate correctly.
- JAR files are created successfully.
- Modern Java APIs function correctly.
- File handling and collection methods work successfully.
3.5 Key Notes / Summary
- Java modularization improves application organization.
- Modules use:
exports
and
requires
keywords. - JAR files package Java applications.
- copyOf() creates unmodifiable collections.
- readString() and writeString() simplify file handling.
- Predicate.not() simplifies filtering operations.
- Modern Java APIs improve readability and development speed.