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());
    }
}

Сериализация — это процесс преобразования структуры данных или объекта в формат, который можно сохранить на диск, передать по сети или записать в базу данных, с возможностью последующего восстановления (десериализации) в исходную структуру.

RFC (Request for Comments) — серия документов Интернет-инженерного совета (IETF), описывающих стандарты, протоколы и технологии Интернета. RFC 8259 является официальной спецификацией формата JSON.

Парсинг — это процесс анализа строки или потока данных в соответствии с правилами формального языка (грамматикой) с целью построения структурированного представления, обычно дерева разбора или абстрактного синтаксического дерева (AST).

REST (Representational State Transfer) — это архитектурный стиль проектирования распределённых систем, введённый Роем Филдингом в его докторской диссертации 2000 года. REST не является протоколом или стандартом в строгом смысле; это набор ограничений и принципов.

Ключевое ограничение — statelessness (отсутствие состояния): каждый запрос от клиента к серверу должен содержать всю информацию, необходимую для его обработки, и сервер не хранит контекст клиента между запросами.

DTD (Document Type Definition) и XSD (XML Schema Definition) — это механизмы определения структуры и допустимых элементов XML-документа. JSON изначально не имел встроенного механизма схем, хотя позже появились JSON Schema и OpenAPI.