Object는 객체를 만들 수 있는 구체 클래스이지만 기본적으로 상속해서 사용하도록 설계되어 있다. Object에서 final이 아닌 메서드(equals, hashCode, toString, clone, finalize)는 모두 재정의(overriding)을 염두에 두고 설계된 것이라 재정의 시 지켜야할 일반 규약이 명확히 정의되어 있다.

Item10. equals는 일반 규약을 지켜 재정의하라

equals를 재정의 하지 않는 것이 최선이다. 아래의 경우에 해당한다면 equals를 재정의 할 필요가 없다.

각 인스턴스가 본질적으로 고유하다 ex) 싱글톤은 그 자체로 고유할 수 밖에 없다. enum도 기본적으로 단 1개만 생성된다.
인스턴스의 ‘논리적 동치성’을 검사할 필요가 없다 ex 1) 50달러 짜리 2개가 존재한다고 했을 때, 이 둘은 같을까? 기본적으로 정의되어 있는 equals에서는 이 둘을 다르게 정의한다. 어떤 가치를 볼 것인지에 따라 이 둘을 같게 또는 다르게 볼 수 있다.

ex 2) 동치성을 검사할 필요가 없는 경우 문자열 “Hello” == “Hello”

상위 클래스에서 재정의한 equals가 하위 클래스에도 적절하다 ex) List, Set을 상속해서 구현할 때 List → AbstractList에서 equals가 구현 Set → AbstractSet에서 equals가 구현
클래스가 private이거나 package-private이고 equals 메서드를 호출할 일이 없다

equals를 재정의 해야 한다면 반드시 Object 명세에 적힌 일반 규약을 따라야 한다.

반사성 : A.equals(A) == true

대칭성 : A.equals(B) == B.equals(A) ex) CaseInsensitiveString i) 대칭성 위배

// 대칭성 위배 54-55 페이지
public final class CaseInsensitiveString {
    private final String s;

    public CaseInsensitiveString(String s) {
        this.s = Objects.requireNonNull(s);
    }

    //대칭성 위배
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString) obj).s);
        }
        if (obj instanceof String) {
            return s.equalsIgnoreCase((String) obj);
        }
        return false;
    }
    
    public static void main(String[] args) {
        CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
        String polish = "polish";
        **System.out.println(cis.equals(polish));**

        List<CaseInsensitiveString> list = new ArrayList<>();
        list.add(cis);
        **System.out.println(list.contains(polish));**
    }
 }

스크린샷 2024-06-02 09.07.20.png

이렇게 쓰겠다는 것은 CaseInsensitiveString을 String과 동급으로 쓰겠다는 의도가 담겨 있다.(잘못된 생각)
CaseInsensitivieString은 String을 알고 있기 때문에 처리가 가능하지만 String은 CaseInsensitiveString을 알지 못하기 때문에 처리가 불가능하다.

ii) 수정된 equals 메서드(56페이지)

// 대칭성 위배 54-55 페이지
public final class CaseInsensitiveString {
    private final String s;

    public CaseInsensitiveString(String s) {
        this.s = Objects.requireNonNull(s);
    }

    //수정된 equals 메서드(56페이지)
    @Override
    public boolean equals(Object obj) {
        **return (obj instanceof CaseInsensitiveString) &&
                (((CaseInsensitiveString) obj).s.equalsIgnoreCase(s));**
    }

    public static void main(String[] args) {
        CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
        String polish = "polish";
        **System.out.println(cis.equals(polish));**

        List<CaseInsensitiveString> list = new ArrayList<>();
        list.add(cis);
        **System.out.println(list.contains(polish));**
    }
}

스크린샷 2024-06-02 09.39.43.png

본인이 CaseInsensitiveString이라면, CaseInsensitivieString만을 지원해야 한다. 다른 타입을 지원해서는 안된다.
다른 타입을 지원하기 시작하면 대칭성이 깨 지기 쉽다.

추이성 : A.equals(B) && B.equals(C), A.equals(C) ex) ColorPoint i) 대칭성 위배

public enum Color {
    RED, ORANGE, YELLOW, GREEN, BLUE
}

// 단순한 불변 2차원 정수 점(Point) 클래스 (56페이지)
public class Point {
    private final int x;
    private final int y;

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

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Point)) {
            return false;
        }
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }
}

//Point에 값 컴포넌트(Color)를 추가 (56페이지)
public class ColorPoint extends Point{
    private final Color color;

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

    //코드 10-2 잘못된 코드 - 대칭성 위배 (57페이지)
    //Point는 부모 속성으로 비교하고 Color는 따로 속성 비교를 하면 되지 않을까?
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ColorPoint)) {
            return false;
        }
        return super.equals(obj) && ((ColorPoint) obj).color == color;
    }

    public static void main(String[] args) {
        Point p = new Point(1, 2);
        ColorPoint cp = new ColorPoint(1, 2, Color.RED);
        System.out.println(**p.equals(cp) + " " + cp.equals(p)**);
    }
}

스크린샷 2024-06-02 12.59.44.png

p.equals(cp)를 할때 cp는 Point을 상속 받았기 때문에 Point의 (obj instanceof Point)의 true에 해당한다.
ColorPoint 입장에서 Point를 바라보면 ColorPoint가 아니다.(ColorPoint가 더 구체적인 클래스) 그래서 false가 나오게 된다.

