Arved Sandstrom wrote:
On 11-05-09 06:04 AM, Michal Kleczek wrote:
I think you are missing the fact that the client is _already_ tied to a
contract by calling getSortedMap() to get the map (since the contract of
getSortedMap() is "return a map implementation that provides such and
such iteration order".
The question is rather - do we need to specify this contract as a Java
type? I would rather say: since the compiler cannot enforce/check the
contract anyway then it is useless - the contract specified as
documentation of getSortedMap() is enough.
I agree that the compiler cannot enforce the contract unless both the
provider of the LinkedHashMap and the calling code are written
cooperatively to use LinkedHashMap explicitly, thereby locking in the
requirement. This is the scenario I've been positing.
As I believe I mentioned in another post, you could get away with
documentation, but I believe you'd have to document not just the method,
but also all the call sites. If you're going to rely on documentation
then perhaps your biggest win would be to change the name of the method
- getMap() would be an atrocious choice. IMO the only defensible choice is
Map getPredictableIterationOrderMap()
Now *this* stands out when you're using it.
Sure - naming of functions is one of the most important aspects of defining
them.
Anyway.
Somehow I got lost in discussion and forgot the most important thing IMHO:
the fact that iteration order is important to the overall solution does not
imply it is important to the client code. Take an example:
//the program is supposed to print hashcodes of strings provided as
//arguments in the order that the user gave them
//forget that the map is not needed here
public void PrintHashes {
public static void main(String[] args) {
final Map<String, Integer> mapOfHashes = new LinkedHashMap<>();
calculateHashes(Arrays.asList(args), mapOfHashes);
printMap(mapOfHashes, System.out);
}
private static <T> void calculateHashes(
Iterable<? extends T> objects,
Map<? super T, ? super Integer> hashes) {
for (final Object object : objects) {
hashes.put(object, object.hashCode());
}
}
private static void printMap(Map<?, ?> map, PrintStream out) {
for (final Map.Entry<?, ?> entry : map.entrySet()) {
out.println("Key: " + entry.getKey() + " Value: " + entry.getValue());
}
}
}
According to your logic all references to Map<whatever> should be replaced
by LinkedHashMap<String, Integer> which - sorry to say that - sounds insane
:)
_That_ is not _my_ logic. My logic is that in the example provided by
LinkedHashMap reasonable. These sets of circumstances may include both
map-producing method to be. Since we don't know, I've repeatedly tried
religion. I'm getting that there is quite a large group out there that
doesn't countenance *ever* breaking "program to the interface". So be it.