[이펙티브 자바] Item10. equals는 일반 규약을 지켜 재정의하라. (대칭성, 반사성, 추이성)

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

 

equals 메서드를 재정의할 때는 반드시 일반 규약을 따라야 한다. 

 

equals 규약

 

1️⃣ 반사성 reflexivity 

: null 이 아닌 모든 참조 값 x에 대해 x.equals(x) == true 이다. 

단순히 말하면 객체는 자기 자신과 같아야 한다는 뜻이다. 이 요건은 대부분?이 아니라 솔직히 거의 다 만족하는 조건일텐데 만약 이 요건을 어긴 클래스가 있다면 클래스의 인스턴스를 컬렉션에 넣은 다음 contains 메서드를 호출하면 방금 넣은 인스턴스가 없다고 답할 것이다. 

 

 

2️⃣ 대칭성 symmetry 

: null 이 아닌 모든 참조 값 x, y 에 대해 x.equals(y) 가 true이면 y.equals(x)도 true이다. 

x.equals(y) == y.equals(x) 

대칭성은 즉 두 객체는 서로에 대한 동치 여부에 똑같이 답해야 한다는 뜻이다. 

 

public 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) = " + cis.equals(polish));
      
      System.out.println("polish.equals(cis) = " + polish.equals(cis)); // A.equals(B) != B.equals(A) 대칭성 x
      
      
      List<CaseInsensitiveString> list = new ArrayList<>();
      list.add(cis);
      
      System.out.println("list.contains(polish) = " + list.contains(polish));
   }
   
   // 수정된 equals
// @Override
// public boolean equals(Object obj)
// {
//    return obj instanceof CaseInsensitiveString &&  ((CaseInsensitiveString) obj).s.equalsIgnoreCase(s);
// }
}

->  CaseInsensitiveString 이 클래스는 대소문자를 구별하지 않는 문자열을 구현한 클래스이다. 

 

System.out.println("cis.equals(polish) = " + cis.equals(polish));

-> 이렇게 하면 true를 반환하겠지만 

 

System.out.println("polish.equals(cis) = " + polish.equals(cis));

-> String의 equals는 CaseInsensitiveString 클래스의 존재를 모르기 때문에 당연히 false를 반환한다. 

 

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

그러므로 이 equals는 대칭성을 위반하는 잘못된 메서드이다. 

 

@Override
public boolean equals(Object obj)
{
   return obj instanceof CaseInsensitiveString &&  ((CaseInsensitiveString) obj).s.equalsIgnoreCase(s);
}

위에 equals에서 수정된 equals 메서드이다. 

 

public static void main(String[] args)
{
   CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
   CaseInsensitiveString cis2 = new CaseInsensitiveString("polish");
   String polish = "polish";
   System.out.println("cis.equals(polish) = " + cis.equals(polish));
   
   System.out.println("polish.equals(cis) = " + polish.equals(cis)); // A.equals(B) != B.equals(A) 대칭성 x
   
   System.out.println("cis.equals(cis2) = " + cis.equals(cis2));
   System.out.println("cis2.equals(cis) = " + cis2.equals(cis));
   
   
   List<CaseInsensitiveString> list = new ArrayList<>();
   list.add(cis);
   
   System.out.println("list.contains(polish) = " + list.contains(polish));
}

equals를 수정한 다음 실행하면 cis.equals(cis2) == cis2.equals(cis)를 만족하는 것을 확인할 수 있다. 또한 cis.equals(polist) == false, polist.equals(cis) == false 반환되는 것도 확인할 수 있다. 

 

 

 

 

3️⃣ 추이성 transitivity 

: null 이 아닌 모든 참조 값 x, y, z에 대해 x.equals(y)가 true 이고, y.equals(z)도 true이면 x.equals(z)도 true이다. 

x.equals(y) && y.equals(z) => x.equals(z) 

추이성은 이제 첫번째 객체와 두번째 객체가 같고, 두번째 객체와 세번째 객체가 같다면, 첫번째 객체와 세번째 객체도 같아야 한다는 뜻이다. 

 

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;
   }
   
   @Override
   public int hashCode()
   {
      return 31 * x + y;
   }
}

-> Point는 2차원에서 점을 표현하는 클래스이다. 

 

public class ColorPoint extends Point
{
   private final Color color;
   
   public ColorPoint(int x, int y, Color color)
   {
      super(x, y);
      this.color = color;
   }
   
   // 잘못된 코드 : 대칭성 위배
   @Override
   public boolean equals(Object obj)
   {
      if (!(obj instanceof ColorPoint)) {
         return false;
      }

      return super.equals(obj) && ((ColorPoint) obj).color == color;
   }
 }

