Serialization and Deserialization in Java

import java.io.*;
import java.nio.file.*;
import java.util.List;

public class SerializeToFile {
    static class Customer implements Serializable {
        private static final long serialVersionUID = 1L;    // version of the serialized form
        private final String name;
        private final int loyaltyPoints;
        private final List<String> orders;
        private transient String sessionToken;              // not serialized

        Customer(String name, int points, List<String> orders, String token) {
            this.name = name; this.loyaltyPoints = points; this.orders = orders; this.sessionToken = token;
        }
        public String toString() {
            return "Customer[" + name + ", points=" + loyaltyPoints + ", orders=" + orders + ", token=" + sessionToken + "]";
        }
    }

    public static void main(String[] args) throws Exception {
        Path file = Path.of(System.getProperty("java.io.tmpdir"), "customer.ser");
        Customer original = new Customer("Asha", 1250, List.of("A-17", "B-42"), "tok-9f2c");

        try (ObjectOutputStream out = new ObjectOutputStream(Files.newOutputStream(file))) {
            out.writeObject(original);                       // serialization
        }
        System.out.println("Saved to " + file.getFileName());

        try (ObjectInputStream in = new ObjectInputStream(Files.newInputStream(file))) {
            Customer copy = (Customer) in.readObject();      // deserialization
            System.out.println("Original: " + original);
            System.out.println("Restored: " + copy);
            System.out.println("Same object? " + (copy == original));
        }
        Files.delete(file);
    }
}

import java.io.*;

public class InheritanceSerialization {
    static class Person {                           // NOT Serializable
        String name = "default";
        Person() { System.out.println("  Person() constructor runs"); }
    }

    static class Employee extends Person implements Serializable {
        private static final long serialVersionUID = 1L;
        int empId;
        Employee(String name, int empId) { this.name = name; this.empId = empId; }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("1. new Employee(...):");
        Employee e = new Employee("Ravi", 501);
        System.out.println("2. deserializing a copy:");
        Employee copy = roundTrip(e);
        System.out.println("empId (serializable class field): " + copy.empId);
        System.out.println("name  (non-serializable parent):  " + copy.name);
    }

    @SuppressWarnings("unchecked")
    static <T> T roundTrip(T obj) throws Exception {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (ObjectOutputStream out = new ObjectOutputStream(bytes)) { out.writeObject(obj); }
        try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) {
            return (T) in.readObject();
        }
    }
}

import java.io.*;

public class NotSerializableDemo {
    static class Address { String city = "Pune"; }               // not Serializable
    static class User implements Serializable {
        private static final long serialVersionUID = 1L;
        String name = "Meera";
        Address address = new Address();                         // breaks serialization
    }

    public static void main(String[] args) {
        try {
            InheritanceSerialization.roundTrip(new User());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

import java.io.*;
import java.util.Base64;

public class CustomSerialization {
    static class Account implements Serializable {
        private static final long serialVersionUID = 1L;
        private final String user;
        private transient String pin;                       // handled manually below

        Account(String user, String pin) { this.user = user; this.pin = pin; }

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();                       // write normal fields
            out.writeUTF(Base64.getEncoder().encodeToString(pin.getBytes()));   // "encrypt" (demo only)
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            pin = new String(Base64.getDecoder().decode(in.readUTF()));
            if (user == null || user.isBlank()) throw new InvalidObjectException("user missing");   // validate
        }
        public String toString() { return user + " / pin length " + pin.length(); }
    }

    record Point(int x, int y) implements Serializable {
        Point {                                             // records deserialize via this constructor
            if (x < 0 || y < 0) throw new IllegalArgumentException("negative coordinate");
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println(InheritanceSerialization.roundTrip(new Account("asha", "4821")));
        System.out.println(InheritanceSerialization.roundTrip(new Point(3, 4)));
    }
}