왜 동적 바인딩 대신 정적 바인딩입니까?

Question

저는 정적과 동적의 차이에 관해서는 여전히 약간 혼란 스럽습니다. 내가 아는 바로는 동적 사용 객체를 정적 사용 유형과 런타임 동안 동적으로 해결하는 반면 정적은 컴파일 타임에 사용합니다. this.lastName.compareTo (s1.lastName) 대신 동적 바인딩을 사용 하시겠습니까?

key.compareTo (리스트 [위치-1])

public static void insertionSort (Comparable[] list) 
{ 
    for (int index = 1; index < list.length; index++) 
    { 
     Comparable key = list[index]; 
     int position = index; 
     while (position > 0 && key.compareTo(list[position-1]) < 0) // using dynamic binding 
     { 
      list[position] = list[position-1]; 
      position--; 
     } 
      list[position] = key; 
    } 
} 

이유 (this.lastName.compareTo (s1.lastName)) 정적 바인딩을 동적 바인딩을 사용 사용합니까?

private String firstName; 
private String lastName; 
private int totalSales; 

@Override 
public int compareTo(Object o) { 
    SalePerson s1 = (SalePerson)o; 

    if (this.totalSales > s1.getTotalSales()) 
    { 
     return 1; 
    } 

    else if (this.totalSales < s1.getTotalSales()) 
    { 
     return -1; 
    } 

    else //if they are equal 
    { 
     return (this.lastName.compareTo(s1.lastName)); //why is this static binding?? 

    } 
} 

Answer 1

귀하의 질문이 완전하지 않으며 관련 코드가 모두 포함되어 있지 않습니다. 그러나 이것은 서로 다른 바인딩 사이의 기본적인 차이입니다.

Java는 정적 바인딩과 동적 바인딩을 모두 가지고 있습니다. Y 인딩은 변수가 특정 데이터 유형에 바인드 된 경우를 나타냄니다.

정적/초기 바인딩은 컴파일시 개인, 최종 및 정적 메서드와 변수에 대해 수행됩니다. 또한 오버로드 된 메소드의 경우

동적/후기 바인딩은 다음과 같은 경우 런타임에서 수행됩니다. 이것은 런타임에 다형성 동작을 가능하게합니다. 그것은 초기와 후기 바인딩 될 때 확인할 수있는 경우

추가로이 코드를 살펴이이 점을 증명하고 확인하려면 :

• ++ 애프터이다

  /* What is the output of the following program? */ 
  
  public class EarlyLateBinding { 
  
  public boolean equals(EarlyLateBinding other) { 
      System.out.println("Inside of overloaded Test.equals"); 
      return false; 
  } 
  
  public static void main(String[] args) { 
  
      Object t1 = new EarlyLateBinding(); //1 
      Object t2 = new EarlyLateBinding(); //2 
      EarlyLateBinding t3 = new EarlyLateBinding(); //3 
      Object o1 = new Object(); 
  
  
      Thread.currentThread().getStackTrace(); 
  
      int count = 0; 
      System.out.println(count++); 
      t1.equals(t2);//n 
      System.out.println(count++); 
      t1.equals(t3);//n 
      System.out.println(count++); 
      t3.equals(o1); 
      System.out.println(count++); 
      t3.equals(t3); 
      System.out.println(count++); 
      t3.equals(t2); 
  } 
  } 
  

  대답

  count와 따라서 리턴 된 결과는 그것을 증가시키기 전에 0이다. 따라서 0으로 시작하여 예상대로 진행됩니다.
: EarlyLateBinding 객체 의 동등한 방법이 실제로 호출
• 유일한 시나리오는 equals 메소드는 (객체 클래스는 동일에 비해 다른 메소드 서명 주) 과부하 때문입니다 문 3.
• 입니다
• 따라서 EarlyLateBinding 유형은 컴파일 시간에 변수 t3에 바인딩됩니다.

. 컴파일시 컴파일러는 정확한 유형을 알 수 없습니다 그렇게 유형을 사용하여 런타임에 해결 될 수 있도록이 코드에서

Answer 2

는

public static void insertionSort (Comparable[] list) 
{ 
    for (int index = 1; index < list.length; index++) 
    { 
     Comparable key = list[index]; 
     int position = index; 
     while (position > 0 && key.compareTo(list[position-1]) < 0) 
     { 
      list[position] = list[position-1]; 
      position--; 
     } 
      list[position] = key; 
    } 
} 

키는 대등 인터페이스를 구현 아무것도 할 수있다 그 그 대상은 를 참조하십시오.

하지만이 코드에서 ,

@Override 
public int compareTo(Object o) { 
    SalePerson s1 = (SalePerson)o; 

    if (this.totalSales > s1.getTotalSales()) 
    { 
     return 1; 
    } 

    else if (this.totalSales < s1.getTotalSales()) 
    { 
     return -1; 
    } 

    else //if they are equal 
    { 
     return (this.lastName.compareTo(s1.lastName)); 

    } 
} 

컴파일러는 S1의 유형은 그래서