Re: HashMap get/put
Kevin McMurtrie wrote:
In article <hcb95q$mvt$1@news.albasani.net>, Lew <noone@lewscanon.com>
wrote:
Kevin McMurtrie wrote:
Generics is extremely helpful for common source code mistakes but it is
by no means a powerful tool. There have been many, many long threads
about it here.
There may have been long threads about it, but generics most assuredly is a
powerful tool. Perhaps you just haven't learned to use it correctly yet.
I think my expectations of a 'powerful tool' are greater than yours.
I think it's question of how powerful, and that there are objective rationales
for calling generics powerful.
Generics permit one to lock down the type relationships in code and push
possible runtime exceptions into compiler messages. The industry rule of
thumb is that compile time fixes are ten times cheaper than run time fixes.
Ten to one is powerful.
Generics force one to thoroughly analyze the type relationships. They
directly express that analysis. Type analysis is very powerful and the
ability to express it commensurately so.
Documentation internal to code is powerful. It speeds understanding for
maintenance programmers and prevents their errors.
Generics increase the ability to refactor code safely. If a type parameter
for interface 'Blah' is '<T extends Collection <Foo> & Serializable>' one can
reify that as 'ArrayList' initially and refactor to 'HashSet' without pain.
One will not be able to accidentally substitute a non-serializable collection.
One will be able to extract 'Foo' elements safely.
Client code can ignore the details secure in those promises. Encapsulation is
powerful:
public interface Blah <T extends Collection <Foo> & Serializable>
{
T getItems();
}
Client:
Blah <?> blah = BlahImpl.make();
Collection <Foo> foos = blah.getItems();
Information hiding, type safety, easier and less risky refactoring, simpler
client code - taken together they show that generics are at least somewhat
powerful.
--
Lew