Why is this a static binding instead of dynamic binding?

Question

I'm still a little confused with regards to the difference between static and dynamic. From what I know dynamic uses object while static use type and that dynamic is resolved during runtime while static is during compile time. so shouldn't this.lastName.compareTo(s1.lastName) use dynamic binding instead?

key.compareTo(list[position-1]) use dynamic binding

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

Why does (this.lastName.compareTo(s1.lastName)) use static binding?

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??

    }
}

I'm guessing `lastName` is a `String`? If so, since `String` is final, it can't be extended, so none of its methods can be overridden. Hence, the implementation is known at compile time. — azurefrog, Mar 10 '17 at 04:52
yes the lastName is a String! Good catch, i didn't even spot that! — Challenger, Mar 10 '17 at 04:56
but why key.compareTo(list[position-1]) uses dyamic binding? — Challenger, Mar 10 '17 at 05:01
compareTo methods of Comparable interfaces are overriden and hence are bouhd at runtime. have a look at my answer below. — Shivam Sinha, Mar 10 '17 at 05:06

score 1 · Answer 1 · answered Mar 10 '17 at 04:59

Your question isn't complete and doesn't include all relevant the code. However this is the basic difference between the different bindings

Java has both static and dynamic binding. Binding refers to when variable is bound to a particular data type.

Static/Early binding is done at compile time for: private, final and static methods and variables. And also for overloaded methods

Dynamic/late binding is done at runtime for: methods which can be overriden methods. This is what enables polymorphic behaviour at runtime.

To further demonstrate this point have a look at this code and see if you can determine when it would be early and late binding:

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

Answer:

++ is after the count and hence the result returned is the 0 before incrementing it. Hence starts with 0 and proceeds as you expect.
The only scenario where the equals methods of EarlyLateBinding object is actually invoked is is statement 3.
This is because the equals method is overloaded (Note: the different method signature as compared to the object class equals)
Hence the type EarlyLateBinding is bound to the variable t3 at compile time.

.

score 1 · Answer 2 · answered Mar 10 '17 at 06:34

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

key can be anything that implements the Comparable interface so in the compile time compiler doesn't know the exact type so type is resolved in the runtime by using the object that key referring to.

But in this 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));

    }
}

compiler knows the type of the s1 so it use the static binding

Why is this a static binding instead of dynamic binding?

2 Answers2