ii) 추이성 위배

public enum Color {
    RED, ORANGE, YELLOW, GREEN, BLUE
}

// 단순한 불변 2차원 정수 점(Point) 클래스 (56페이지)
public class Point {
    private final int x;
    private final int y;

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

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Point)) {
            return false;
        }
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }
}

//Point에 값 컴포넌트(Color)를 추가 (56페이지)
public class ColorPoint extends Point{
    private final Color color;

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

    // 코드 10-3 잘못된 코드 - 추이성 위배! (57페이지)
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Point)) {
            return false;
        }

        // obj가 일반 Point면 색상을 무시하고 비교한다.
        if (!(obj instanceof ColorPoint)) {
            return obj.equals(this);  //Point
        }

        // obj가 ColorPoint면 색상까지 비교한다.
        return super.equals(obj) && ((ColorPoint) obj).color == color;
    }

    public static void main(String[] args) {
        // 두 번째 equals 메서드(코드 10-3)는 추이성을 위배한다.
        ColorPoint p1 = new ColorPoint(1, 2, Color.RED);
        Point p2 = new Point(1, 2);
        ColorPoint p3 = new ColorPoint(1, 2, Color.BLUE);
        System.out.printf("%s %s %s%n", p1.equals(p2), p2.equals(p3), p1.equals(p3));
    }
}

스크린샷 2024-06-02 14.22.15.png

굉장히 위험한 코드, ColorPoint와 동일한 레벨에 있는 서브 클래스를 만든 다음 서로 equals를 구현하면 서로 equals를 호출하면서 method가 호출될 때마다 stack이 쌓이면서 stackoverflow가 발생하게 된다.
p1과 p2는 같다고 나올 것이다. (Color가 무시되기 때문에) p2와 p3도 같다고 생각을 하게 될 것이다. p1과 p3를 비교할 때에는 ColorPoint이기 때문에 Color까지 비교하게 되고 서로 다르다고 생각하게 된다.

iii) 리스코프 치환 원칙 위배

public enum Color {
    RED, ORANGE, YELLOW, GREEN, BLUE
}

// 단순한 불변 2차원 정수 점(Point) 클래스 (56페이지)
public class Point {
    private final int x;
    private final int y;

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

    // 잘못된 코드 - 리스코프 치환 원칙 위배 (59페이지)
    // ColorPoint는 ColorPoint 끼리 같고, Point는 Point 끼리 같아야 하지 않을까?
    @Override
    public boolean equals(Object obj) {
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }
}

public class CounterPointTest {
    private static final Set<Point> unitCircle = Set.of(
            new Point(1, 0), new Point(0, 1),
            new Point(-1, 0), new Point(0, -1)
    );

    public static boolean onUnitCircle(Point p) {
        return unitCircle.contains(p);
    }

    public static void main(String[] args) {
        Point p1 = new Point(1, 0);
        Point p2 = new Point( 1, 0);

        //true를 출력한다.
        System.out.println(onUnitCircle(p1));

        //true를 출력해야 하지만, Point의 equals가 getClass를 사용해 작성되었다면 그렇지 않다.
        System.out.println(onUnitCircle(p2));
    }
}

스크린샷 2024-06-02 22.12.01.png

리스코프 치환 원칙 : 상위 타입에서 동작 하는 코드는 하위 타입의 인스턴스를 주더라도 그대로 동작해야 한다.

ex) 대칭성 위배 예제. Timestamp, date

    public static void main(String[] args) throws MalformedURLException {
        long time = System.currentTimeMillis();
        Timestamp timestamp = new Timestamp(time);
        Date date = new Date(time);

        //대칭성 위배! (60페이지)
        System.out.println(date.equals(timestamp));
        System.out.println(timestamp.equals(date));
    }

스크린샷 2024-06-03 19.53.54.png

iiii) Composition 사용(상속이 아닌 필드로 선언)

// 코드 10-5 equals 규약을 지키면서 값 추가하기 (60페이지)
public class ColorPoint {
    private final Point point;
    private final Color color;

    public ColorPoint(int x, int y, Color color) {
        point = new Point(x, y);
        this.color = Objects.requireNonNull(color);
    }

    //이 ColorPoint의 Point 뷰를 반환한다.
    public Point asPoint() {
        return point;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ColorPoint)) {
            return false;
        }
        ColorPoint cp = (ColorPoint) obj;
        return cp.point.equals(point) && cp.color.equals(color);
    }

    @Override
    public int hashCode() {
        return 31 * point.hashCode() + color.hashCode();
    }
}

일관성 : A.equals(B) == A.equals(B)

null-아님 : A.equals(null) == false → 명시적으로 null을 검사하지 말고 묵시적으로 null을 검사하자.

@Overide
public boolean equals(Object o) {
	if (!(o instanceof MyType)) { //null 검사가 이뤄진다.
		return false;
	}
	MyType mt = (MyType) o;
}

equals 구현 방법

== 연산자를 사용해 입력이 자기 자신의 참조인지 확인한다.
instanceof 연산자로 입력이 올바른 타입인지 확인한다.