[이펙티브 자바] Item14. Comparable을 구현할지 고민하라. (Comparable 구현 방법 #1)

 

[이펙티브 자바] Item14. Comparable을 구현할지 고민하라.

[이펙티브 자바] Item14. Comparable을 구현할지 고민하라. (compareTo 기본 규약) (tistory.com)

[이펙티브 자바] Item14. Comparable을 구현할지 고민하라. (compareTo 기본 규약)

여기서 우선 CompareTo에 대한 기본 규약에 대해서 봤고, 이제 compareTo를 구현하는 방법이다. 

 

 

public class PhoneNumber implements Comparable<PhoneNumber>
{
  ...
}

먼저 자연적인 순서 natural order를 제공할 클래스에 implements Comparable<T>를 선언한다. 

Comparable은 타입을 인수로 받는 제네릭 인터페이스이므로 compareTo 메서드에 인수 타입은 컴파일 타임에 정해진다. (입력 인수의 타입을 확인하거나 형변환할 필요가 없다는 뜻) 

 

 

@Override
public int compareTo(PhoneNumber o)
{
   int result = Short.compare(areaCode, o.areaCode);
   if (result == 0) {
      result = Short.compare(prefix, o.prefix);
      
      if (result == 0) {
         result = Short.compare(lineNum, o.lineNum);
      }
   }
   return result;
}

그리고 compareTo 메서드를 재정의한다. 

compareTo 메서드 안에서 기본 타입은 박싱된 기본 타입 compare을 사용해 비교한다. (Short.compare)

 

그리고 이제 비교할 때 핵심 필드가 여러개라면 비교 순서가 중요하다. 

순서를 결정하는데 있어서 가장 중요한 필드를 비교하고 그 값이 0이라면 다음 필드를 비교하는 순서로 이어간다. 

 

 

근데 이제 기존 클래스를 확장하고 필드를 추가하는 경우엔 compareTo 규약을 지킬 수 없다. 

public class Point implements Comparable<Point>
{
   final int x, y;
   
   public Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
   
   public int getX()
   {
      return x;
   }
   
   public int getY()
   {
      return y;
   }
   
   @Override
   public int compareTo(Point o)
   {
      int result = Integer.compare(this.x, o.x);
      if (result == 0) {
         result = Integer.compare(this.y, o.y);
      }
      
      return result;
   }
}

이렇게 상위 클래스에서 Comparable을 implements하고 compareTo 구현했다. 

 

 

 

public class NamedPoint extends Point
{
   final private String name;
   
   public NamedPoint(int x, int y, String name)
   {
      super(x, y);
      this.name = name;
   }
}

그리고 하위 클래스에서 Point 클래스를 상속받고 추가로 name 필드를 추가해서 비교를 하고 싶다고 한다.. 

그러면 다시 Comparable을 구현하고 하고 싶겠지만 그렇게 할 수 없다. 

 

public static void main(String[] args)
{
   NamedPoint p1 = new NamedPoint(1, 0, "hyejin");
   NamedPoint p2 = new NamedPoint(1, 0, "chamo");
   
   Set<NamedPoint> points = new TreeSet<>(new Comparator<NamedPoint>()
   {
      @Override
      public int compare(NamedPoint p1, NamedPoint p2)
      {
         int result = Integer.compare(p1.getX(), p2.getX());
         if (result == 0) {
            result = Integer.compare(p1.getY(), p2.getY());
         }
         if (result == 0) {
            result = p1.name.compareTo(p2.name);
         }
         
         return result;
      }
   });
   
   points.add(p1);
   points.add(p2);
   
   System.out.println("points = " + points);
}

대신 이렇게 생성자에 Comparator를 전달해서 compare를 구현하는 방법이 있긴 한데 비추하는 방법이다. 

-> Composition을 사용하자!! 

 

public class Point implements Comparable<Point>
{
   
   final int x, y;
   
   public Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
   
   @Override
   public int compareTo(Point o)
   {
      int result = Integer.compare(this.x, o.x);
      if (result == 0) {
         result = Integer.compare(this.y, y);
      }
      return result;
   }
}

public class NamedPoint implements Comparable<NamedPoint>
{
   private final Point point;
   
   private final String name;
   
   public NamedPoint(Point point, String name)
   {
      this.point = point;
      this.name = name;
   }
   
   public Point getPoint()
   {
      return this.getPoint();
   }
   @Override
   public int compareTo(NamedPoint o)
   {
      int result = this.point.compareTo(o.point);
      if (result == 0) {
         result = this.name.compareTo(o.name);
      }
      return result;
   }
}

-> Comparable을 구현한 클래스를 확장하고 값 컴포넌트를 추가하고 싶다면 확장하는 대신 독립적인 클래스를 만들고 이 클래스에 원래 클래스 이느턴스를 가리키는 필드를 두고, 그 다음 내부 인스턴스를 반환하는 '뷰' 메서드(getPoint)를 제공하면 된다.