How Java function access modifiers relate to the Java 9 module system

The Java 9 module system has changed the meaning of the access modifiers: the public modifier allows external module access; the protected modifier allows module access of the exported package; the default modifier restricts access to modules of the exported package; the private modifier only allows Declare access within the module.

The relationship between Java function access modifiers and the Java 9 module system

Java 9 introduced the module system, which is A new way to organize and package Java applications. The module system introduces new meaning to the existing access modifiers in the Java language (public, protected, default, and private).

Access modifiers

Access modifiers in Java specify which classes and packages can access the class, field, or method. The four access modifiers are explained as follows:

• public: Accessible to all classes and packages.
• protected: Accessible to all classes and all subclasses in the same package.
• default (also called package-private): Accessible only to classes in the same package.
• private: Accessible only to the class in which the class, field or method is declared.

Module System

The Java 9 module system allows you to organize your code into modules. A module is a collection of compilation units with explicit dependencies and exported packages. The module system enforces encapsulation by establishing dependencies between modules and packages.

Access permission modifiers and module system

In the Java 9 module system, the role of access permission modifiers has changed:

• public: A class, field, or method can be accessed directly from outside the module.
• protected: A class, field, or method can only be accessed directly from within the module or from a module that exports the package.
• default (package-private): The class, field, or method can only be accessed from the module that exported the package.
• private: A class, field, or method can only be accessed from the declaring module.

Practical case

Consider the following example module:

module demo.module {
    exports demo.package;
}

package demo.package;

class MyClass {
    public void publicMethod() { }
    protected void protectedMethod() { }
    void defaultMethod() { }
    private void privateMethod() { }
}

In this example, demo.package package Is exported so other modules can access its public classes, fields, and methods.

• publicMethod is public and can be accessed from any module.
• protectedMethod is protected and can only be accessed from demo.module or a module that imported the demo.package package.
• defaultMethod is the default and can only be accessed from modules that import the demo.package package.
• privateMethod is private and can only be accessed from demo.module.

Conclusion

By understanding the relationship between the Java 9 module system and access modifiers, you can enhance application encapsulation and manage access to your code access.

The above is the detailed content of How Java function access modifiers relate to the Java 9 module system. For more information, please follow other related articles on the PHP Chinese website!