Here’s examples from my actual code of five lesser-known Java features, in increasing order of how much fun I had discovering they exist.
Anonymous classes
These are fairly well-known, so let’s go for a freaky example – an anonymous class declaration within the head of a (labeled!) for loop:
sentence : for (List children :
node.getOrderedChildrenBySpan(
sentence.getOrderedTerminals(), new Test() {
@Override
public boolean test(Node object) {
return false;
}
})) {
for (Node child : children) {
String tag = child.getLabel().getTag();
if (tag.contains("-SBJ")) {
break sentence;
}
tags.add(PTBUtil.pureTag(child));
}
}
Enums
Boring, I know. I’m mentioning them here for completeness because I found out about them rather late and was like, hey, cool, that’s much nicer and cleaner than working with explicit integer constants.
public enum EditOperationType {
DELETE, INSERT, SWAP, MATCH;
@Override
public String toString() {
switch(this) {
case DELETE:
return "delete";
case INSERT:
return "insert";
case SWAP:
return "swap";
default:
return "match";
}
}
}
Generic methods
Luckily, the following code is no longer live.
@SuppressWarnings("unchecked")
public T retrieve(
Class type, int id) {
return (T) getStoreForType(type).retrieve(id);
}}
Instance initializers
I know I discovered these once thinking I needed a constructor in an anonymous class and wondering how to do this, because how would one declare a constructor in a class without a name? It did not remain in my workspace, however, and I never used an instance initializer again. In the case of anonymous classes, I tend to use final variables outside of the anonymous class, or derive them from classes whose constructors already handle everything I need. So I’m pulling an example from someone else’s code:
_result = new ContainerBlock() {
{
setPanel(_panel);
setLayout(LayoutFactory.getInstance()
.getReentrancyLayout());
addChild(unboundVarLabel);
}
};
Multiple type bounds
public abstract class IncrementalComparator<
T extends HasSize & HasID> {
// ...
}
I wonder what’s next.
