Java Module Class

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

The Module class in Java provides a programmatic interface to the module system, allowing interaction with and manipulation of modules at runtime.

Table of Contents

1. What is the Module Class?
2. Creating a Module
3. Adding Module Dependencies
4. Adding Packages to a Module
5. Exposing Packages to Other Modules
6. Common Methods
7. Examples of Using the Module Class
8. Conclusion

1. What is the Module Class?

The Module class represents a module in the Java module system, providing methods to retrieve information about the module, such as its name, packages, and dependencies.

2. Creating a Module

To create a module, organize your code in a directory structure with a module-info.java file that describes the module.

Example Directory Structure:

myproject/
    src/
        com.example.mymodule/
            module-info.java
            com/example/mymodule/MyClass.java

Example module-info.java:

module com.example.mymodule {
    exports com.example.mymodule;
}

3. Adding Module Dependencies

To add dependencies, use the requires directive in module-info.java.

Example:

module com.example.mymodule {
    requires java.sql;
    exports com.example.mymodule;
}

4. Adding Packages to a Module

Use the exports directive in module-info.java to add packages to a module.

Example:

module com.example.mymodule {
    exports com.example.mymodule.utils;
}

5. Exposing Packages to Other Modules

Use the opens directive to allow deep reflection on a package by other modules.

Example:

module com.example.mymodule {
    opens com.example.mymodule.internal to com.example.othermodule;
}

6. Common Methods

• getName(): Returns the name of the module.
• isNamed(): Checks if the module is named.
• getPackages(): Returns a set of package names in the module.
• getDescriptor(): Returns the module descriptor, which contains metadata about the module.
• addOpens(String packageName, Module otherModule): Dynamically opens a package to another module.

7. Examples of Using the Module Class

Example 1: Accessing Module Information

This example demonstrates how to retrieve basic information about a module.

public class ModuleInfoExample {
    public static void main(String[] args) {
        Module module = ModuleInfoExample.class.getModule();

        System.out.println("Module Name: " + module.getName());
        System.out.println("Is Named: " + module.isNamed());
    }
}

Example 2: Retrieving Exported Packages

This example shows how to get the set of packages exported by a module.

public class ExportedPackagesExample {
    public static void main(String[] args) {
        Module module = ExportedPackagesExample.class.getModule();

        System.out.println("Exported Packages: " + module.getPackages());
    }
}

Example 3: Checking Module Dependencies

This example demonstrates how to check the dependencies of a module.

public class ModuleDependenciesExample {
    public static void main(String[] args) {
        Module module = ModuleDependenciesExample.class.getModule();

        module.getDescriptor().requires().forEach(requirement ->
            System.out.println("Required Module: " + requirement.name())
        );
    }
}

Example 4: Using Reflection with Modules

This example shows how to use reflection to access module information.

import java.lang.reflect.Method;

public class ReflectionWithModulesExample {
    public static void main(String[] args) {
        try {
            Module module = Class.forName("java.base/java.lang.Object").getModule();
            System.out.println("Module Name: " + module.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

8. Conclusion

The Module class in Java provides a powerful interface for interacting with the module system, allowing you to access module information, dependencies, and manage packages. This enhances modular application development by improving encapsulation and dependency management.