1 - What is this called?
This is a type of polymorphism that's called "inclusion polymorphism". It allows you to create restrictions on the type of variable that can be used in your code, while still allowing some type flexibility. Java and C#, for instance, have generics that allow various types and references to use the same code. However, these often run into run-time issues that could otherwise be caught by a static code analyzer. It's generally considered to be less risky to rely on the static analyzer (assuming your IDE has a good one) than to wait and find out your code has bugs in it after your release.
2 - And Why do it?
In addition to the reason I gave above, one of the most common applications of this is the polymorphic array.
Consider the following:
// Both classes contain an Accelerate() function
NiceCar MyNiceCar = new NiceCar();
EvenNicerCar MyEvenNicerCar = new EvenNicerCar();
// We're forced to use these methods separately
MyNiceCar.Accelerate();
MyEvenNicerCar.Accelerate();
////////////////////////////////////////////////////////////////////////////////////////////////////
// We can make this code much smaller and less prone to copy/paste errors using polymorphism!
Car[] MyPolymorphicArray = new Car[] { new NiceCar(), new EvenNicerCar() };
foreach(c in MyPolymorphicArray) { c.Accelerate(); }
Using this type of syntax, you can see that I'm able to make the code smaller, more-manageable, type-safe, and our static code analyzer will complain if we get it wrong, rather than waiting until runtime to find out. When you use this type of architecture, make sure you require the methods intended to be used by the instances to either be in an interface or in the parent class of that object in order to help avoid implementation errors. Additionally, take note that if you do this, the Accelerate() method may only need to be written in the parent class, which helps make the code even smaller.