What are the non access modifiers in Java?

List of non-access modifiers in Java: Here, we are going to learn about the non-access modifiers in Java programming language.
Submitted by Preeti Jain, on July 29, 2019

Java non access modifiers

We have 7 non-access modifiers in Java. The name of these non-access modifiers are given below,

native
synchronized
transient
volatile
final
abstract
static

We will learn all the non access modifiers one by one...

1) native

"native" is a keyword which is introduced in java.
"native" is the modifier applicable for methods only but it is not applicable for variable and classes.
The native methods are implemented in some other language like C, C++, etc.
The purpose of the native method is to improve the performance of the system.
We know that the implementation of native methods is available in other languages so we don't need to care about the implementation.

Example: We will see the way of writing native methods

class Native {
    static {
        // Load Native Library
        System.loadLibrary("native library");
    }
    // Native Method Declaration
    public native void display();
}

class Main {
    public static void main(String[] args) {
        Native native = new Native();
        native.display();
    }
}

2) synchronized

"synchronized" is the keyword applicable for methods and block.
"synchronized" keyword is not applicable for classes and variables.
"synchronized" keyword is useful for multithreading if we declare a method as synchronized then at a time only one thread is allowed to operate on an object.

Example:

class SynchronizedDisplay {
    public synchronized void display(String msg) {
        for (int i = 0; i < 2; ++i) {
            System.out.println(msg);
            try {
                Thread.sleep(500);
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
}

class MyThread extends Thread {
    SynchronizedDisplay sd;
    MyThread(SynchronizedDisplay sd) {
        this.sd = sd;
    }
    public void run() {
        sd.display("hi");
    }
}

class SynchronizedClass {
    public static void main(String[] args) {
        SynchronizedDisplay sd1 = new SynchronizedDisplay();
        MyThread mt1 = new MyThread(sd1);
        mt1.start();
        MyThread mt2 = new MyThread(sd1);
        mt2.start();
    }
}

Output

E:\Programs>javac SynchronizedClass.java

E:\Programs>java SynchronizedClass
hi
hi
hi
hi

3) transient

"transient" is a keyword introduced in java.
"transient" is the modifier applicable only for variables.
"transient" is the modifier not applicable for classes and methods.
"transient" is useful for serialization because at the time of serialization if we don't want to save the value of the variable to meet some security constraints.

Example:

Let suppose we have a class named Transient in that class we have two-three data member fname (first name), lname (last name) and address, so the address member declared as transient so its values will not be serialized (i.e. in case of deserialization of an object we will get the default value of address variable and its defined value will be erased).

import java.io.*;
class Serialization implements Serializable {
    public String fname, lname;
    transient String address;

    public Serialization(String fname, String lname, String address) {
        this.fname = fname;
        this.lname = lname;
        this.address = address;
    }
}

public class Deserialization {
    public static void main(String[] args) {
        Serialization serialize = new Serialization("Ronit", "Jain", "Mayur vihar 1");
        try {
            FileOutputStream fos = new FileOutputStream("E:\\Programs\\myjava.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(serialize);
            oos.close();
            fos.close();
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }

        serialize = null;

        try {
            FileInputStream fis = new FileInputStream("E:\\Programs\\myjava.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            serialize = (Serialization) ois.readObject();
            ois.close();
            fis.close();
            System.out.println("His full name and address is :" + serialize.fname + " " + serialize.lname + " " + serialize.address);
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        } catch (ClassNotFoundException ex) {
            System.out.println(ex.getMessage());
        }
    }
}

Output

E:\Programs>javac Deserialization.java

E:\Programs>java Deserialization
His full name and address is :Ronit Jain null

4) volatile

"volatile" is a keyword which is introduced in java.
"volatile" is the modifier applicable only for variables but not for methods and classes.
If the value of variable keep on changing such type of variable we have to declare with the volatile modifier.
Any intermediate operation will be performed in local copy instead of the final copy.

Example:

class VolatileVariable {
    // volatile keyword here makes sure that
    // the changes made in one class are 
    // immediately reflect in other class
    static volatile int volatile_var = 10;
}


class Main {
    public static void main(String[] args) {
        System.out.println("The previous value of volatile variable in one class is " + VolatileVariable.volatile_var);
        VolatileVariable.volatile_var++;
        System.out.println("The value changes made to the volatile variable in other class is" + VolatileVariable.volatile_var);
    }
}

Output

E:\Programs>javac Main.java

E:\Programs>java Main
The previous value of volatile variable in one class is 10
The value changes made to the volatile variable in other class is 11

5) final

"final" is a keyword which is introduced in java.
"final" is the modifier applicable for methods, classes, and variables.
We cannot override in child class.

Example: Declare class as "final" and variable as final and method as final

final class Final {
    final String str = "we are accessible final variable";

    final void printMethod() {
        System.out.println("we are in final method");
    }

    public static void main(String[] args) {
        Final f = new Final();
        System.out.println("final variable :" + f.str);
        f.printMethod();
    }
}

Output

E:\Programs>javac Final.java

E:\Programs>java Final
final variable :we are accessible final variable
we are in final method.

6) abstract

"abstract" is a keyword which is introduced in java.
"abstract" is the modifier applicable for classes and methods.
If a class is abstract then we need to implement all methods of abstract class in our class.

Example:

abstract class AbstractClass {
    abstract void printMethod();
}

public class AbstractImplementation {
    public static void main(String[] args) {
        AbstractClass ac = new AbstractClass() {
            void printMethod() {
                System.out.println("Hi, We are in abstract class");
            }
        };
        ac.printMethod();
    }
}

Output

E:\Programs>javac AbstractImplementation.java
E:\Programs>java AbstractImplementation
Hi, We are in abstract class

7) static

"static" is a keyword introduced in java.
"static" member create one copy of the whole program and share it with other objects of the same program.
"static" can access only static methods.

Example:

class StaticClass {
    public static int div(int a, int b) {
        return a / b;
    }
}

class Main {
    public static void main(String[] args) {
        int p = 20, q = 10;
        int div = StaticClass.div(p, q);
        System.out.println("The div of p , q is" + div);
    }
}

Output

E:\Programs>javac Main.java

E:\Programs>java Main
The div of p , q is2

Comments and Discussions!

Load comments ↻