Problems with static binding and dynamic binding in Java

When the code compiles, sometimes,it is not clear which method needs to be invoked.It can be determined only at runtime.

Take this simple code as an example.

class Animal{   

    public void makeNoise(){
       System.out.println("Default");
    };
}

class Dog extends Animal{

    //override the makeNoise()
    public void makeNoise(){
        System.out.println("Woof");
    };
}

class Cat extends Animal{

        //override the makeNoise()
        public void makeNoise(){
            System.out.println("Meow");
        };
    } 

public class Sounds{

    public static void AnimalSounds(Animal animal){
    animal.makeNoise();
    }

    public static void main(String args[]){

        Animal dog = new Dog();     
        Animal cat = new Cat(); 
        AnimalSounds(dog);
        AnimalSounds(cat);  
    }
}

AnimalSounds(Animal animal) method takes any object that passes ISA test of Animal and invoke the respective method of that object. As you can see, it removes code duplication as well since we can use the same method on different types of objects.

Hope this address your concern.

To understand this topic you should know what are compilation and run-time processes in general. In short, when you build your app compiler goes through all your code and checks for consistency, safety and run-ability. If there is no error founded by compiler it generates class files from your source code (java files). When the app is running it means that your class files are loaded into memory and JVM executing your app instruction by instruction.

From your example:

Person a = new Student(); // Student is a subclass of Person
a.speak();     

Compilation process: Compiler checks this line: Person a = new Student(); for type safety (compatibility). So, if student is a person compilation goes to next line else it fails. In next line: a.speak(); compiler looks at a type, found that it's a Person and looks for speak() method at Person type. If that method is not founded by compiler compilation process fails.

Runtime process: When JVM executes this line: Person a = new Student(); it goes through initialization process from top (parent class) to bottom (child class). In next line: a.speak(); JVM founds student object through reference a looks for method speak() if it's founded in Student then executes it, otherwise it runs speak() method from parent class Person.

Another examples from inheritance subject:

class Person {
    public void speak() {}
    public void think() {}
}

class Student extends Person {
    @Override
    public void speak() {}
    public void speakALot() {}
}

Person a = new Student();
a.speak(); // calling overrided version of speak() 
a.think(); // since this method is not overrided in child class it will be called from parent class
a.speakALot(); // since Person doesn't know anything about specific methods of derived classes compilation fails 

Student b = new Student();
b.speak(); // calling speak() method of student object
b.think(); // inheritance trick, child class keeps reference to its base class and that's why public and protected fields and methods are available
b.speakALot(); // calling speakALot() method of student object

If I just write a general purpose class to test any kind of Vehicle as follows.

public class Workshop{
    public boolean test(Vehicle vehicle){
        vehicle.start();
        vehicle.stop();
        //...more code
        return true;
    }
 }

I can compile this code only with Vehicle type, though none of the child classes of Vehicle have been written. In general frameworks exploit this capability of providing processing based on generic type in absence of concrete types (clients are free to extend child class hierarchy). In such cases Compiler will just make sure that vehicle will have at least one implementation (null implementation like {} is also acceptable) will be available so as not to break the code.