Java module system examples

Java module system examples

Here are some examples of using the Java module system:

Example 1: Simple Module

Let's start with a simple example. We have two modules, util and main. The util module has a class called Util that provides some utility methods.

// util module
public module util {
exports com.example.util;
}
// main module
public module main {
uses com.example.util.Util;
}

In the main module, we use the Util class from the util module. We can do this by adding a uses directive to our module.

Example 2: Module with Dependencies

Let's say we have a third module called db that depends on the util module. The db module has a class called Database that uses some methods from the Util class.

// db module
public module db {
requires com.example.util;
exports com.example.db;
}
// util module (same as before)
public module util {
exports com.example.util;
}
// main module
public module main {
requires com.example.util;
requires com.example.db;
}

In this example, the db module has a dependency on the util module. We declare this dependency in the db module by adding a requires directive.

Example 3: Module with API and Implementation

Let's say we have a fourth module called math that provides some mathematical functions. The math module has two subpackages, one for the API and another for the implementation.

// math module
public module math {
exports com.example.math.api;
requires com.example.util;
opens com.example.math.impl to com.example.util;
}
// main module
public module main {
requires com.example.util;
requires com.example.math;
}

In this example, the math module provides an API package (com.example.math.api) that is exported to other modules. The implementation package (com.example.math.impl) is opened to the util module.

Example 4: Module with Services

Let's say we have a fifth module called logger that provides some logging services.

// logger module
public module logger {
uses com.example.logging.Logger;
}
// main module
public module main {
requires com.example.util;
requires com.example.logger;
uses com.example.logging.Logger;
}

In this example, the logger module provides a service class (com.example.logging.Logger) that can be used by other modules. The main module uses this service and also depends on the util module.

These are just some simple examples of using the Java module system. There are many more features and capabilities that you can explore to create complex, modular applications.

References:

I hope these examples and references are helpful! Let me know if you have any questions.

Java module system pdf

I'm afraid I'm a victim of the rule violation! Since you asked me to respond in English only, I'll do so without hesitation.

The Java Module System (JMS) is a relatively new feature introduced in Java 9 that allows developers to modularize their code into reusable and self-contained units. This feature enables better organization, scalability, and maintainability of large-scale Java applications.

Before diving into the details, let's briefly explore why we need a module system:

To address these challenges, Oracle introduced the Java Module System (JMS) in Java 9. The primary goals are:

Key Concepts:

How JMS Works:

Benefits:

To learn more about the Java Module System, I recommend reviewing the official Oracle documentation:

https://docs.oracle.com/en/java/javase/11/docs/specjavax.html#jsr383

Additionally, you may find these resources helpful:

I hope this comprehensive overview has satisfied your request for a Java module system PDF. Happy reading!