Eu me deparei com duas questões de sobrecarga recentemente que não consigo encontrar uma resposta e não tenho um ambiente java para executar algum código de teste. Espero que alguém possa me ajudar montando uma lista de todas as regras que os compiladores Java seguem para sobrecarregar ou apontar-me alternadamente para uma lista que já existe.

Primeiro, quando dois métodos diferem apenas por um parâmetro varargs final, sob quais circunstâncias cada um é chamado e você pode chamar o método varargs sem nenhum argumento?

private void f(int a) { /* ... */ }
private void f(int a, int... b) { /* ... */ }

f(12); // calls the former? I would expect it to
f(12, (int[])null); // calls latter, but passes null for b? 
  // Can I force the compiler to call the second method in the same fashion
  // as would happen if the first method didn't exist?

Segunda pergunta, quando dois métodos diferem por tipos herdados um do outro que é chamado? Eu esperaria que a versão mais derivada fosse chamada e a conversão permitisse chamar o outro.

interface A {}
class B implements A {}
class C implements A {}

private void f(A a) {}
private void f(B b) {}

f(new C()); // calls the first method
f(new B()); // calls the second method?
f((A)(new B()); // calls the first method using a B object?

Estes são os dois exemplos, mas como um leitor de código, eu prefiro uma lista canônica das regras exatas ordenadas usadas para resolver isso, pois frequentemente não tenho tempo para configurar um ambiente de compilação para verificar o que o compilador está fazendo.