Vamos supor que eu tenha o seguinte código:

// Method acception generic parameter
public static <T> T foo(T para) {
    return para;
}

// Method accepting Integer parameter
public static Integer foo(Integer para) {
    return para + 1;
}

// Method accepting Number parameter
public static Number foo(Number para) {
    return para.intValue() + 2;
}

public static void main(String[] args) {
    Float f = new Float(1.0f);
    Integer i = new Integer(1);
    Number n = new Integer(1);
    String s = "Test";

    Number fooedFloat = foo(f);     // Uses foo(Number para)
    Number fooedInteger = foo(i);   // Uses foo(Integer para)
    Number fooedNumber = foo(n);    // Uses foo(Number para)
    String fooedString = foo(s);    // Uses foo(T para)

    System.out.println("foo(f): " + fooedFloat);
    System.out.println("foo(i): " + fooedInteger);
    System.out.println("foo(n): " + fooedNumber);
    System.out.println("foo(s): " + fooedString);
}

A saída é a seguinte:

foo(f): 3
foo(i): 2
foo(n): 3
foo(s): Test

Agora a pergunta (s):

foo(n) chamadasfoo(Number para)provavelmente porquen é definido comoNumber, mesmo que tenha umInteger atribuído a ele. Então, estou certo no pressuposto de que a decisão, qual dos métodos sobrecarregados é tomada, acontece no tempo de compilação, sem ligação dinâmica? (Pergunta sobreestático edinâmico obrigatório)foo(f) usafoo(Number para), enquantofoo(i) usafoo(Integer para). Somentefoo(s) usa a versão genérica. Portanto, o compilador sempre verifica se há uma implementação não genérica para os tipos fornecidos e somente se não voltar à versão genérica? (Pergunta sobregenéricos)Novamente,foo(f) usafoo(Number para), enquantofoo(i) usafoo(Integer para). Ainda,Integer i também seria umNumber. Portanto, sempre é utilizado o método com o tipo "mais externo" na árvore de herança? (Pergunta sobreherança)

Sei que são muitas perguntas e o exemplo não é retirado do código produtivo, mas gostaria de saber o que "acontece por trás" e por que as coisas acontecem.

Além disso, quaisquer links para a documentação ou especificação Java são realmente apreciados, eu mesmo não os encontrei.