top button
Flag Notify
    Connect to us
      Facebook Login
      Site Registration Why to Join

    Get Free Article Updates

Facebook Login
Site Registration
Print Preview

Java Modifiers

+2 votes

Java Modifiers

Java is a tightly encapsulated language. This means, that no code can be written outside the class. Not even the main() method. However, even within the class, code can become vulnerable to access from external environment. For this purpose, java provides a set of access specifiers such as public , private, protected, and default that help to restrict access to class and class members. However, at time, it is required to further restrict access to the members of a class to prevent modification by unauthorized code. Java provides additional field and method modifiers for this purpose.

Also, in some cases, it may be required to have a common data member that can be shared by all objects of a class as well as other classes. Java provides the concept of class variables and methods to solve this purpose. Classes sharing common attributes and behavior can also be grouped together for better understanding of the application. Java provides packages that can be used to group related classes. Also, the entire set of packages can be combined into a single file called the .jar file for deployment on the target system.

Field and Method Modifiers

 Field and method modifiers are keywords used to identify fields and methods that provide controlled access to users. Some of these can be used in conjunction with access specifiers such as public and protected. The different field modifiers that can be used are as follows:

  • Volatile
  • Native
  • Transient
  • Final


1. ‘volatile’ Modifier

The volatile modifier allows the content of a variable to be synchronized across all running threads. A thread is an independent path of execution of code within a program. Many threads can run concurrently within a program. The volatile modifier is applied only to fields. Constructors, methods, classes, and interfaces cannot use this modifier. The volatile modifiers is not frequently used.

While working with a multi threaded program, the volatile keyword is used. When multiple threads of a program are using the same variable, in general, each thread has its own copy of that variable in the local cache. In such a case, if the value of the variable is updated, it updates the copy in the local cache and not the man variable present in the memory. The other thread using the same variable does not get the updated value.

To avoid this problem, a variable is declared as volatile to indicate that it will not be stored in the local cache.

Also, whenever a thread updates the values of the variable, it is updates the variable present in the main memory. This helps other thread to access the updated value.

For example,

private volatile int testValue;  // volatile variable

2. ‘native’ Modifier

In some cases, it is required to use a method in java program that resides outside JVM. For this purpose, Java provide the native modifier. The native modifier is used only with methods. It indicates that the implementation of the method is in a language other than java such as C or C++. Constructors, fields, classes, and interfaces cannot use 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. In case of the native modifiers, the implementation of the method exists in a library outside the JVM. Before invoking a native method, the library that contains the method implementation must be loaded by making the following system call.


To declare a native method, the method is preceded with the native modifier. Also, the implementation is not provided for the method. For example,

Public native void nativeMethod();

3. ‘transient’ Modifier

When a Java application is executed, the objects are loaded in the Random Access Memory (RAM). However, objects can also be stored in a persistent storage outside the JVM so that it can be used later. This determines the scope and life span of an object. The process of storing an object in a persistent storage is called serialization. For any object to be serialized, the class must implement the Serializable interface.

However, if transient modifier is used with a variable, it will not be stored and will not become part of the object’s persistent state. The transient modifier is useful to prevent security sensitive data from being copied to a source in which no security mechanism has been implemented. Also, transient modifier reduces the amount of data being serialized, improves performance, and reduces costs.

The transient modifier can only be used with instance variable. It informs the JVM not to store the variable when the object, in which it is declared, is serialized. Thus, when the object is stored in persistent storage, the instance variable declared as transient is not persisted.

4. ‘final’ Modifier

The final modifier is used when modification of a class or data members is to be restricted. The final modifier can be used with a variable, method, and class.

A variable declared as final is a constant whose value cannot be modified. A final variable is assigned a value at the time of declaration. A compile time error is raised if a final variable is reassigned a value in a program after its declaration.

final float PI =  3.14;

The variable PI is declared final so that its value cannot be changed later.

A method declared final cannot be overridden or hidden in a java subclass. The reason for using a final method is to prevent subclasses from changing the meaning of the method and increase the efficiency of code by allowing the compiler to turn method calls into inline java code. A final method is commonly used to generate a random constant in a mathematical application.

Code snippet

final float. getCommission (float sales)


System.out.println(“A final method…”);


The method getCommission() can be used to calculate commission based on monthly sales. The implementation of the method cannot be modified by other classes as it is declared as final. A final method cannot be declared abstract. As it cannot be overridden.

Rules and Best Practices 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 held 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.
  • A transient, variable may not be declared as final or static.
posted Aug 19 by Rameshwar Singh

  Promote This Article
Facebook Share Button Twitter Share Button Google+ Share Button LinkedIn Share Button Multiple Social Share Button

Contact Us
+91 9880187415
#280, 3rd floor, 5th Main
6th Sector, HSR Layout
Karnataka INDIA.