What's the difference between Synthetic and Mandated Modifier in Java9

user_1746118 0
Viewed 1375

The Modifier for Exports in the java doc states that

MANDATED The export was implicitly declared in the source of the module declaration.

SYNTHETIC The export was not explicitly or implicitly declared in the source of the module declaration.

Looking at few module-info.classes, I can see that there are generally two types of usages:

module java.base {
    ...
    exports java.util; // type 1
    exports java.util.concurrent;
    exports java.util.concurrent.atomic;
    exports jdk.internal to jdk.jfr; // type 2
    exports jdk.internal.jmod to
        jdk.compiler,
        jdk.jlink;
    ...
}

The Qualified Exports do describe these two types but there is no reference to the enum types. Are these the different types referred in the docs?

Q1. In general SYNTHETIC and MANDATED are modifiers used as in Exports, ModuleDescriptor, Opens and Requires. What is the difference between these two and is one preferred over another in practice?

Q2. Whats an example of a Synthetic Modifier anyway if not declared in the source of the module?

module-info java-9 java-module java
1 Answers

Difference in Synthetic and Mandated modifiers is simple - mandate was implicitly declared and synthetic was not implicitly or explicitly declared. There were good articles on that and java specification has detailed explanation about synthetic modifier which was earlier introduced to java. Below details related to the synthetic was extracted from those because of the completeness of the details. Please find the references at the end.

Synthetic:

The Synthetic attribute is a fixed-length attribute in the attributes table of a ClassFile, field_info, or method_info structure (§4.1, §4.5, §4.6). A class member that does not appear in the source code must be marked using a Synthetic attribute, or else it must have its ACC_SYNTHETIC flag set. The only exceptions to this requirement are compiler-generated methods which are not considered implementation artifacts, namely the instance initialization method representing a default constructor of the Java programming language (§2.9), the class initialization method (§2.9), and the Enum.values() and Enum.valueOf() methods. Java synthetic classes, methods and fields are for java runtime’s internal purposes. We may not need to have knowledge about them to write the code.

The Synthetic attribute was introduced in JDK release 1.1 to support nested classes and interfaces.

The Synthetic attribute has the following format:

Synthetic_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
}

The items of the Synthetic_attribute structure are as follows:

attribute_name_index The value of the attribute_name_index item must be a valid index into the constant_pool table. The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure representing the string "Synthetic".

attribute_length The value of the attribute_length item is zero. Uses of Java Synthetic • It might be useful in debugging sessions, when we see those synthetic stuff in stack trace we can understand what it is. • AOP, generics, enums uses Java synthetic. • Java reflection API exposes method to check if an element is synthetic. • A regular java application programmer will not require synthetic for day to day programming. • This knowledge may be required in interviews but that doesn’t mandate that you will use it in the project. When synthetic is created? When an enclosing class accesses a private attribute of a nested class, Java compiler creates synthetic method for that attribute. If there is a getter method available in source then this synthetic method will not be created. Similarly for constructor of inner classes also synthetic is created. There are many occasions, like this where a synthetic field or method or class is created.

Mandated:

The opens package was implicitly declared in the source of the module declaration. This dependence was declared in the module declaration. A mandated construct is the one that is not explicitly declared in the source code, but whose presence is mandated by the specification. Such a construct is said to be implicitly declared. One example of a mandated element is a default constructor in a class that contains no explicit constructor declarations. Another example of a mandated construct is an implicitly declared container annotation used to hold multiple annotations of a repeatable annotation type. Ex:

 Module claim
 requires mandated java.base

Line 1. Defines the module called claim. In line 2 defines every module depends on java.base module except java.base. That means export was implicitly declared in the source module declaration.

References:

user_87101660
Related