그리고 ColorPoint는 Point를 확장해서 색상 필드를 추가한 클래스이다. 

equals를 재정의해서 위치와 색상이 같을 때만 true를 반환하도록 했다. 

 

public static void main(String[] args)
{
   // 첫번째 equals는 대칭성을 위배한다.
   Point point = new Point(1, 2);
   ColorPoint colorPoint = new ColorPoint(1, 2, Color.RED);
   System.out.println(point.equals(colorPoint) + " " + colorPoint.equals(point));
   
 }

이 코드를 실행해보면 treu, false가 출력되는데 

Point의 equals는 색상을 무시하기 때문에 비교했을 때 true를 반환하지만, ColorPoint의 equals는 입력 매개변수의 클래스 종류마다 다르기 때문에 매번 false를 반환할 것이다. 

 

@Override
public boolean equals(Object obj)
{
   if (!(obj instanceof Point)) {
      return false;
   }
   
   // obj가 일반 Point이면 color를 무시하고 비교한다.
   if (!(obj instanceof ColorPoint)) {
      return obj.equals(this);
   }
   
   // obj가 ColorPoint이면 색상까지 비교한다.
   return super.equals(obj) && ((ColorPoint) obj).color == color;
   
}

그렇다면 이번엔 Point라면 색상을 무시하고 비교하도록 설정했다. 

그리고 ColorPoint라면 색상까지 비교하도록 설정했다. 

 

    public static void main(String[] args)
   {
      
      // 두번째 equals는 추이성을 위배한다.
      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));
   }

p1.equals(p2) == true, p2.equals(p3) == true 라서 추이성을 생각하면 p1.equals(p3) == true 여야 하지만 결과는 false 이다. 

즉, 추이성이 깨진다. p1과 p2는 색상을 고려하지 않았지만, p1와 p3 비교해서는 색상까지 고려했기 때문이다..!

 

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 == null || obj.getClass() != getClass()) {
         return false;
      }

      Point p = (Point) obj;
      return p.x == x && p.y == y;
   }
   
   @Override
   public int hashCode()
   {
      return 31 * x + y;
   }
}

이번에는 Point의 equals를 instanceof 로 검사하는게 아닌 getClass로 검사하면 구체 클래스를 확장해 새로운 값을 추가하면서 equals 규약을 지킬 수 있어 보이지만 이건 리스코프 치환 원칙을 위배하는 코드이다. 

 

public class CounterPoint extends Point
{
   private static final AtomicInteger counter = new AtomicInteger();
   
   public CounterPoint(int x, int y)
   {
      super(x, y);
      counter.incrementAndGet();
   }
   
   public static int numberCreated()
   {
      return counter.get();
   }
}

public class CounterPointTest
{
   // 단위 원 안의 모든 점을 포함하도록 unitCircle을 초기화한다.
   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 CounterPoint(1, 0);
      
      System.out.println("onUnitCircle(p1) = " + onUnitCircle(p1)); // true 출력
      
      // true를 출력해야 하지만, Point의 equals가 getClass를 사용해 작성되었다면 false를 출력한다.
      System.out.println("onUnitCircle(p2) = " + onUnitCircle(p2));
   }
   
   
   
}

Point의 하위 클래스인 CounterPoint도 Point이므로 어디서든 Point로써 활용될 수 있어야 하는데 지금은 onUnitCircle(p2)를 하면 false가 반환된다. 왜냐하면 Set을 포함하여 대부분의 컬렉션은 contains할 때 equals 메서드를 이용하는데 CounterPoint의 인스턴스는 Point와 같을 수 없기 때문이다. 

@Override
public boolean equals(Object obj)
{
   if (!(obj instanceof Point)) {
      return false;
   }

   Point p = (Point) obj;
   return p.x == x && p.y == y;
}

대신 Point의 equals 를 instanceOf 기반으로 올바르게 구현했다면 onUnitCirCle 메서드가 제대로 동작할 것이다. (CounterPoint는 필드를 추가하지 않았기 때문에) 

 

책에서도 언급하고 있는데 

구체 클래스를 확장해 새로운 값을 추가하면서 equals 규약을 만족시킬 방법은 존재하지 않는다!! 

 

 

4️⃣ 일관성 consistency 

: null 이 아닌 모든 참조 값 x, y에 대해 x.equals(y)를 반복해서 호출하면 항상 true를 반환하거나 항상 false를 반환한다. 

x.equals(y) == x.equals(y) 

 

 

5️⃣ null 아님 

: null 이 아닌 모든 참조 값 x에 대해 x.equals(null)은 false 이다.

x.equals(null) == false