Introduction
In this article we are going to describe some important modifiers which are used with method data members etc. We also describe separate examples of each modifier. In Java there are many modifiers used for its various purposes. The following list gives all the modifiers. In the following table some of the modifiers are used very commonly in all languages such as public, protected, static, volatile etc. And most of you know about the use of these common modifiers. So now we describe only three of the modifiers; native, transient and volatile.
Java Modifier Name and Description Table
Modifier Name |
Used on |
Description |
public |
class
interface
member |
Accessible anywhere
|
private |
member |
Accessibilty only in its class (which defines it). |
protected |
member |
Accessibility only within its package and its subclasses |
none |
class
interface
member |
Accessible only in its package |
final |
class
method
field
variable |
Cannot be subclassed
Cannot be overridden and dynamically looked up
Cannot change its value. static final fields are compile-time constants.
Cannot change its value. |
abstract |
class
interface
method |
Contains unimplemented methods and cannot be instantiated.
All interfaces are abstract. Optional in declarations
No body, only signature. The enclosing class is abstract |
static |
class
method
field
initializer |
Make an inner class a top-level class
A class method, invoked through the class name.
A class field, invoked through the class name one instance, regardless of class instances created.
Run when the class is loaded, rather than when an instance is created. |
strictfp |
class
method
field
initializer |
All methods in the class are implicitly strictfp.
All floating-point computation done is strictly conforms to the IEEE 754 standard. All values including intermediate results must be expressed as IEEE float or double values. It is rarely used. |
synchronized |
method |
For a static method, a lock for the class is acquired before executing the method. For a non-static method, a lock for the specific object instance is acquired. |
volatile |
field |
Accessible by unsynchronized threads, very rarely used. |
transient |
field |
Not be serialized with the object, used with object serializations. |
native |
member |
Accessible only in its class(which defins it). |
Native Modifier
The native modifier is used where sometimes we want to use a method that exists outside the JVM. The native keyword indicates that. And this modifier is only applicable to methods. Like the abstract keyword, the native keyword shows that the implementation of this method exists elsewhere. And the native method implementation exists in a library outside of the JVM. All the native methods are implemented in another language such as C or C++. Before a native method can be invoked, a library that contains the method must be loaded and that library is loaded by making the following system call.
Note- System.loadLibrary("libraryName"); This line is used to load the library libraryName loadLibrary() is the method of the System class and this line is written in a static block because all the static blocks are loaded at class loading time. This library will load first of requesting by another run the method of this library.
Example(Scenario)
public class NativeDemo
{
native void NativeMethod();
static
{
System.loadLibrary("NativeMethodLibrary");
}
Transient Modifier
In the Java technology, while any Java program is in a running state, the objects are put in the RAM of the System. That determines the scope and life of the object. However an object may be stored in persistent storage outside the JVM, for later use by the same application or by some another application. The process of storing an object is called serialization. For an object to be serialized, the corresponding class must implement the interface Serialization. Thus, the transient modifier is related to storing an object in persistent storage. Such storage is called the object's persistent state. A variable declared transient is not stored, and hence does not become part of the object's persistent state. So a transient modifier is used to prevent a security-sensitive piece of data from copying to a source where there is no security mechanism exists.
The transient modifier can only be applied to instance variables. When you are declaring an instance variable transient, you are telling the Java Virtual Machine not to store this variable when the object, in which it is declared, is serialized. Thus, when an instance variable is declared as transient, then its value need not persist when an object is stored.
Example
public class TransientDemo implements Serializable
{
// variable will not persist
transient int num1;
// variable will persist
int num2;
}
Volatile Modifier
In the Java language the volatile modifier only applies to instance variables just such as the transient modifier. Those variables declared volatile are part of asynchronous modifications. Thus we can say that, declaring a variable volatile indicates to the compiler that this variable might be changed unexpectedly by other parts of the program. So, the compiler takes some special precautions to keep this variable properly updated; volatile variables are commonly used in multithreaded applications or multiprocessor environments. The volatile modifier indicates to the thread which accesses the volatile member that it should synchronize its private copy of the variable with the original copy in the memory. Consider the following example for the better understanding.
Example
class VolatileDemo extends Thread
{
// declared a volatile variable
private volatile static int someVal;
VolatileDemo(String str)
{
super(str);
}
// implementing the run method for threads
public void run()
{
for (int j=0; j<7; j++)
{
try
{
System.out.println(getName() + "->"+j);
if(getName().equals("Abhishek thread 1"))
{
someVal=101;
}
if(getName().equals("Abhishek thread 2"))
{
System.out.println("The value of volatile variable is :"+someVal);
}
Thread.sleep(1000);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
}
public class VolatileModifierDemo
{
public void main(String args[])
{
// creating a thread object
Thread t1=new VolatileDemo("Abhishek thread 1");
// starting the execution of thread
Thread t2=new VolatileDemo("Abhishek thread 2");
t1.start();
t2.start();
}
}
OUTPUT
Resources
Describing Access Modifiers in Java