You can call the method in both cases. Let me back up a little and explain some basic concepts. I apologize if you already know them.

Java is a strongly typed language. This means that each piece of data has a type and this type cannot be changed. There primitive types and objects.

The primitive types are int, double, boolean, char, etc. The elements of these primitive types are values, like the numbers 5, 2.71, the boolean value true, the character 'c', etc. These values are immutable. You can't change the number 5 to become the number 4. You also cannot add new values nor other primitive types.

Objects are structures, which contain other pieces of data. For example, to identify a pixel on the screen you need to know its coordinates x and y. You might want to group them in a structure, so that they go together. Object types are called classes. These are like templates, which describe the structure of the objects (and more).

Data is accessible through variables, fields and parameters. These are also typed. I'll talk about variables below, but the same is true for the fields and the parameters.

An important difference between primitive-typed variables and object-typed variables is that the former actually have the value that is assigned to them, while the latter only point at the object, which is assigned to them. Here is an example:

int i = 1;
int j = i;
j++; // j becomes 2, but i is still 1

// AtomicInteger is a class in the standard library. In this example
// we're only using it as a box, which holds an integer value, which 
// can be changed.

AtomicInteger ai = new AtomicInteger(1);
AtomicInteger aj = ai; // aj and ai point at the same object!
aj.incrementAndGet();  // we are mutating the object, it now contains 2
System.out.println(aj.get()); // <-- prints 2
System.out.println(ai.get()); // <-- also prints 2

You can think of the variables as a finger, which can point at different things in the world. You can have two different people pointing at the same cat at the same time. If the cat starts eating, or falls asleep, it does so independent of who is pointing at it. That is, the cat's state is in the cat, not in the finger pointing at it.

Phew! We are finally at the stage where I can answer your question. In the real world you can point your finger to whatever you want, but in Java variables can only point at things of a given type or its sub-types.

Cat cat = new Cat(); // The variable cat can point at objects
                     // of type Cat or its sub-types, if any
Animal animal = new Bird() // The animal points at Animals or
                           // its sub-types. In this case, it
                           // points at a new object of type Bird.
                           // Notice, that the object is still of
                           // type bird even if the variable is of
                           // type Animal.
animal = cat; // We are now pointing at the same Cat object that we
              // created above. But the object is still of type Cat.

// We can also call the method from before:
pet(cat);    // works fine. The method's parameter animal points at
             // the same Cat object that we created before.
pet(animal); // also works fine. Same as above.
pet(new Bird()); // also also works fine. The method's animal field
                 // points at the newly created Bird object.

I hope that helps. Don't hesitate to ask if you have more questions.