What are the benefits of declaring a different type than the initialization object due to polymorphism?

Given the following code:

class Vehicle{
	public void operate(){
		System.out.println("The vehicle is being operated.");
	}
}

class Car extends Vehicle{
	public void operate(){
		System.out.println("The car is being operated.");
	}
}

public class Simulation{
	public static void main(String[] args){
		Vehicle vehicle1 = new Car();
		Vehicle vehicle2 = new Vehicle();
		vehicle1.operate();
        vehicle2.operate();
	}
}

What is the benefit of declaring vehicle1 as a Vehicle when we end up initializing it as Car? Shouldn't we just declare it as a Car?

In this example it's not obvious to see the benefit. However, doing so has these benefits:

1. Usually you'll be calling methods with your object. So we have two options ...myFunction(Vehicle vehicle) or myFunction(Car car). If you choose to use Car, you are restricting the type that can be passed to that method. This is very important. Keep in mind software changes a lot, requirements change, enhancements are made. Let's suppose now you have a shiny new object a Ferrari which extends Vehicle, you cannot call myFunction(Car car) but you will be able to call myFunction(Vehicle vehicle) by passing Ferrari. So in order to make your call using myFunction you will have to change the function signature. Sometimes you cannot change the function signature because, well, it is a library and you don't have the source code. Or maybe you can change it but if you do you will break people using your code. In larger software development, teams are split and you have to create some classes that others will use to complete the whole project. Or you will create libraries and ship to clients. That's the main reason there is polymorphism: to make it easy for many teams to work together without breaking each others code and also improve on the code by using subclasses without breaking things.
   When you are writing only a small piece of code that you are not going to share with anyone and don't plan on expanding that code base, there is not much of a benefit. However it is a good habit to have.

2. Intent: by declaring it as Vehicle, you are showing in your code that you only care about something that has the behavior of a Vehicle .i.e you can call operate(). When you extend a class you can add additional behaviors/methods to it. By declaring it as Vehicle you won't be able to call any of new methods in Car. Remember that your code will most likely be read by others (if it's not your sole property), so using Vehicle makes it obvious that you only care about something that can operate().

3. Collections: Very often you need to create objects and use them as a collection. Let's imagine you have a race of Vehicles. To make all the Vehicles start, you can easily use Vehicle[] and stuff all of them in there if you use Vehicle. If you were using the Car, Ferrari, Van... you could only stuff them if you use Object[] and then you will have to cast to ((Vehicle)arrayElement).operate() instead of just arrayElement.operate(). I'm giving a simplistic example but I think you'll get the idea.

So to conclude, from only your code there is on the surface no direct benefit but from the reasons above there will be a benefit if you use Vehicle and there is benefit to do so now because you will build good habits and think more OOP and about the bigger picture.

Declaring it locally in a method like that there isn't much difference. Generally speaking you get more flexibility by working on references of the most abstract type that can possibly work. You might see that in code like List<String> foo = new ArrayList<>(); because List is enough.

For example look at Collections.sort(). It takes a List because list elements are ordered. It can't just take Collection because collections aren't guaranteed to be ordered, like Set. But it can use any implementation of List, like ArrayList, LinkedList, etc because ordering is the only property sort() cares about.