Что необходимо предусматривать при клонировании объекта иммутабельного класса

Клонирование объектов иммутабельных классов

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

Что такое иммутабельный класс

Иммутабельный класс обладает следующими характеристиками:

• Все поля private и final
• Нет setter методов
• Класс сам final или его методы final
• Мутабельные поля не должны экспортироваться или модифицироваться

Проблемы при клонировании иммутабельных объектов

// Пример иммутабельного класса с мутабельным полем
public final class User implements Cloneable {
    private final String name;
    private final List<String> addresses;  // ПРОБЛЕМА: List мутабельный
    private final LocalDate birthDate;     // OK: LocalDate иммутабельный
    
    public User(String name, List<String> addresses, LocalDate birthDate) {
        this.name = name;
        // ПРОБЛЕМА: если не скопировать, внешний код может изменить List
        this.addresses = new ArrayList<>(addresses);
        this.birthDate = birthDate;
    }
    
    // ПЛОХО: возвращаем исходный List
    public List<String> getAddresses() {
        return addresses;  // Нарушает иммутабельность!
    }
    
    // ХОРОШО: возвращаем неизменяемую копию
    public List<String> getAddresses() {
        return Collections.unmodifiableList(addresses);
    }
}

Правильное клонирование иммутабельного класса

public final class ImmutableUser implements Cloneable {
    private final String name;
    private final int age;
    private final LocalDate birthDate;
    private final List<String> addresses;
    
    public ImmutableUser(String name, int age, LocalDate birthDate, 
                         List<String> addresses) {
        this.name = name;
        this.age = age;
        this.birthDate = birthDate;
        // Копируем мутабельные поля для защиты
        this.addresses = new ArrayList<>(addresses);
    }
    
    @Override
    public ImmutableUser clone() throws CloneNotSupportedException {
        try {
            // Можно просто вернуть this, т.к. класс иммутабельный
            return (ImmutableUser) super.clone();
        } catch (CloneNotSupportedException e) {
            // Не должно произойти, т.к. реализуем Cloneable
            throw new AssertionError();
        }
    }
    
    // Альтернатива: copy constructor (более безопасен)
    public ImmutableUser(ImmutableUser other) {
        this.name = other.name;
        this.age = other.age;
        this.birthDate = other.birthDate;
        this.addresses = new ArrayList<>(other.addresses);
    }
}

Проблема: Double Cloning (глубокое клонирование)

public final class Person implements Cloneable {
    private final String name;
    private final Address address;  // мутабельный объект
    
    public Person(String name, Address address) {
        this.name = name;
        // НЕПРАВИЛЬНО: не копируем Address
        this.address = address;
    }
    
    @Override
    public Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        // ПРОБЛЕМА: address всё ещё ссылается на исходный объект
        // Если мы изменим address через reflection или какой-то другой способ,
        // оба Person объекта будут затронуты
        return cloned;
    }
}

// ПРАВИЛЬНОЕ решение: глубокое копирование мутабельных полей
public final class Person implements Cloneable {
    private final String name;
    private final Address address;
    
    public Person(String name, Address address) {
        this.name = name;
        // Копируем мутабельный объект в конструкторе
        this.address = new Address(address.getStreet(), address.getCity());
    }
    
    @Override
    public Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        // Если это всё ещё недостаточно, можем переопределить поле
        // через reflection, но это признак плохого дизайна
        return cloned;
    }
}

class Address {
    private String street;
    private String city;
    
    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }
    
    public Address copy() {
        return new Address(this.street, this.city);
    }
}

Copy Constructor — рекомендуемый подход

public final class Email implements Serializable {
    private final String value;
    
    public Email(String value) {
        if (!isValid(value)) {
            throw new IllegalArgumentException("Invalid email");
        }
        this.value = value;
    }
    
    // Copy constructor - безопаснее, чем clone()
    public Email(Email other) {
        this.value = other.value;
    }
    
    // Через builder pattern
    public static class Builder {
        private String value;
        
        public Builder(Email original) {
            this.value = original.value;
        }
        
        public Builder value(String value) {
            this.value = value;
            return this;
        }
        
        public Email build() {
            return new Email(value);
        }
    }
    
    private static boolean isValid(String email) {
        return email.contains("@");
    }
}

Что необходимо предусматривать

1. Копирование мутабельных полей — все мутабельные объекты должны быть скопированы

public final class Config {
    private final Map<String, String> settings;
    
    public Config(Map<String, String> settings) {
        // Копируем мутабельный Map
        this.settings = new HashMap<>(settings);
    }
    
    // Возвращаем неизменяемую копию
    public Map<String, String> getSettings() {
        return Collections.unmodifiableMap(settings);
    }
}

1. Validation при клонировании — проверяем инварианты класса

public final class Age {
    private final int value;
    
    public Age(int value) {
        if (value < 0 || value > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
        this.value = value;
    }
    
    public Age(Age other) {
        // Copy constructor автоматически проверяет валидность
        this(other.value);
    }
}

1. Глубокое клонирование коллекций

public final class UserGroup {
    private final List<User> users;
    
    public UserGroup(List<User> users) {
        // Копируем список
        this.users = new ArrayList<>(users);
    }
    
    public UserGroup deepCopy() {
        // Если User также мутабельный, нужно копировать каждый
        List<User> copiedUsers = users.stream()
            .map(user -> new User(user))  // copy constructor
            .collect(Collectors.toList());
        return new UserGroup(copiedUsers);
    }
}

1. Использование Serialization для клонирования

import java.io.*;

public final class SerializableUser implements Serializable {
    private final String name;
    private final int age;
    
    // Deep clone через сериализацию
    public SerializableUser deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);
        oos.close();
        
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        SerializableUser cloned = (SerializableUser) ois.readObject();
        ois.close();
        return cloned;
    }
}

Лучшие практики

• Избегайте Cloneable — используйте copy constructors или builder pattern
• Копируйте мутабельные поля в конструкторе и при клонировании
• Возвращайте Collections.unmodifiableXXX для коллекций
• Используйте final для класса и полей
• Валидируйте данные при создании копии
• Документируйте поведение при клонировании
• Предпочитайте copy constructor вместо clone() для иммутабельных классов

Для иммутабельных классов часто вообще не нужно клонирование, так как объект не может быть изменен. Но если есть мутабельные поля, необходимо скопировать их, чтобы предотвратить побочные эффекты.