Java Dynamic Binding

Ho difficoltà a capire il principio Polymorphic OOP di Dynamic Binding (Late Binding) in Java. Ho cercato una domanda relativa a java e non ero sicuro che se una risposta generale a come funziona il binding dinamico riguarderebbe Java Dynamic Binding, ho scritto questa domanda.

Data:

class Person
{
     private String name;

     Person(intitialName)
     {
          name = initialName;
     }

     // irrelevant methods is here.

     // Overides Objects method
     public void writeOutput()
     {
          println(name);
     }
}

class Student extends Person
{

     private int studentNumber;

     Student(String intitialName, int initialStudentNumber)
     {
     super(intitialName);
     studentNumber = initialStudentNumber;
     }

     // irrellevant methods here...

     // overides Person, Student and Objects method
     public void writeOutput()
     {
      super.writeOutput();
      println(studentNumber);
     }   
  }

class Undergaraduate extends Student
{

     private int level;

     Undergraduate(String intitialName, int initialStudentNumber,int initialLevel)
     {
     super(intitialName,initialStudentNumber);
     level = initialLevel;
     }

     // irrelevant methods is here.

     // overides Person, Student and Objects method
     public void writeOutput()
     {
      super.writeOutput();
      println(level);
     }

  }

Mi sto chiedendo. se avessi un array chiamato persona dichiarata per contenere oggetti di tipo Person:

  Person[] people = new Person[2];
  person[0] = new Undergraduate("Cotty, Manny",4910,1);
  person[1] = new Student("DeBanque, Robin", 8812);

Dato che quella persona [] è dichiarata per essere di tipo Persona, ti aspetteresti, ad esempio, nella terza riga dove persona [0] è inizializzata a nuovo oggetto Undergraduate, per ottenere solo la variabile di istanza dai Metodi di Persona e Persone poiché non l'assegnazione a un nuovo Undergraduate al suo antenato denota l'oggetto Undergraduate per accedere a Persona - è Ancestors, metodi e variabili di isntance ...

Quindi ... con il seguente codice mi aspetterei

  person[0].writeOutput();  // calls Undergraduate::writeOutput()
  person[1].writeOutput();  // calls Student::writeOutput() 

persona [0] per non avere il metodo sovrascritto writeOutput () di Undergraduate, né fare in modo che la persona [1] abbia il metodo sovrascritto di Student - writeOutput ().

Se avessi

Person mikeJones = new Student("Who?,MikeJones",44,4);
mikeJones.writeOutput();

Il metodo Person :: writeOutput () verrebbe chiamato.

Perché non è così? Ha a che fare con qualcosa che non capisco riguardo ai matrici? La dichiarazione Person [] people = new Person [2] non vincola il metodo come il codice precedente sarebbe?