Pourquoi est-ce une liaison statique au lieu de la liaison dynamique?

Question

Je suis encore un peu confus en ce qui concerne la différence entre statique et dynamique. D'après ce que je sais, la dynamique utilise un objet alors que le type d'utilisation statique et que la dynamique est résolue pendant l'exécution alors que l'état statique est pendant la compilation. Donc, cela ne devrait pas this.lastName.compareTo (s1.lastName) utiliser la liaison dynamique à la place?

key.compareTo (liste [position 1]) l'utilisation dynamique liaison

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

Pourquoi (this.lastName.compareTo (s1.lastName)) utilisent une liaison statique?

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

Votre question n'est pas complète et n'inclut pas tout le code pertinent. Cependant, ceci est la différence fondamentale entre les différentes liaisons

Java a une liaison statique et une liaison dynamique. La liaison fait référence à la variable liée à un type de données particulier. La liaison statique/anticipée est effectuée au moment de la compilation pour les méthodes et variables privées, finales et statiques. Et aussi pour les méthodes surchargées

La liaison dynamique/tardive est effectuée à l'exécution pour: les méthodes qui peuvent être des méthodes surchargées. C'est ce qui permet le comportement polymorphique à l'exécution.

Pour démontrer ce point plus jeter un oeil à ce code et voir si vous pouvez déterminer quand il serait précoce et la liaison tardive:

/* 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); 
} 
} 

Réponse:

• ++ est après la compter et donc le résultat renvoyé est le 0 avant de l'incrémenter. Par conséquent commence avec 0 et continue comme prévu.
• Le seul scénario où les égaux méthodes d'objet EarlyLateBinding est en fait invoqué est est STATEMENT 3.
• En effet, la méthode equals est surchargée (Note: la signature différente de la méthode par rapport à la classe d'objet est égal à)
• Par conséquent, le type EarlyLateBinding est lié à la variable t3 au temps de compilation .

.

Answer 2

dans ce code

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

clé peut être quelque chose qui implémente l'Comparable l'interface donc dans le compilateur de compilation ne connaît pas le type exact si le type est résolu dans l'exécution en utilisant le objet que clé faisant référence à.

Mais dans ce code,

@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)); 

    } 
} 

compilateur

connaît le type de s1 il utilise la liaison statique