The reason is that the implementation of these interfaces is usually not relevant when handling them, therefore if you oblige the caller to pass a `HashMap` to a method, then you're essentially obliging which implementation to use.  So as a general rule, you're supposed to handle its interface rather than the actual implementation and avoid the pain and suffering which might result in having to change all method signatures using `HashMap` when you decide you need to use `LinkedHashMap` instead.

It should be said that there are exceptions to this when implementation is relevant.  If you need a map when order is important, then you can require a `TreeMap` or a `LinkedHashMap` to be passed, or better still `SortedMap` which doesn't specify a specific implementation. This obliges the caller to necessarily pass a certain type of implementation of Map and strongly hints that order *is* important.  

However best practice still dictates that if it isn't important, you shouldn't use specific implementations.  This is true in general.  If you're dealing with `Dog` and `Cat` which derive from `Animal`, in order to make best use of inheritance, you should generally avoid having methods specific to `Dog` or `Cat`.  Rather all methods in `Dog` or `Cat` should override methods in `Animal` and it will save you trouble in the long run.