Transient variable in Java

A transient variable is a special type of variable which we create by using the transient keyword. It is a special type of variable which have a non-serialized value at the time of serialization. A variable that is initialized by its default value during de-serialization is known as a transient variable.

A transient variable plays an important role in preventing an object from being serialized. We can make any variable transient by using the transient keyword.

Usually, the interviewer asks the difference between the volatile and the transient variable. So, the volatile and the transient variables are both different from each other. The transient keyword is mainly used at the time of serializing an object, while the volatile keyword is related to the visibility of variables that are modified by multiple threads at the time of concurrent programming.

Both the volatile and transient keywords are rarely used by the programmer and not so much popular as compared to public, static or final.

In order to exclude the instance variables from the serialization process, we use the transient keyword. In order to indicate compiler to read the value of the variable from the main memory, we use the volatile keyword.

We can use the volatile keyword with static but cannot use the transient keyword with static.

Let's take an example of a transient variable and understand how it works in Java:

TransientVariableExample.java

// import required classes and packages 

packagejavaTpoint.javacodes;

importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serializable;

// create TransientVariableExample class to understand the concept of transient variable
public class TransientVariableExample {

	// main() method start
	public static void main(String args[]) {
	
		Book newBook = new Book(1014, "Java and OOPs", "RS Aggarwal", 5);
		System.out.println("Book before serialization: " + newBook);
		
		// use try-catch block
try {
	// create instance of FileOutputStream class for newBook
FileOutputStream stream1 = new FileOutputStream("newBook.ser");

            // create instance of ObjectOutputStream class 
ObjectOutputStream stream2 = new ObjectOutputStream(stream1);
stream2.writeObject(newBook);

stream1.close();
stream2.close();

            // show message for successful serialized book
System.out.println("Book is successfully Serialized ");

            // create instance of FileInputStream class for newBook
FileInputStream inputStream1 = new FileInputStream("newBook.ser");

            // create instance of ObjectInputStream class 
ObjectInputStream inputStream2 = new ObjectInputStream(inputStream1);

            // read data of book from inputStream2
            Book oldBook = (Book) inputStream2.readObject();

inputStream1.close();
inputStream2.close();

            // show successful messages
System.out.println("Book is successfully created from the Serialized data and the book after seriazliation is : " + oldBook);

        } catch (Exception e) {
e.printStackTrace();
        }

    }


}

// create class Book that implements the Serializable interface and has a transient variable.

class Book implements Serializable{
    // declare variables 
	privateint ISBN;	// each book has ISBN number
private String title;	// for title of the book
private String author;	// for author of the book
private transient int edition = 1; // edition of the book, i.e., transient variable not serialized

    // initialize variables using constructor
public Book(intisbn, String ttl, String auth, int edition) {
this.ISBN = isbn;
this.title = ttl;
this.author = auth;
this.edition = edition;
    }

    @Override
public String toString() {
        return "Book" + " ISBN= " + ISBN + ", title=" + title + ", author=" + author + ", edition=" + edition + '}';
    }

}

Output: