Arguments to a function call can be specified in an order that is different from the default order of the function's parameters. It is possible to pick parameters by name irrespective of their declaration order, which produces succinct code in case the function has many parameters with default values.
Self-documenting function/method calls. Improved refactoring safety. Combined with default values, it negates the need for function/method overloading.
When you change from one library to another, using interfaces and implementations allows to reduce the code that needs to be modified and keeping the rest untouched. This saves time
You have to write more lines of code, to declare the interface or abstraction and then the implementation of such abstraction. So the project increases in number of files and lines of code to write. But after this is done the payoff later is well worth it
Function/method arguments with default/typical values can be omitted, resulting in a more concise call and hence improved readability. Combined with named arguments/parameters, it negates the need for function/method overloading.
If your GC is a black box that can run whenever it wants/needs to and you don't know all of what it does, it's not great for real-time high applications. The GC should be predictable, you should know when it's going to run, for how long, and what's it's going to be doing (destroying objects, freeing memory, defragmenting, etc.).
Frankly, a GC isn't entirely needed with a well designed engine/program.
Immutable data structures consume more memory than mutable ones. Computation is in principle slowed down by up to a logarithmic factor compared to mutable data structures.
Code that actually compiles is likely to work as intended, since the type system can check things that would require runtime assertions in other languages.
Modifying the base String to add a class it does not possess is one thing, but subtly modifying String's existing classes can lead to nightmare debugging for other developers of that codebase.