In this post, you will learn to:
- Define field and method modifiers.
- State the use of volatile modifiers.
- Explain the use of native modifiers.
- Describe the transient modifier and its use.
- List the rules for using access control specifiers.
Field and Method Modifiers
Field and method modifiers are keywords used to identify fields and methods that need to be declared for controlling access to users. Some of these can be used in conjunction with access specifiers, such as public and protected. Java provides the volatile, transient, and native keywords that act as field and method modifiers.
The volatile modifier allows the content of a variable to be synchronized across all running threads.Therefore, when the value of the variable changes or is updated, all threads will reflect the same change. The volatile modifier is applied only to fields. Constructors, methods, classes, and interfaces cannot have this modifier. This modifier is not frequently used. volatile variables are useful in multiprocessor environments and are not frequently used otherwise.
The native modifier is used only with methods and indicates that the implementation of the method is in a language, other than in Java. Constructors, fields, classes, and interfaces cannot have this modifier. The methods declared using the native modifier are called native methods. The Java source file typically contains only the declaration of the native method and not its implementation.
Native methods violate Java’s platform independence feature, and hence must not be used, unless absolutely required. The callers of native methods need not even know that the method was declared in the class, because they invoke the method normally, just as other methods are invoked. Some classes in the Java API have native methods. The Object class, for instance, present in the java.lang package, has many native methods.
The transient modifier is used to declare fields that are not saved or restored as a part of the state of the object. Often, serialization proves to be quite expensive. In such scenarios, the transient keyword reduces the amount of data being serialized, improves performance and reduces costs.
Rules for Using Field Modifiers
Some of the rules for using field modifiers are as follows:
- final fields cannot be volatile.
- native methods in Java cannot have a body.
- Declaring a transient field as static or final should be avoided as far as possible.
- native methods violate Java’s platform independence characteristic. Therefore, they should not be used frequently.