public class Library implements Serializable {
    private String name;
    private List<Book> books;  // Book тоже должен быть Serializable
    private Librarian head;    // Librarian тоже должен быть Serializable
}

Глубокая копия (deep copy) — это копия объекта, при которой копируются не только сам объект, но и все объекты, на которые он ссылается, рекурсивно. В отличие от поверхностной копии (shallow copy), где копируются только ссылки на те же внутренние объекты.

public class Config implements Serializable {
    private static String globalPrefix = "app";  // не сериализуется
    private String instanceName;                  // сериализуется
}

public class UserSession implements Serializable {
    private String username;
    private transient String password;      // не сериализуется
    private transient Connection dbConn;    // не сериализуется
    private transient byte[] cachedToken;   // не сериализуется
}

public class Base {  // не Serializable
    private int baseField;
    public Base() {}  // обязателен no-arg конструктор
}

public class Derived extends Base implements Serializable {
    private int derivedField;  // только это поле сериализуется
}

No-arg конструктор (no-argument constructor, default constructor) — это конструктор без параметров. В Java, если класс не объявляет явных конструкторов, компилятор генерирует no-arg конструктор автоматически. Если объявлен хотя бы один конструктор с параметрами, no-arg конструктор нужно объявлять явно.

public class Node implements Serializable {
    private String name;
    private Node next;  // может образовать цикл
}

// Создаём цикл: A -> B -> C -> A
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
a.next = b;
b.next = c;
c.next = a;  // цикл!

// Сериализация не зацикливается благодаря таблице handles
oos.writeObject(a);  // записывает A, B, C, затем backreference на A

public class Document implements Serializable {
    private static final long serialVersionUID = 1L;
    private String title;
}

SHA (Secure Hash Algorithm) — семейство криптографических хеш-функций, которые преобразуют входные данные произвольной длины в строку фиксированной длины (дайджест). В контексте serialVersionUID используется не криптографический SHA, а похожий алгоритм хеширования структурных элементов класса.

// Версия 1
public class User implements Serializable {
    private String name;
    private int age;
}

// Версия 2 — добавлен метод, serialVersionUID изменился!
public class User implements Serializable {
    private String name;
    private int age;
    
    public void greet() {  // новый метод изменяет вычисленный UID
        System.out.println("Hello");
    }
}

java.io.InvalidClassException: User; local class incompatible:
stream classdesc serialVersionUID = -123456789, 
local class serialVersionUID = 987654321

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
}

// Версия 1
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
}

// Версия 2 — совместимое изменение: добавлено поле
public class User implements Serializable {
    private static final long serialVersionUID = 1L;  // тот же UID!
    private String name;
    private String email;  // новое поле, старые объекты получат null
}

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

public class SecureDocument implements Serializable {
    private static final long serialVersionUID = 1L;
    private String title;
    private transient String secretContent;  // не сериализуем напрямую
    
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();  // записываем title и другие нетранзиентные поля
        // Шифруем секретный контент перед записью
        String encrypted = encrypt(secretContent);
        out.writeUTF(encrypted);
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();  // читаем title
        // Дешифруем секретный контент
        String encrypted = in.readUTF();
        this.secretContent = decrypt(encrypted);
    }
    
    private String encrypt(String data) { /* ... */ return data; }
    private String decrypt(String data) { /* ... */ return data; }
}

Singleton — это порождающий паттерн проектирования, гарантирующий, что класс имеет только один экземпляр, и предоставляющий глобальную точку доступа к нему. При десериализации singleton механизм создаёт новый объект, нарушая гарантию единственности. readResolve возвращает существующий экземпляр.

public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
    
    // При десериализации возвращаем существующий INSTANCE, а не новый объект
    private Object readResolve() {
        return INSTANCE;
    }
}

Прокси-сериализация (serialization proxy pattern) — это паттерн, при котором вместо самого объекта сериализуется лёгкий прокси-объект (proxy), содержащий только необходимые данные, а при десериализации прокси через readResolve восстанавливает оригинальный объект через его конструктор или фабрику. Это защищает инварианты, предотвращает создание "сырых" объектов и позволяет менять внутреннюю структуру класса, не ломая совместимость.

public class ComplexObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private final int x;
    private final int y;
    // инвариант: x >= 0 && y >= 0
    
    public ComplexObject(int x, int y) {
        if (x < 0 || y < 0) throw new IllegalArgumentException();
        this.x = x;
        this.y = y;
    }
    
    // Вместо себя сериализуем прокси
    private Object writeReplace() {
        return new SerializationProxy(x, y);
    }
    
    // Запрещаем десериализацию ComplexObject напрямую
    private void readObject(ObjectInputStream in) throws InvalidObjectException {
        throw new InvalidObjectException("Proxy required");
    }
    
    private static class SerializationProxy implements Serializable {
        private static final long serialVersionUID = 1L;
        private final int x;
        private final int y;
        
        SerializationProxy(int x, int y) {
            this.x = x;
            this.y = y;
        }
        
        // При десериализации прокси восстанавливаем ComplexObject через конструктор
        private Object readResolve() {
            return new ComplexObject(x, y);  // инвариант проверяется!
        }
    }
}

import java.io.*;

public class Task310726 {
    static class DataV1 implements Serializable {
        private static final long serialVersionUID = 1L;
        String name = "John";
    }

    static class DataV2 implements Serializable {
        private static final long serialVersionUID = 1L;
        String fullName;
    }

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(new DataV1());
        }

        byte[] bytes = baos.toByteArray();
        try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            DataV2 obj = (DataV2) ois.readObject();
            System.out.println(obj.fullName);
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}

public class UnmodifiableView {
    
    public static void main(String[] args) {
        List<String> original = new ArrayList<>(Arrays.asList("A", "B", "C"));
        List<String> unmodifiable = Collections.unmodifiableList(original);
        
        System.out.println("Original: " + original);   // [A, B, C]
        System.out.println("Unmodifiable: " + unmodifiable); // [A, B, C]
        
        // Изменяем исходный список
        original.add("D");
        System.out.println("После изменения оригинала:");
        System.out.println("Original: " + original);   // [A, B, C, D]
        System.out.println("Unmodifiable: " + unmodifiable); // [A, B, C, D] — изменился!
        
        // Попытка изменить view вызовет исключение
        try {
            unmodifiable.add("E"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.err.println("Нельзя изменить view");
        }
        
        //Решение 1: копия + обертка (все равно оригинал может быть изменен, если доступен)
        List<String> copyAndWrap = Collections.unmodifiableList(new ArrayList<>(original));
        original.add("F");
        System.out.println("Copy+wrap не изменился: " + copyAndWrap); // [A, B, C, D] — не изменился
        
        //Решение 2: List.copyOf (Java 10+) — действительно неизменяемый
        List<String> immutable = List.copyOf(original);
        original.add("G");
        System.out.println("List.copyOf: " + immutable); // [A, B, C, D, F] — не изменился
        
        //Решение 3: List.of (Java 9+) — для фиксированного набора значений
        List<String> fixed = List.of("X", "Y", "Z");
        // fixed не зависит от внешних списков
    }
}

import java.util.*;

public class Task030826 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> unmod = Collections.unmodifiableList(list);
        list.add(4);
        try {
            unmod.add(5);
        } catch (UnsupportedOperationException e) {
            System.out.print("ex ");
        }
        System.out.println(unmod.size());
    }
}