Location 클래스

코드 설명

/****************************************************************************** 
* Location 객체는 2차원 평면상의 위치를 추적합니다.
******************************************************************************/
public class Location implements Cloneable
{
   private double x; // 이 Location의 x 좌표
   private double y; // 이 Location의 y 좌표

   /**
   * 지정된 좌표로 Location 객체를 생성합니다.
   * @param xInitial
   *   이 Location의 초기 x 좌표
   * @param yInitial
   *   이 Location의 초기 y 좌표
   * @postcondition
   *   이 Location은 지정된 좌표로 초기화됩니다.
   **/   
   public Location(double xInitial, double yInitial)
   {
      x = xInitial;
      y = yInitial;
   }
   
   /**
   * 이 Location의 복사본을 생성합니다.
   * @param - 없음
   * @return
   *   이 Location과 동일한 값을 가지는 복사본을 반환합니다.
   *   이후 복사본과 원본을 각각 수정해도 서로에게 영향을 주지 않습니다.
   *   반환 타입은 Java 5.0부터 허용되는 Location입니다 (Object 아님).
   **/
   public Location clone()
   {
      Location answer;
      
      try
      {
         answer = (Location) super.clone();
      }
      catch (CloneNotSupportedException e)
      {
         // 이 예외는 발생하지 않아야 하지만,
         // 만약 발생한다면 아마도 Cloneable을 implements하지 않았기 때문입니다.
         throw new RuntimeException("이 클래스는 Cloneable을 구현하지 않았습니다.");
      }
      
      return answer;
   }

   /**
   * 두 Location 사이의 거리를 계산합니다.
   * @param p1
   *   첫 번째 Location
   * @param p2
   *   두 번째 Location
   * @return
   *   p1과 p2 사이의 거리
   * @note
   *   거리가 오버플로우하면 Double.POSITIVE_INFINITY를,
   *   어느 하나라도 null이면 Double.NaN을 반환합니다.
   **/
   public static double distance(Location p1, Location p2)
   {
      double a, b, c_squared;

      // 어느 한 Location이 null인지 확인
      if ((p1 == null) || (p2 == null))
         return Double.NaN;
               
      // x, y 좌표 차이 계산
      a = p1.x - p2.x;
      b = p1.y - p2.y;
      
      // 피타고라스 정리를 이용하여 거리 제곱 계산
      c_squared = a * a + b * b;
      
      return Math.sqrt(c_squared);
   } 
   
   /**
   * 이 Location과 다른 객체를 비교하여 동일한지 확인합니다.
   * @param obj
   *   비교할 객체
   * @return
   *   obj가 같은 x, y 값을 가진 Location 객체이면 true, 아니면 false
   * @note
   *   obj가 null이거나 Location이 아니면 false
   **/
   public boolean equals(Object obj)
   {
      if (obj instanceof Location)
      {
         Location candidate = (Location) obj;
         return (candidate.x == x) && (candidate.y == y);
      }
      else
         return false;
   }

   /**
   * 이 Location의 x 좌표를 반환합니다.
   * @param - 없음
   * @return
   *   x 좌표 값
   **/
   public double getX()
   {
      return x;
   }

   /**
   * 이 Location의 y 좌표를 반환합니다.
   * @param - 없음
   * @return
   *   y 좌표 값
   **/
   public double getY()
   {
      return y;
   }

   /**
   * 두 Location의 중간 위치를 반환합니다.
   * @param p1
   *   첫 번째 Location
   * @param p2
   *   두 번째 Location
   * @return
   *   p1과 p2의 중간 위치를 나타내는 Location
   * @note
   *   p1 또는 p2가 null이면 null을 반환합니다.
   **/
   public static Location midpoint(Location p1, Location p2)
   {
      double xMid, yMid;
      
      // null 체크
      if ((p1 == null) || (p2 == null))
         return null;
      
      // 중간 좌표 계산
      xMid = (p1.x / 2) + (p2.x / 2);
      yMid = (p1.y / 2) + (p2.y / 2);
      
      // 새로운 Location 생성 및 반환
      Location answer = new Location(xMid, yMid);       
      return answer;
   }

   /**
   * 이 Location을 원점을 기준으로 시계 방향으로 90도 회전시킵니다.
   * @param - 없음
   * @postcondition
   *   이 Location은 원점을 기준으로 시계 방향으로 90도 회전된 상태가 됩니다.
   **/
   public void rotate90()
   {
      double xNew;
      double yNew;
      
      // 시계 방향 90도 회전: x' = y, y' = -x
      xNew = y;
      yNew = -x;
      x = xNew;
      y = yNew;
   }

