Ich bin kürzlich auf zwei überladende Fragen gestoßen, auf die ich keine Antwort gefunden habe und die keine Java-Umgebung haben, um Testcode auszuführen. Ich hoffe, jemand kann mir helfen, indem er eine Liste aller Regeln erstellt, die Java-Compiler befolgen, um mich zu überladen oder mich abwechselnd auf eine bereits vorhandene Liste zu verweisen.

Erstens, wenn sich zwei Methoden nur durch einen abschließenden varargs-Parameter unterscheiden, unter welchen Umständen wird jede aufgerufen und können Sie die varargs-Methode ohne Argumente aufrufen?

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?

Zweite Frage, wenn sich zwei Methoden durch voneinander geerbte Typen unterscheiden, die aufgerufen werden? Ich würde erwarten, dass die am besten abgeleitete Version aufgerufen wird und Casting die andere aufrufen darf.

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?

Dies sind die beiden Beispiele, aber als Codeleser würde ich eine kanonische Liste der genau geordneten Regeln bevorzugen, die zur Lösung dieses Problems verwendet werden, da ich häufig keine Zeit habe, eine Build-Umgebung einzurichten, um zu überprüfen, was der Compiler tut.