clone 재정의는 주의해서 진행하라(2) - [3장. 모든 객체의 공통 메서드(아이템13)]

  이전 글을 통해 불변 객체에서 clone을 사용하는 방법을 알아보았다.

  이번에는 가변 객체에서 clone을 사용하는 방법을 알아보자. 가변 객체를 복제하는 3가지 방법을 살펴보자.

 

1. 배열 복사를 이용하는 경우 👨‍🚀

public class Stack implements Cloneable{
	private Object[] elements;
	private int size = 0;
	private static final int DEFAULT_INITIAL_CAPACITY = 16;
	
	public Stack() {
		this.elements = new Object[DEFAULT_INITIAL_CAPACITY];
	}
	
	public void push(Object e) {
		ensureCapacity();
		elements[size++] = e;
	}
	
	public Object pop() {
		if(size == 0)
			throw new EmptyStackException();
		
		Object result = elements[--size];
		elements[size] = null; // 다 쓴 참조 해제
		return result;
	}
	
	// 원소를 위한 공간을 적어도 하나 이상 확보한다.
	private void ensureCapacity() {
		if(elements.length == size)
			elements = Arrays.copyOf(elements, 2 * size + 1);
	}
	
	public boolean isEmpty() {
		return size == 0;
	}
	
	@Override
	public Stack clone() {
		try {
			Stack result = (Stack) super.clone();
			return result;
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}
}

----------

public static void main(String[] args) {
    Object[] values = new Object[2];
    values[0] = new User("amenable", 24);
    values[1] = new User("sunny", 21);

    Stack stackOrigin = new Stack();
    for(Object arg : values)
        stackOrigin.push(arg);
    Stack stackCopy = stackOrigin.clone();
    while(!stackOrigin.isEmpty())
        System.out.println(stackOrigin.pop() + " ");
    // clone.User@15db9742 
    // clone.User@6d06d69c 
    while(!stackCopy.isEmpty())
        System.out.println(stackCopy.pop() + " ");
    // null
    // null
}

