(이펙티브 자바 3판) 3장 - 모든 객체의 공통 메서드, clone 재정의는 주의해서 진행해라

public interface Comparable<T> {
    public int compareTo(T o);
}

public class Point {
    int x;
    int y;
    
    public void print() {
        System.out.println(String.format("x: %d\ny: %d", x, y));
    }
}

public class Point implements Comparable<Point> {
    int x;
    int y;
    
    public void print() {
        System.out.println(String.format("x: %d\ny: %d", x, y));
    }
    
    @Override
    public int compareTo(final Point o) {
        return 0;
    }
}

public interface Cloneable {
}

@HotSpotIntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

@Test
void copyTest() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    final var cloneMethod = Point.class.getDeclaredMethod("clone");
    cloneMethod.setAccessible(true);

    final var instance = new Point();
    final var copy = cloneMethod.invoke(instance);
}

public class Point {
    private int x;
    private int y;

    public Point(final int x, final int y) {
        this.x = x;
        this.y = y;
    }
    
    // 자바 5에 추가된 covariant return typing(공변 반환 타이핑, 리턴 타입이 서브 클래스의 범위 안에 있으면 된다는 내용) 덕분에 
    // 해당 메서드를 사용하는 사용자가 직접 형변환을 할 필요가 사라졌다.  
    @Override
    public Point clone() {
        return (Point) super.clone();
    }
}

/* Thrown to indicate that the clone method in class Object has been called to clone an object,
 * but that the object's class does not implement the Cloneable interface.
 */

public class Point implements Cloneable {
    private int x;
    private int y;

    public Point(final int x, final int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public Point clone() {
        return (Point) super.clone();
    }
}

public class Point implements Cloneable {
    private int x;
    private int y;

    public Point(final int x, final int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public Point clone() {
        try {
            return (Point) super.clone();
        } catch (final CloneNotSupportedException e) {
            // Cloneable 인터페이스를 구현한 이상 이 코드는 절대 실행되지 않는다.
            throw new AssertionError();
        }
    }
}

// Object의 clone 메서드를 호출하는 게 아니므로 CloneNotSupportedException을 던지지 않기 때문에 Cloneable 인터페이스를 구현할 필요가 없다.
public class Point {
    private int x;
    private int y;

    public Point(final int x, final int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public Point clone() {
        // 좀 더 메서드가 깔끔해진 것 같다.
        return new Point(this.x, this.y);
    }
    
    // 실제로 객체가 잘 복사됐는지 비교하기 위해 equals 메서드를 오버라이딩
    @Override
    public boolean equals(final Object o) {
        if (this == o) return true;
        if (!(o instanceof Point)) return false;
        
        final var point = (Point) o;
        if(this.x != point.x) return false;
        if(this.y != point.y) return false;
        
        return true;
    }
}

@Test
void testClone() {
    final var point = new Point(1, 2);
    final var clone = point.clone();

    // 내부적으로 동일 연산자를 통해 다른 인스턴스인지 비교 
    assertNotSame(point, clone);
    
    // 클래스 정보도 똑같다.
    assertEquals(point.getClass(), clone.getClass());
    
    // 내부적으로 동등 연산자인 equals 메서드를 통해 논리적 동치성을 보장하는지 비교
    assertEquals(point, clone);
}

public class ColorPoint extends Point {
    private String color;

    public ColorPoint(final int x, final int y, final String color) {
        super(x, y);
        this.color = color;
    }

    @Override
    public Object clone() {
        // java.lang.ClassCastException을 유발한다.
        // super.clone() 메서드로 얻어온 메서드의 반환 타입은 Point 생성자를 통해 생성된 Point 클래스 인스턴스이다. 
        // 부모 클래스를 가지고 자식 클래스로 형변환 했을 때 자식 클래스에 필요한 필수 필드들이 들어가있지 않을 가능성이 존재해서
        // 변환된 클래스가 제대로 작동하리란 보장이 없기 때문에 위와 같이 예외를 던지는 게 아닐까?
        // 따라서 형 변환을 할 수 없기 때문에 자식 클래스에서 필드가 추가된 경우에는 제대로 clone 조차 하지 못한다.
        // return (ColorPoint) super.clone();
        return super.clone();
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) return true;
        if (!(o instanceof ColorPoint)) return false;
        if (!super.equals(o)) return false;