   /**
   * 이 Location을 x축, y축 방향으로 각각 지정된 만큼 이동시킵니다.
   * @param xAmount
   *   x축 방향으로 이동할 거리
   * @param yAmount
   *   y축 방향으로 이동할 거리
   * @postcondition
   *   Location이 지정된 거리만큼 이동됩니다.
   * @note
   *   이동 결과로 좌표가 Double.MAX_VALUE를 넘거나  
   *   최솟값보다 작아질 수 있으며, 이 경우  
   *   getX 또는 getY 호출 시 무한대 값을 반환할 수 있습니다.
   **/
   public void shift(double xAmount, double yAmount)
   {
      x += xAmount;
      y += yAmount;
   }              

   /**
   * 이 Location의 문자열 표현을 반환합니다.
   * @param - 없음
   * @return
   *   (x=값  y=값) 형식의 문자열
   **/
   public String toString()
   {
       return "(x=" + x + "  y=" + y + ")";
   }
}

• 실제 좌표의 연산을 다룰 수 있도록 만들어진 클래스

public class Location implements Cloneable

• clone() 메서드를 사용하기 위해서 Clonable인터페이스가 필요하다.
• location은 double형 x, y 좌표를 멤버 변수로 가지는 2차원 좌표의 객체이다.

public Location(double xInitial, double yInitial)

• location 객체의 x와 y 좌표를 초기화 해준다.

public Location clone()

• 객체를 복사하여서 복사본을 만들어서 반환한다.
• super.clone()을 사용하여서 얕은 복사를 수행하고, 반환타입은 Location으로 해준다.
• CloneNotSupportedException이 발생하면 예외처리를 발생한다.

public static double distance(Location p1, Location p2)

• 두 점간의 유클리드 거리를 구하여서 반환해 준다.
• 만약 둘 중에 하나라도 null이면 Double.NaN, 즉 수학적 계산이 불가능하다는 것을 반환해 준다.
• 오버플로우 값에 대한 예외 처리가 없기 때문에 오버플로우에 유의해야 한다.

public boolean equals(Object obj)

• x좌표와 y좌표가 각각 동일한지 비교해 준다.
• obj가 Location타입이고, 좌표값이 모두 같으면 true를 반환해 준다.

public double getX()
public double getY()

• 각각 x, y좌표를 반환해 준다.

public static Location midpoint(Location p1, Location p2)

• 두 점 사이의 중간점을 계산하여서 Location 객체로 반환해 준다.

public void rotate90()

• 원점을 기준으로 하여서 시계 방향으로 90도 회전시켜 준다.
• x'=y
• y'=-x
• 예를 들어서 (2,3)은 (3,-2)가 된다.

public void shift(double xAmount, double yAmount)

• x축, y축 방향으로 이동시켜 준다.
• (2, 3). shift(5, -1) → (7, 2)처럼 값이 나오게 된다.

public String toString()

• Location 객체를 문자열로 변환하여서 반환해 준다.
• 예: (x=3.5 y=7.2)

예제 코드

public class LocationTest {
    public static void main(String[] args) {
        Location a = new Location(3, 4);
        Location b = new Location(6, 8);

        System.out.println("a: " + a);  // (x=3.0  y=4.0)
        System.out.println("b: " + b);  // (x=6.0  y=8.0)

        System.out.println("거리: " + Location.distance(a, b));  // 5.0

        Location mid = Location.midpoint(a, b);
        System.out.println("중간점: " + mid);  // (x=4.5  y=6.0)

        a.rotate90();
        System.out.println("a 회전 후: " + a); // (x=4.0  y=-3.0)

        a.shift(1, 2);
        System.out.println("a 이동 후: " + a); // (x=5.0  y=-1.0)

        Location c = a.clone();
        System.out.println("복사된 c: " + c); // (x=5.0  y=-1.0)

        System.out.println("a와 c는 같은가? " + a.equals(c)); // true
    }
}

a: (x=3.0  y=4.0)
b: (x=6.0  y=8.0)
거리: 5.0
중간점: (x=4.5  y=6.0)
a 회전 후: (x=4.0  y=-3.0)
a 이동 후: (x=5.0  y=-1.0)
복사된 c: (x=5.0  y=-1.0)
a와 c는 같은가? true