Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Serialization in Java — converting objects to byte streams, Serializable interface, ObjectOutputStream, transient keyword, serialVersionUID, and custom serialization.
What is Serialization?
Serialization is the process of converting a Java object's state into a byte stream, so it can be:
- Saved to a file (persistence)
- Sent over a network (remote communication)
- Stored in a database (as BLOB)
- Cached in memory systems (Redis, Memcached)
Serialization
Java Object →→→ Byte Stream →→→ File/Network/Database
(in memory) (portable) (persistent storage)
Deserialization (reverse)
File/Network →→→ Byte Stream →→→ Java Object
(storage) (portable) (back in memory)
The Serializable Interface
To make a class serializable, implement java.io.Serializable:
java example
import java.io.Serializable;
// Serializable is a MARKER interface (no methods to implement)
public class Student implements Serializable {
private String name;
private int age;
private double gpa;
public Student(String name, int age, double gpa) {
this.name = name;
this.age = age;
this.gpa = gpa;
}
@Override
public String toString() {
return String.format("Student{name='%s', age=%d, gpa=%.2f}", name, age, gpa);
}
}Basic Serialization with ObjectOutputStream
java example
import java.io.*;
class Employee implements Serializable {
private String name;
private int id;
private double salary;
private String department;
public Employee(String name, int id, double salary, String department) {
this.name = name;
this.id = id;
this.salary = salary;
this.department = department;
}
@Override
public String toString() {
return String.format("Employee{id=%d, name='%s', salary=%.2f, dept='%s'}",
id, name, salary, department);
}
}
public class SerializationBasic {
public static void main(String[] args) {
Employee emp = new Employee("Alice Johnson", 1001, 75000.50, "Engineering");
System.out.println("=== Serialization Demo ===\n");
System.out.println("Object to serialize: " + emp);
// Serialize (write object to file)
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("employee.ser"))) {
oos.writeObject(emp);
System.out.println("\n✓ Object serialized to 'employee.ser'");
System.out.println(" File size: " + new File("employee.ser").length() + " bytes");
} catch (IOException e) {
System.out.println("Serialization error: " + e.getMessage());
}
// Deserialize (read object from file)
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("employee.ser"))) {
Employee restored = (Employee) ois.readObject();
System.out.println("\n✓ Object deserialized from file:");
System.out.println(" " + restored);
} catch (IOException | ClassNotFoundException e) {
System.out.println("Deserialization error: " + e.getMessage());
}
new File("employee.ser").delete();
}
}Output:
Example
=== Serialization Demo ===
Object to serialize: Employee{id=1001, name='Alice Johnson', salary=75000.50, dept='Engineering'}
✓ Object serialized to 'employee.ser'
File size: 142 bytes
✓ Object deserialized from file:
Employee{id=1001, name='Alice Johnson', salary=75000.50, dept='Engineering'}
The transient Keyword
Fields marked transient are excluded from serialization:
java example
import java.io.*;
class UserAccount implements Serializable {
private String username;
private transient String password; // NOT serialized!
private transient int loginAttempts; // NOT serialized!
private String email;
private String role;
public UserAccount(String username, String password, String email, String role) {
this.username = username;
this.password = password;
this.email = email;
this.role = role;
this.loginAttempts = 0;
}
@Override
public String toString() {
return String.format(
"UserAccount{user='%s', pass='%s', email='%s', role='%s', attempts=%d}",
username, password, email, role, loginAttempts);
}
}
public class TransientExample {
public static void main(String[] args) throws IOException, ClassNotFoundException {
UserAccount account = new UserAccount("alice", "secret123", "alice@mail.com", "admin");
System.out.println("=== Transient Keyword Demo ===\n");
System.out.println("Before serialization: " + account);
// Serialize
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("user.ser"))) {
oos.writeObject(account);
}
// Deserialize
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("user.ser"))) {
UserAccount restored = (UserAccount) ois.readObject();
System.out.println("After deserialization: " + restored);
}
System.out.println("\nNotice: password is null, loginAttempts is 0");
System.out.println("Transient fields get their DEFAULT values:");
System.out.println(" - Objects → null");
System.out.println(" - int → 0");
System.out.println(" - boolean → false");
System.out.println(" - double → 0.0");
new File("user.ser").delete();
}
}Output:
| Before serialization | UserAccount{user='alice', pass='secret123', email='alice@mail.com', role='admin', attempts=0} |
| After deserialization | UserAccount{user='alice', pass='null', email='alice@mail.com', role='admin', attempts=0} |
| Notice | password is null, loginAttempts is 0 |
| - Objects | null |
| - int | 0 |
| - boolean | false |
| - double | 0.0 |
serialVersionUID
The serialVersionUID is a version identifier for the serialized class. It ensures compatibility between the serializer and deserializer:
java example
import java.io.*;
class Product implements Serializable {
// Explicitly declare serialVersionUID
private static final long serialVersionUID = 1L;
private String name;
private double price;
private int quantity;
public Product(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}
@Override
public String toString() {
return String.format("Product{name='%s', price=%.2f, qty=%d}", name, price, quantity);
}
}
public class SerialVersionUIDExample {
public static void main(String[] args) throws IOException, ClassNotFoundException {
System.out.println("=== serialVersionUID Demo ===\n");
Product product = new Product("Laptop", 999.99, 50);
// Serialize
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("product.ser"))) {
oos.writeObject(product);
System.out.println("Serialized: " + product);
}
// Deserialize
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("product.ser"))) {
Product restored = (Product) ois.readObject();
System.out.println("Deserialized: " + restored);
}
System.out.println("\n--- What serialVersionUID Prevents ---");
System.out.println("Without explicit serialVersionUID:");
System.out.println(" 1. Serialize object (class version A)");
System.out.println(" 2. Modify class (add/remove field) → version B");
System.out.println(" 3. Deserialize → InvalidClassException!");
System.out.println("");
System.out.println("With explicit serialVersionUID = 1L:");
System.out.println(" 1. Serialize object (serialVersionUID = 1L)");
System.out.println(" 2. Add new field (keep serialVersionUID = 1L)");
System.out.println(" 3. Deserialize → WORKS! New field gets default value");
new File("product.ser").delete();
}
}Serializing Multiple Objects
java example
import java.io.*;
import java.util.*;
class Contact implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private String phone;
private String email;
public Contact(String name, String phone, String email) {
this.name = name;
this.phone = phone;
this.email = email;
}
@Override
public String toString() {
return String.format("%-15s | %-12s | %s", name, phone, email);
}
}
public class MultipleObjects {
public static void main(String[] args) throws IOException, ClassNotFoundException {
System.out.println("=== Serializing Multiple Objects ===\n");
// Create contacts
List<Contact> contacts = new ArrayList<>(Arrays.asList(
new Contact("Alice", "555-0101", "alice@mail.com"),
new Contact("Bob", "555-0102", "bob@mail.com"),
new Contact("Charlie", "555-0103", "charlie@mail.com"),
new Contact("Diana", "555-0104", "diana@mail.com")
));
// Method 1: Serialize entire collection
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("contacts.ser"))) {
oos.writeObject(contacts);
System.out.println("✓ Serialized " + contacts.size() + " contacts as List");
}
// Method 2: Deserialize entire collection
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("contacts.ser"))) {
@SuppressWarnings("unchecked")
List<Contact> restored = (List<Contact>) ois.readObject();
System.out.println("\nRestored contacts:");
System.out.printf("%-15s | %-12s | %s%n", "Name", "Phone", "Email");
System.out.println("-".repeat(50));
restored.forEach(System.out::println);
}
new File("contacts.ser").delete();
}
}Output:
Example
=== Serializing Multiple Objects ===
✓ Serialized 4 contacts as List
Restored contacts:
Name | Phone | Email
--------------------------------------------------
Alice | 555-0101 | alice@mail.com
Bob | 555-0102 | bob@mail.com
Charlie | 555-0103 | charlie@mail.com
Diana | 555-0104 | diana@mail.com
Serialization with Inheritance
Example
import java.io.*;
// Parent class is NOT Serializable
class Animal {
String species;
int legs;
public Animal() {
// Default constructor REQUIRED for non-serializable parent
this.species = "Unknown";
this.legs = 0;
System.out.println(" [Animal default constructor called]");
}
public Animal(String species, int legs) {
this.species = species;
this.legs = legs;
}
}
// Child class IS Serializable
class Dog extends Animal implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private String breed;
public Dog(String name, String breed, int legs) {
super("Canine", legs);
this.name = name;
this.breed = breed;
}
@Override
public String toString() {
return String.format("Dog{name='%s', breed='%s', species='%s', legs=%d}",
name, breed, species, legs);
}
}
public class InheritanceSerialization {
public static void main(String[] args) throws IOException, ClassNotFoundException {
System.out.println("=== Inheritance + Serialization ===\n");
Dog dog = new Dog("Rex", "German Shepherd", 4);
System.out.println("Before: " + dog);
// Serialize
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("dog.ser"))) {
oos.writeObject(dog);
}
// Deserialize
System.out.println("\nDeserializing...");
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("dog.ser"))) {
Dog restored = (Dog) ois.readObject();
System.out.println("After: " + restored);
}
System.out.println("\nKey Points:");
System.out.println(" 1. Parent (Animal) fields are NOT serialized");
System.out.println(" 2. Parent's no-arg constructor IS called during deserialization");
System.out.println(" 3. Child (Dog) fields ARE serialized normally");
System.out.println(" 4. Parent's species='Unknown' and legs=0 (defaults)");
new File("dog.ser").delete();
}
}
Output:
Example
=== Inheritance + Serialization ===
Before: Dog{name='Rex', breed='German Shepherd', species='Canine', legs=4}
Deserializing...
[Animal default constructor called]
After: Dog{name='Rex', breed='German Shepherd', species='Unknown', legs=0}
Key Points:
1. Parent (Animal) fields are NOT serialized
2. Parent's no-arg constructor IS called during deserialization
3. Child (Dog) fields ARE serialized normally
4. Parent's species='Unknown' and legs=0 (defaults)
Custom Serialization (writeObject / readObject)
You can control exactly what gets serialized:
Example
import java.io.*;
class SecureConfig implements Serializable {
private static final long serialVersionUID = 1L;
private String serverUrl;
private String apiKey; // We want to encrypt this
private int timeout;
public SecureConfig(String url, String key, int timeout) {
this.serverUrl = url;
this.apiKey = key;
this.timeout = timeout;
}
// Custom serialization: encrypt sensitive data
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject(); // Serialize normal fields
// Write encrypted version of apiKey
String encrypted = encrypt(apiKey);
oos.writeObject(encrypted);
System.out.println(" [Custom writeObject: apiKey encrypted]");
}
// Custom deserialization: decrypt sensitive data
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException {
ois.defaultReadObject(); // Deserialize normal fields
// Read and decrypt apiKey
String encrypted = (String) ois.readObject();
this.apiKey = decrypt(encrypted);
System.out.println(" [Custom readObject: apiKey decrypted]");
}
// Simple encryption (for demo — use real crypto in production!)
private String encrypt(String data) {
StringBuilder sb = new StringBuilder();
for (char c : data.toCharArray()) {
sb.append((char)(c + 3));
}
return sb.toString();
}
private String decrypt(String data) {
StringBuilder sb = new StringBuilder();
for (char c : data.toCharArray()) {
sb.append((char)(c - 3));
}
return sb.toString();
}
@Override
public String toString() {
return String.format("Config{url='%s', apiKey='%s', timeout=%d}",
serverUrl, apiKey, timeout);
}
}
public class CustomSerialization {
public static void main(String[] args) throws IOException, ClassNotFoundException {
System.out.println("=== Custom Serialization ===\n");
SecureConfig config = new SecureConfig(
"https://api.example.com", "sk-secret-key-123", 30000);
System.out.println("Original: " + config);
// Serialize
System.out.println("\nSerializing...");
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("config.ser"))) {
oos.writeObject(config);
}
// Deserialize
System.out.println("\nDeserializing...");
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("config.ser"))) {
SecureConfig restored = (SecureConfig) ois.readObject();
System.out.println("\nRestored: " + restored);
}
new File("config.ser").delete();
}
}
Output:
| Original | Config{url='https://api.example.com', apiKey='sk-secret-key-123', timeout=30000} |
| [Custom writeObject | apiKey encrypted] |
| [Custom readObject | apiKey decrypted] |
| Restored | Config{url='https://api.example.com', apiKey='sk-secret-key-123', timeout=30000} |
Common Mistakes
1. Forgetting to implement Serializable
java example
// ❌ NotSerializableException at runtime!
class MyClass {
// missing: implements Serializable
}
// ✅ Always implement Serializable
class MyClass implements Serializable { }2. Non-serializable fields
java example
// ❌ If a field's class isn't Serializable, the whole object fails
class DataHolder implements Serializable {
private Socket connection; // Socket isn't Serializable → Exception!
}
// ✅ Mark non-serializable fields as transient
class DataHolder implements Serializable {
private transient Socket connection; // Excluded from serialization
}3. Not declaring serialVersionUID
java example
// ❌ JVM generates one automatically — breaks if class changes
class MyClass implements Serializable { }
// ✅ Always declare explicitly
class MyClass implements Serializable {
private static final long serialVersionUID = 1L;
}Interview Questions
Q1: What is serialization in Java?
Answer: Serialization is the process of converting a Java object into a byte stream so it can be persisted to a file, sent over a network, or stored in a database. The reverse process (byte stream → object) is deserialization.
Q2: What is the Serializable interface? Why is it called a marker interface?
Answer: Serializable is an interface with NO methods. It's called a "marker" interface because it simply marks/tags a class as eligible for serialization. The JVM checks for this marker before allowing serialization.
Q3: What is the transient keyword?
Answer: transient marks a field to be excluded from serialization. During deserialization, transient fields receive their default values (null for objects, 0 for numbers, false for booleans). Use it for sensitive data (passwords), derived values, or non-serializable fields (connections, threads).
Q4: What is serialVersionUID and why is it important?
Answer: It's a version number for the serialized class. During deserialization, JVM compares the sender's UID with the receiver's. If they don't match, it throws InvalidClassException. Declaring it explicitly allows controlled class evolution (adding fields without breaking existing serialized data).
Q5: What happens if a parent class is not Serializable but the child is?
Answer: Only the child's fields are serialized. During deserialization, the parent's no-argument constructor is called to initialize parent fields. If the parent doesn't have a no-arg constructor, deserialization fails with InvalidClassException.
Q6: Can static fields be serialized?
Answer: No. Static fields belong to the class, not to any instance. Serialization saves instance state only. However, serialVersionUID (which is static) is a special case used by the serialization mechanism itself.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Serialization in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, file, handling, serialization
Related Java Master Course Topics
Continue learning this concept
File HandlingBuffered Streams in JavaComplete guide to Buffered Streams in Java — BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, performance benefits, line-by-line reading, and real-world file processing.File HandlingByte Streams in JavaComplete guide to Byte Streams in Java — FileInputStream, FileOutputStream, reading and writing binary data, copying files, and understanding byte-level I/O operations.File HandlingCharacter Streams in JavaComplete guide to Character Streams in Java — FileReader, FileWriter, handling Unicode text, character encoding, reading/writing text files with proper internationalization support.File HandlingDeserialization in JavaComplete guide to Deserialization in Java — ObjectInputStream, reading objects from files, type safety, version compatibility, security risks, and best practices for safe deserialization.File HandlingFile Class in JavaComplete guide to the java.io.File class — creating File objects, checking file properties, creating/deleting files and directories, listing contents, and file path operations.File HandlingJava NIO PackageComplete guide to Java NIO (New I/O) — Path, Files, Channels, Buffers, non-blocking I/O, WatchService, and modern file operations that replace traditional java.io approaches.