        final var colorPoint = (ColorPoint) o;
        return Objects.equals(color, colorPoint.color);
    }
}

@Test
void testColorClone() {
    final var colorPoint = new ColorPoint(1, 2, "red");
    final var clone = colorPoint.clone();

    // 내부적으로 동일 연산자를 통해 다른 인스턴스인지 비교
    assertNotSame(colorPoint, clone);

    // 클래스 정보도 부모의 생성자를 통해서 만들었기 때문에 자식 클래스의 정보를 가지지 못한다.
    assertNotEquals(colorPoint.getClass(), clone.getClass());

    // 내부적으로 동등 연산자인 equals 메서드를 통해 논리적 동치성을 보장하는지 비교하는데 red는 제대로 복사되지 않았음
    assertNotEquals(colorPoint, clone);
}

public class Type implements Cloneable {
    private int number;
    private Type[] children;

    public Type(final int number, final Type[] children) {
        this.number = number;
        this.children = children;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(final int number) {
        this.number = number;
    }

    public Type[] getChildren() {
        return children;
    }

    public void setChildren(final Type[] children) {
        this.children = children;
    }
    
    @Override
    public Type clone() {
        try {
            return (Type) super.clone();
        } catch (final CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) return true;
        if (!(o instanceof Type)) return false;

        final var type = (Type) o;
        if(this.number != type.number) return false;
        if(!Arrays.equals(this.children, type.children)) return false;
        return true;
    }
}

@Test
void test() {
    final var original = new Type(3, new Type[]{new Type(1, null), new Type(2, null)});
    final var clone = original.clone();

    // 원본 객체에서 첫 번째 자식을 다른 자식으로 대체
    original.getChildren()[0] = new Type(4, null);

    // clone과 original이 완전 독립된 객체라면 이 테스트는 통과해선 안 된다.
    assertEquals(original, clone);
}

@Override
public Type clone() {
    try {
        final var clone = (Type) super.clone();

        // 배열의 clone 메서드는 공변 반환 타이핑도 제대로 적용했고 unchecked exception인 CloneNotSupportedException도 제대로 처리한 유일한 예라고 책에서 설명하고 있다.
        // 하지만 가변 객체를 참조하는 필드는 final로 선언하라는 용법과는 상반된다.  
        // final로 선언해도 완전 불변 객체를 만드는 것은 아니지만 적어도 레퍼런스 값이 바뀌는 경우는 막을 수 있으니까 final로 선언하라는 용법이 있는 것으로 알고 있는데
        // 이 용법을 사용하면 가변 객체의 clone을 할당할 수 없다.
        clone.children = this.children.clone();
        return clone;
    } catch (final CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

@Test
void test() {
    final var original = new Type(3, new Type[]{new Type(1, null), new Type(2, null)});
    final var clone = original.clone();

    // 자식을 재할당하는 게 아니라 자식의 필드를 변경
    original.getChildren()[0].setNumber(2);

    // clone과 original이 완전 독립된 객체라면 이 테스트는 통과해선 안 된다.
    assertEquals(original, clone);
}

@Override
public Type clone() {
    try {
        final var clone = (Type) super.clone();

        // 배열의 clone 메서드는 공변 반환 타이핑도 제대로 적용했고 unchecked exception인 CloneNotSupportedException도 제대로 처리한 유일한 예라고 책에서 설명하고 있다.
        clone.children = childrenDeepCopy(clone.children);
        return clone;
    } catch (final CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

private Type[] childrenDeepCopy(final Type[] parent) {
    final var shallowClone = parent.clone();
    return Arrays.stream(shallowClone)
                 .map(origin -> new Type(origin.number, origin.hasChildren() ? childrenDeepCopy(origin.children) : null))
                 .toArray(Type[]::new);
}

private boolean hasChildren() {
    return children != null && children.length != 0;
}

@Override
public Type clone() throws CloneNotSupportedException {
    // 자식 클래스에서는 super.clone()을 통해 clone 메서드를 재정의 하니까 무조건 부모 클래스의 clone 메서드를 호출하게 돼있다.
    throw new CloneNotSupportedException();
}

// 복사 생성자
public Type(final Type type) { ... }

// 복사 팩터리 (복사 생성자를 모방한 정적 팩터리)
public static Type newInstance(final Type type) { ... }