Var-arg doesn't work as I think for single parameter methods

Question

Hello,
I was playing with var-args and after running the following code I really couldn't understand why the compiler picks the answer for the single parameter method call, when surely it should find an exact match with the var-arg method?
The first two obviously use the var-arg call, but why the last? I would have thought the compiler would only go back up the class until it reached an exact match then stop, which the single parameter version matches exactly the var-arg.
class FourByFour {
     public void changeGear(long x) {
          System.out.println("4x4");
class Ford extends FourByFour {
     public void changeGear(int... x) {
          System.out.println("Ford");     
public class trial {
     public static void main(String[] args)
          Ford c = new Ford();
          c.changeGear(1,2);
c.changeGear(new int[]{1});
          c.changeGear(1);
btw, the base is only a long because I wanted to see whether it would still prefer casting to the var-arg.

Answer 1

But surely the int var-arg matches exactly the single parameter call? var-arg takes 0 or more parameters, so passing in one parameter is a full match and more so than it's base class long? Maybe I'm just getting mixed up with how var-args are interpreted as internally?
As for 'back up the class' I assumed it first checks the current objects methods, then checks it's super methods, etc. but if it finds an exact match on a method, to save wasted time it would stop right there, e.g.
class A { void method(long x){}}
class B extends A {void method(int x){}}
calling new B.method(x) with an int would obviously call B's and not A's and would not bother checking with A's because it is an exact match with B, which is sort of how I interpreted passing in a single int to a var-arg. Or, swapping the two signatures around it would call A's because if B's had a long it would not be an exact match and so it's base class is called.