Java transient is a modifier keyword that is used to mark a variable whose value is not to be serialized during Serialization. If we do not want to save the value of a specific variable during the serialisation, then we can mark a variable as transient by using the transient keyword. As the name itself, transient indicates that it last for a short time or not permanent. When the JVM encounters the transient variable, it ignores the variable’s original value and saves it by its default data type value.
Start Your Free Software Development Course
Web development, programming languages, Software testing & others
Syntax:
The following is the declaration transient keyword.
transient private <member variable>;</member>
or
private transient <member variable>;</member>
AS above mentioned, we can see that the data member defined as transient will not be serialized because it is marked by transient keyword for not to be serialized. We can define a transient data member in two ways, the same as above in the syntax.
Note that Serialization is a process that converts the state of an object into a byte stream. During serialization, if we do not want to save a variable’s value in the file, we can declare it as transient.
Examples of Transient Keyword in Java
Next, we write the java code to understand the transient keyword more clearly with the following example where we will use a transient keyword to define a member variable of a class and make this class subclass of Serializable to perform the serialization and deserialization, as below.
Example #1
Code:
//package demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; class Employee implements Serializable{ private String name; private String eid; private int age; //transient variable not serialized private transient int projid = 104; public Employee( String name, String eid, int age, int projid) { this.age = age; this.name = name; this.eid = eid; this.projid = projid; } @Override public String toString() { return "Employee ( name=" + name + ", eid=" + eid + ", age=" + age + ", projid=" + projid + ')'; } } public class Demo { public static void main(String[] args) { // create Employee class object which is Serializable Employee e1 = new Employee( "John", "e106", 26, 104); System.out.println("Employee object Before Serialization is : " + e1); try { FileOutputStream fw = new FileOutputStream("D:\\data.txt"); ObjectOutputStream ow = new ObjectOutputStream(fw); ow.writeObject(e1); System.out.println("Employee is successfully Serialized "); // code for deserialization FileInputStream fr = new FileInputStream("D:\\data.txt"); ObjectInputStream or = new ObjectInputStream(fr); Employee de1 = (Employee) or.readObject(); System.out.println("Employee object successfully created from Serialized data."); System.out.println("Employee object after deseriazliation is : " + de1); } catch (Exception e) { e.printStackTrace(); } } }
Output:
Code Explanation: As in the above code, the employee class has created, and the project id that is projid data member of the employee class is defined as transient, so the value projid will not be serialized and while writing an employee object to the file will not save the value of a projid in the file. And later in the code, an employee object is read back from that file and deserialize an object; we can see in the output that the printing projid of the employee object is 0, which is the default value for the transient variable projid because it is serialized.
Example #2
Next, we write the java code to understand the transient keyword and show that the transient keyword does not impact the static and final variable as transient.
Code:
//package demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; class Employee implements Serializable{ private String name; // Use of transient has no impact on static private static String eid; // Use of transient has no impact on final private final int age; //transient variable not serialized private transient int projid = 104; public Employee( String name, String eid, int age, int projid) { this.age = age; this.name = name; this.eid = eid; this.projid = projid; } @Override public String toString() { return "Employee ( name=" + name + ", eid=" + eid + ", age=" + age + ", projid=" + projid + ')'; } } public class Demo { public static void main(String[] args) { // create Employee class object which is Serializable Employee e1 = new Employee( "John", "e106", 26, 104); System.out.println("Employee object Before Serialization is : " + e1); try { FileOutputStream fw = new FileOutputStream("D:\\data.txt"); ObjectOutputStream ow = new ObjectOutputStream(fw); ow.writeObject(e1); // code for deserialization FileInputStream fr = new FileInputStream("D:\\data.txt"); ObjectInputStream or = new ObjectInputStream(fr); Employee de1 = (Employee) or.readObject(); System.out.println("Employee object after deseriazliation is : " + de1); } catch (Exception e) { e.printStackTrace(); } } }
Output:
Code Explanation: As in the above code, the employee class has created, and the eid data member is declared as static and transient, the age declare as final and transient, and porjid of the employee class is declared as only transient, so only the value of projid will not be serialized and while writing an employee object to the file, but others data member value will be serialized. we can see in the output that after desterilize an object is printing, the projid of the employee object is 0, and all other data members’ values are saved because they are not serialized.
Conclusion
As simple as, the name transient meaning is lasting for a short time or not permanent the same way transient keyword is used in java. The transient is a modifier keyword that is used to mark a variable whose value is not to be serialized during Serialization.
The above is the detailed content of Java Transient. For more information, please follow other related articles on the PHP Chinese website!

Bytecodeachievesplatformindependencebybeingexecutedbyavirtualmachine(VM),allowingcodetorunonanyplatformwiththeappropriateVM.Forexample,JavabytecodecanrunonanydevicewithaJVM,enabling"writeonce,runanywhere"functionality.Whilebytecodeoffersenh

Java cannot achieve 100% platform independence, but its platform independence is implemented through JVM and bytecode to ensure that the code runs on different platforms. Specific implementations include: 1. Compilation into bytecode; 2. Interpretation and execution of JVM; 3. Consistency of the standard library. However, JVM implementation differences, operating system and hardware differences, and compatibility of third-party libraries may affect its platform independence.

Java realizes platform independence through "write once, run everywhere" and improves code maintainability: 1. High code reuse and reduces duplicate development; 2. Low maintenance cost, only one modification is required; 3. High team collaboration efficiency is high, convenient for knowledge sharing.

The main challenges facing creating a JVM on a new platform include hardware compatibility, operating system compatibility, and performance optimization. 1. Hardware compatibility: It is necessary to ensure that the JVM can correctly use the processor instruction set of the new platform, such as RISC-V. 2. Operating system compatibility: The JVM needs to correctly call the system API of the new platform, such as Linux. 3. Performance optimization: Performance testing and tuning are required, and the garbage collection strategy is adjusted to adapt to the memory characteristics of the new platform.

JavaFXeffectivelyaddressesplatforminconsistenciesinGUIdevelopmentbyusingaplatform-agnosticscenegraphandCSSstyling.1)Itabstractsplatformspecificsthroughascenegraph,ensuringconsistentrenderingacrossWindows,macOS,andLinux.2)CSSstylingallowsforfine-tunin

JVM works by converting Java code into machine code and managing resources. 1) Class loading: Load the .class file into memory. 2) Runtime data area: manage memory area. 3) Execution engine: interpret or compile execution bytecode. 4) Local method interface: interact with the operating system through JNI.

JVM enables Java to run across platforms. 1) JVM loads, validates and executes bytecode. 2) JVM's work includes class loading, bytecode verification, interpretation execution and memory management. 3) JVM supports advanced features such as dynamic class loading and reflection.

Java applications can run on different operating systems through the following steps: 1) Use File or Paths class to process file paths; 2) Set and obtain environment variables through System.getenv(); 3) Use Maven or Gradle to manage dependencies and test. Java's cross-platform capabilities rely on the JVM's abstraction layer, but still require manual handling of certain operating system-specific features.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

SublimeText3 Linux new version
SublimeText3 Linux latest version

MantisBT
Mantis is an easy-to-deploy web-based defect tracking tool designed to aid in product defect tracking. It requires PHP, MySQL and a web server. Check out our demo and hosting services.

Safe Exam Browser
Safe Exam Browser is a secure browser environment for taking online exams securely. This software turns any computer into a secure workstation. It controls access to any utility and prevents students from using unauthorized resources.

SAP NetWeaver Server Adapter for Eclipse
Integrate Eclipse with SAP NetWeaver application server.

Zend Studio 13.0.1
Powerful PHP integrated development environment
