Java code can look much cleaner and shorter when using static factory methods combined with import static. These are methods, which return a new (or reused) instance of a class. Let’s say we have a HashMap
which should use instances of KeyClass
for the keys and a tuple of ValueClass1
and ValueClass2
as its values. Instead of writing lengthy code like
HashMap<KeyClass, Tuple<ValueClass1, ValueClass2>>
myMap = new HashMap<KeyClass,
Tuple2<ValueClass1, ValueClass2>>();
you could just use
HashMap<KeyClass, Tuple<ValueClass1, ValueClass2>>
myMap = map();
Therefor, we need to create a static factory method named map
somewhere with the following code:
public static <T1, T2> HashMap<T1, T2> map()
{
return new HashMap<T1, T2>();
}
And then, when filling the HashMap
, you can again make use of factory methods. Compared to
myMap.put(myKey,
new Tuple2<ValueClass1, ValueClass2>(
value1, value2));
the following code is much shorter:
myMap.put(myKey, t(value1, value2));
Nice, how easy tuples (or triples, or quadrupels, …) can be created in Java! Remember, that import static
is needed to make it really short. We do not want to write Tuple.t(...)
everywhere where we instantiate a tuple, but really only t(...)
. This is nearly as short as in the programming languages which support tuples natively.
One other example, where we always use those methods, are fractions. Instead of new Fraction(1, 4);
we always use fr(1, 4)
. Actually we made the constructor private
, so that programmers must use the factory method. This leads to much cleaner code. One real example from Zong!: Instead of
new Chord(new Note(new Pitch(1, 0, 4)),
new Fraction(1, 4))
we just have to write
chord(note(pi(1, 0, 4)), fr(1, 4))