Some Important Modifiers in Java


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

modifier.gif
 

Resources
 

Describing Access Modifiers in Java

Method Parameter Modifiers in C#

New Modifiers in C#

Differentiate Hiding and Overriding

Up Next
    Ebook Download
    View all
    Learn
    View all