Mark Space wrote:
www wrote:
I saw in many places that people use:
Map m= new HashMap();
I *rarely* see people do:
HashMap m= new HashMap();
1. Convention. As you say, many people do it this way.
2. Flexibility. It may be easier to change the implementation of the
former than the latter. The latter form would encourage other
programmers to code to the specific HashMap() interface, rather than
the more general Map() interface. With Map(), you can just plug in a
new type of map like
Map m = new LinkedHashMap();
But if you've coded to a specific type of Hash Map this change may be
not so easy to make.
3. Probably some other reasons I can't think of right now... always
it depends on your application.
It is a best practice to prefer the most general type possible for the
compile-time type of a variable. This provides the most bug-free and
maintainable code.
The word is "prefer", not "demand", and "possible for the ... type",
which might be a specific implementation but usually isn't.
Consider the fairly common error of using Vector for a List when you
don't need its special features. If you declared
List <String> stuff = new Vector <String> ();
then it's much easier to change to
List <String> stuff = new ArrayList <String> ();
and later, if you see that you need specific performance characteristics,
List <String> stuff = new TreeList <String> ();
or even
List <String> stuff
= Collections.synchronizedList( new ArrayList <String> () );
No other code will depend on non-List methods such as those of Vector,
so you are much safer in making the changes.
Read Joshua Bloch's excellent book /Effective Java/ for details on this
and many other best practices.
It doesn't make a lot of sense to me. Generics were added to closely
example into a plain List as you lose all of what makes it a LinkedList.