Ligadura dinámica, polimorfismo

Podemos utilizar fácilmente el ejemplo que te di anteriormente, de hecho en ese ejemplo se muestra el polimorfismo, es decir si yo tengo una clase que hereda otra, puedo usar la clase padre para crear una instancia del hijo
Animal perro = new Perro()
Esto es el polimorfismo, usar clases padre para contener instancias de clases hijo (también llamado upcasting), si recuerdas te decía que al hacer esto aun cuando la instancia creada es de clase "perro" como mi declaración es de tipo "Animal" solo tengo acceso a las funciones definidas en "Animal" no en "Perro", para acceder a funciones de "Perro" necesitaría hacer un downcasting (decirle al compilador que la variable perro es realmente de tipo "Perro" no "Animal")
Perro otroPerro = (Perro) perro;
Ahora lo que mencionas de la ligadura dinámica realmente tiene que ver con la sobrecarga de funciones, supongamos que en la clase animal yo tengo una función que se llame comer(), cuando heredo animal también heredo esa función, por lo tanto perro también tendría esa función, pero que pasa si en perro yo defino otra vez esa misma función (con el mismo prototipo, argumentos, etc), a esto se le llama sobrecarga de funciones. La ligadura dinámica entra precisamente aquí, ¿si yo tengo esa sobrecarga (o redifinicion del método si se te hace más fácil) el compilador debe saber que version de la función llamar (la de animal o la de perro?).
Volviendo al ejemplo:
Animal unPerro = new Perro();
unPerro.comer();
De entrada pensarías que el compilador llamaría al método comer() que se encuentra en Animal, pero no es así, en realidad llama a la version que se encuentra en Perro, aquí es donde el compilador se vuelve un poco inteligente y se da cuenta que Perro tiene una sobrecarga de la misma función presente en animal así que llama la que corresponda con el tipo de dato creado (en este caso la clase Perro).

Pero si esto es el ejemplo:
Animal unPerro = new Perro();
¿Por qué sabe que la función que tiene que coger es la de perro? Si tu lo declaras como Animal, ¿es por qué lo que realmente creas es new Perro()?
pero para que te sirve realmente poner Animal unPerro = new Perro();
no seria mejor poner directamente Perro un Perro = new Perro();
No entiendo la diferencia...

Así es, el compilador llama a la implementación de comer() que esta en perro porque realmente lo que estas creando es una instancia de Perro.
¿Para qué sirve esto?, bueno esto es muy usado en librerías o cuando tu quieres proveer una funcionalidad pero sabes que puede ser usada de distintas formas y no puedes o seria muy difícil que codificaras todas esas formas, un ejemplo muy común en esto es el uso de interfaces (espero que las hayas leído).
Vamos a poner un ejemplo, supongamos que vas a diseñar un programa que simule un zoológico, es decir que haga que los animales caminen, coman, duerman, etc. ¿Cuántos animales tendrás?, ¿Qué pasa si luego decides añadir un nuevo animal?. Si tu no usaras polimorfismo tendrías que saber en tiempo de diseño cuantos animales exactamente vas a tener, ¿algo muy difícil no?.
Por lo tanto diseñas una clase que sea lo suficientemente genérica como para que acepte cualquier tipo de animal sin necesidad de saber que tipo de animal es, algo así:
class Zoo{
   private ArrayList<Animal> huespedes = new ArrayList<Animal>();
   public void nuevoAnimal(Animal a){
       huespedes.add(a);
   }
}
¿Básicamente lo que hace esta clase es añadir un animal a la lista de huéspedes no?, así puedes saber cuales animales tiene el zoológico. ¿Imaginate si no lo hicieras genérico?, ¿Cuántas funciones nuevoAnimal tendrías que hacer?, una por cada nuevo tipo de animal que tuvieras (perro, gato, león). Con esto sabes que cualquier clase va a heredar la clase Animal, por lo tanto puedes escribir código genérico que no necesite saber de que tipo especifico es un animal.
Espero no haberte puesto más dudas, si es así, dímelo y podemos ver otra forma de explicarlo.