  불변 객체에서 clone을 정의한 방식으로 가변 객체에 적용하게 된다면 위와 같이 copy 된 인스턴스가 기존 값에 영향을 받게 된다. 그러므로 위와 같이 배열을 복제할 때는 배열의 clone 메서드를 사용해야 한다.

@Override
public Stack clone() {
    try {
        Stack result = (Stack) super.clone();
        result.elements = elements.clone(); // final이면 사용 불가
        return result;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

----------

public static void main(String[] args) {
    Object[] values = new Object[2];
    values[0] = new User("amenable", 24);
    values[1] = new User("sunny", 21);

    Stack stackOrigin = new Stack();
    for(Object arg : values)
        stackOrigin.push(arg);
    Stack stackCopy = stackOrigin.clone();
    while(!stackOrigin.isEmpty())
        System.out.println(stackOrigin.pop() + " ");
    // clone.User@15db9742 
    // clone.User@6d06d69c 
    while(!stackCopy.isEmpty())
        System.out.println(stackCopy.pop() + " ");
    // clone.User@15db9742 
    // clone.User@6d06d69c 
}

  이렇게 하면 배열이 2개 생기긴 하겠지만, 결국은 얕은 복사(Shallow Copy)다. 그래서 사실상 배열에서 동일한 인스턴스를 보고 있긴 하다.

  그리고 elements가 final이라면 새로 할당할 수 없으므로 final을 쓸 수 없다는 제약도 존재한다.

 

2. Deep Copy를 이용하는 경우 👩‍🔬

public class HashTable implements Cloneable {
	
	private Entry[] buckets = new Entry[10];
	
	private static class Entry {
		final Object key;
		Object value;
		Entry next;
		
		Entry(Object key, Object value, Entry next) {
			this.key = key;
			this.value = value;
			this.next = next;
		}
		
		public void add(Object key, Object value) {
			this.next = new Entry(key, value, null);
		}
		
		public Entry deepCopy() {
			return new Entry(key, value, next == null ? null : next.deepCopy());
		}
	}
	
	@Override
	public HashTable clone() {
		HashTable result = null;
		try {
			result = (HashTable)super.clone();
			result.buckets = this.buckets.clone(); // shallow copy 라서 위험하다
			return result;
		} catch (CloneNotSupportedException e) {
			throw new AssertionError();
		}
	}
	
	public static void main(String[] args) {
		HashTable hashTable = new HashTable();
		Entry entry = new Entry(new Object(), new Object(), null);
		hashTable.buckets[0] = entry;
		HashTable clone = hashTable.clone();
		System.out.println(hashTable.buckets[0] == entry); // true
		System.out.println(hashTable.buckets[0] == clone.buckets[0]); // true
	}
}

  복제본은 자신만의 버킷 배열을 갖지만, 이 배열은 원본과 같은 연결 리스트를 참조하고 있다. 그러므로 아래와 같이 Deep Copy를 해줘야 한다.

public Entry deepCopy() {
    return new Entry(key, value, next == null ? null : next.deepCopy());
}

@Override
public HashTable clone() {
    HashTable result = null;
    try {
        result = (HashTable)super.clone();
        result.buckets = new Entry[this.buckets.length];
        for(int i = 0; i < this.buckets.length; i++) {
            if(buckets[i] != null) {
                result.buckets[i] = this.buckets[i].deepCopy(); // deep copy
            }
        }
        return result;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

----------

public static void main(String[] args) {
    HashTable hashTable = new HashTable();
    Entry entry = new Entry(new Object(), new Object(), null);
    hashTable.buckets[0] = entry;
    HashTable clone = hashTable.clone();
    System.out.println(hashTable.buckets[0] == entry); // true
    System.out.println(hashTable.buckets[0] == clone.buckets[0]); // false
}

  위에서 나온 DeepCopy 방법은 재귀적으로 호출하는 방식이다. 스택 오버플로우 때문에 연결 리스트를 복제하는 방법으로는 그다지 좋지 않다. 그렇기 때문에 아래와 같이 deepCopy 메서드를 재귀 호출 대신 반복자를 써서 순회하는 방법으로 수정할 수 있다. 

public Entry deepCopy() {
    Entry result = new Entry(key, value, next);
    for(Entry p = result; p.next != null; p = p.next) {
        p.next = new Entry(p.next.key, p.next.value, p.next.next);
    }
    return result;
}

  그리고 clone메서드 안에서는 아래와 같이 재정의 할 수 있는 메서드를 만들지 않아야 한다. 그 이유는 하위 클래스에서 해당 메서드를 재정의하면 동작이 바뀔 수 있기 때문이다.

@Override
public HashTable clone() {
    HashTable result = null;
    try {
        result = (HashTable)super.clone();
        // result.buckets = new Entry[this.buckets.length];
        result.buckets = createNewBuckets();
        for(int i = 0; i < this.buckets.length; i++) {
            if(buckets[i] != null) {
                result.buckets[i] = this.buckets[i].deepCopy(); // deep copy
            }
        }
        return result;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

protected Entry[] createNewBuckets() {
    ...
}

 

3. 고수준 메서드를 이용하는 경우 🦸‍♂️

// 고수준 메서드 예시
result.get(key);
result.put(key, value);

  super.clone을 호출하여 얻은 객체의 모든 필드를 초기 상태로 설정하고 원본 객체의 상태를 다시 생성하는 고수준 메서드를 사용할 수도 있다. 그러면 원본과 복사본의 내용이 같게 된다.

  하지만 이 방법은 저수준에서 바로 처리할 때보다 느리다. 그리고 Cloneable 아키텍처의 기초가 되는 필드 단위 객체 복사를 우회하기 때문에 전체 Cloneable 아키텍처와는 어울리지 않는 방식이기도 하다.

 

4. 추가 주의 사항 👨‍💻

1. 상속용 클래스는 Cloneable을 구현해서는 안 된다.

  그 이유는 해당 클래스를 확장하려는 프로그래머에게 clone을 올바르게 구현하도록 많은 부담을 주기 때문이다. 그래서 아래와 같은 2가지 방법으로 그 부담을 덜어줄 수 있다.

1. 추상클래스에서 clone을 구현해 주고 하위 클래스에서 구현을 하지 않도록 하기.
2. 하위클래스에서 아예 clone을 구현하지 못하도록 막기
   이 방식은 마치 Object를 바로 상속할 때처럼 Cloneable 구현 여부를 하위 클래스에서 선택하도록 해준다.

public abstract class Shape implements Cloneable {

	private int area;
	
	public abstract int getArea();
	
	// 방법 1
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
	// 방법 2
	@Override
	protected final Object clone() throws CloneNotSupportedException {
		throw new CloneNotSupportedException();
	}
}

2. 스레드 안전 클래스로 만들어 줘야 한다면 동기화도 처리해줘야 한다.

@Override
public synchronized HashTable clone() {
    ...
}

3. Deep Copy 방법에서 살펴본 것처럼 clone메서드 안에서는 재정의 할 수 있는 메서드를 만들지 않아야 한다.

 

5. 결론 👨‍🏭

  지금까지 쭉 읽어왔다면 느꼈겠지만, 굳이 이렇게 해야 할까? 매우 복잡한 경우가 많다...

  Cloneable을 이미 구현한 클래스를 확장한다면 어쩔 수 없이 clone을 잘 작동하도록 구현해야 한다. 그렇지 않은 상황에서는 아래와 같이 복사 생성자(= 변환 생성자)와 복사 팩터리(= 변환 팩터리)라는 더 나은 객체 복사 방식을 사용하도록 하자.

public class User {
	private final String name;
	private final int age;
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	// 복사 생성자
	public User(User user) {
		this.name = user.name;
		this.age = user.age;
	}
	
	// 복사 팩터리
	public static User copyFactory(User user) {
		User copyUser = new User(user.name, user.age);
		return copyUser;
	}
}

  복사 생성자와 복사 팩터리를 이용한다면 다음과 같은 장점이 있다. (지금까지 고려해 줬던 것들의 반대라고 생각하면 이해하기 쉬울 것이다.)

1. 언어 모순적이고 위험천만한 객체 생성 메커니즘(생성자를 쓰지 않는 방식)을 사용하지 않아도 된다.
2. 엉성하게 문서화된 규약에 기대지 않아도 된다. (clone 규약)
3. 정상적인 final 필드 용법과 충돌하지 않는다.
4. 불필요한 검사 예외를 던지지 않는다.
5. 형변환도 필요하지 않는다.
6. '인터페이스' 타입의 인스턴스를 인수로 받을 수 있다.
   원본의 구현 타입에 얽매이지 않고 복제본의 타입을 직접 선택할 수 있다.

public static void main(String[] args) {
    Set<String> hashSet = new HashSet<>();
    Set<String> treeSet = new TreeSet<>(hashSet);
}

----------

// 인수를 확인하자.
public TreeSet(Collection<? extends E> c) {
    this();
    addAll(c);
}

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 수강하고 작성한 것입니다.