In this talk we explain how we use the more recent concepts of the Java programming language in order to improve readability and maintainability of our code.

1. Getting the most out of
Java
Sebastian Zarnekow - Sven Efftinge
itemis

2. Topics

3. Topics
Construction of Data Objects

4. Topics
Construction of Data Objects
Dependency Injection

5. Topics
Construction of Data Objects
Dependency Injection
Fluent Interfaces

6. Topics
Construction of Data Objects
Dependency Injection
Fluent Interfaces
Polymorphic Dispatch

7. Topics
Construction of Data Objects
Dependency Injection
Fluent Interfaces
Polymorphic Dispatch
Annotation-based APIs

8. Java is getting old

9. Java is Ceremonial

10. Java is Ceremonial
public String greeting(final String name) {
return "Hello "+name+"!";
}

11. Java is Ceremonial
Public visibility should be default
public String greeting(final String name) {
return "Hello "+name+"!";
}

12. Java is Ceremonial
public String greeting(final String name) {
return "Hello "+name+"!";
}

13. Java is Ceremonial
Local variables and arguments should
be final by default
public String greeting(final String name) {
return "Hello "+name+"!";
}

14. Java is Ceremonial
public String greeting(final String name) {
return "Hello "+name+"!";
}

15. Java is Ceremonial
Return type can be inferred
public String greeting(final String name) {
return "Hello "+name+"!";
}

16. Java is Ceremonial
public String greeting(final String name) {
return "Hello "+name+"!";
}

17. Java is Ceremonial
public String greeting(final String name) :
return "Hello "+name+"!";
}

18. Java is Ceremonial
public String greeting(final String name) {
return "Hello "+name+"!";
}
greeting(String name) :
"Hello "+name+"!";

19. Java’s Syntax is Inflexible

20. Java’s Syntax is Inflexible
All infix operators work for built-in types only.

21. Java’s Syntax is Inflexible
All infix operators work for built-in types only.
2 / 4 * 13;

22. Java’s Syntax is Inflexible
All infix operators work for built-in types only.
2 / 4 * 13;
new BigDecimal(2)
.divide(new BigDecimal(4))
.multiply(new BigDecimal(13));

23. Java lacks Closures

24. Java lacks Closures
Working with collections in Java (i.e. without closures):
public List<String> fourLetterWords(List<String> words) {
List<String> fourLetterWords = Lists.newArrayList();
for (String string : words) {
if (string.length()==4)
fourLetterWords.add(string);
}
return fourLetterWords;
}

25. Java lacks Closures
Working with collections in Java (i.e. with closures):
public List<String> fourLetterWords(List<String> words) {
return words.select(#{s->s.length()==4});
}

26. ...but Java is also great!

27. ...but Java is also great!
•Lots of developers

28. ...but Java is also great!
•Lots of developers
•JVM is a great platform

29. ...but Java is also great!
•Lots of developers
•JVM is a great platform
•Big open-source community

30. ...but Java is also great!
•Lots of developers
•JVM is a great platform
•Big open-source community
•Leading edge tooling
(Eclipse, IntelliJ IDEA)

31. What can we do about the
“not-so-nice things”
in Java?

32. Object Instantiation

33. Object Categories

34. Object Categories
• Short Living, Data Objects

35. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)

36. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)
• Immutable Objects (BigInteger, String)

37. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)
• Immutable Objects (BigInteger, String)
• Others (LayoutManager, Runnables)

38. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)
• Immutable Objects (BigInteger, String)
• Others (LayoutManager, Runnables)
• Components

39. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)
• Immutable Objects (BigInteger, String)
• Others (LayoutManager, Runnables)
• Components
• Singletons (ConnectionPool, Scheduler, ...)

40. Object Categories
• Short Living, Data Objects
• Collections (ArrayList, HashSet, Iterator)
• Immutable Objects (BigInteger, String)
• Others (LayoutManager, Runnables)
• Components
• Singletons (ConnectionPool, Scheduler, ...)
• Services (URLValidator, BillingService, ...)

41. Construction of
Data Objects

42. Construction of
Data Objects
• Convenience

43. Construction of
Data Objects
• Convenience
• Readability

44. Construction of
Data Objects
• Convenience
• Readability
Map<String,Foo> foos = new HashMap<String, Foo>();

45. Use Type Inference
Map<String,Foo> foos = new HashMap<String, Foo>();

46. Use Type Inference
Map<String,Foo> foos = new HashMap<String, Foo>();
Map<String,Foo> foos = Maps.newHashMap();

47. Use Type Inference
Map<String,Foo> foos = new HashMap<String, Foo>();
Map<String,Foo> foos = Maps.newHashMap();
public static <K, V> HashMap<K, V> newHashMap() {
return new HashMap<K, V>();
}

48. Use Static Imports
Map<String,Foo> foos = Maps.newHashMap();

49. Use Static Imports
Map<String,Foo> foos = Maps.newHashMap();
Map<String,Foo> foos = newHashMap();

50. Use Static Imports
Map<String,Foo> foos = Maps.newHashMap();
import static com.google.common.collect.Maps.*;
...
Map<String,Foo> foos = newHashMap();

51. Use Var Args
List<String> names = newArrayList();
names.add("Foo");
names.add("Bar");
names.add("Baz");

52. Use Var Args
List<String> names = newArrayList();
names.add("Foo");
names.add("Bar");
names.add("Baz");
List<String> names = newArrayList("Foo","Bar","Baz");

53. Use Var Args
List<String> names = newArrayList();
names.add("Foo");
names.add("Bar");
names.add("Baz");
List<String> names = newArrayList("Foo","Bar","Baz");
public static <E> ArrayList<E> newArrayList(E... elements) {
...
}

54. Component Instantiation
- Classical Approach -

55. Constructor Invocation

56. Constructor Invocation
public class TwitterClient {
void send(String message) {
if (message.length() > 140) {
Shortener shortener = new TinyUrlShortener();
message = shortener.shorten(message);
}
if (message.length() <= 140) {
Tweeter tweeter = new SmsTweeter();
tweeter.send(message);
}
}
}

57. Constructor Invocation
Shortener shortener = new TinyUrlShortener();
Tweeter tweeter = new SmsTweeter();

58. Constructor Invocation
• Strong Dependencies
• Not Testable
Shortener shortener = new TinyUrlShortener();
Tweeter tweeter = new SmsTweeter();

59. Component Instantiation
- Dependency Injection -

60. Constructor Parameters

61. Constructor Parameters
public class TwitterClient {
private Shortener shortener; private Tweeter tweeter;
public TwitterClient(Shortener shortener, Tweeter tweeter) {
this.shortener = shortener;
this.tweeter = tweeter;
}
void send(String message) {
if (message.length() > 140) {
message = shortener.shorten(message);
}
if (message.length() <= 140) {
tweeter.send(message);
}
}
}

62. Constructor Parameters
// Initialize the component graph
Shortener shortener = new TinyUrlShortener();
Tweeter tweeter = new SmsTweeter();
TwitterClient client = new TwitterClient(shortener, tweeter);
// Do Something meaningful
client.send(“Hello World”);

63. Constructor Parameters
... Have Advantages

64. Constructor Parameters
... Have Advantages
• Components Depend on Interfaces

65. Constructor Parameters
... Have Advantages
• Components Depend on Interfaces
• Testable Code

66. Constructor Parameters
... Have Advantages
• Components Depend on Interfaces
• Testable Code
• Dependencies are No Longer Burried in the
Core of Your Application

67. Constructor Parameters
... Leave the Burden to the Client

68. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);

69. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);

70. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);
Shortener shortener = new TinyUrlShortener(soap);

71. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);
Shortener shortener = new TinyUrlShortener(soap);
AndroidSmsSender sender = new AndroidSmsSender();

72. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);
Shortener shortener = new TinyUrlShortener(soap);
AndroidSmsSender sender = new AndroidSmsSender();
Tweeter tweeter = new SmsTweeter(sender);

73. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);
Shortener shortener = new TinyUrlShortener(soap);
AndroidSmsSender sender = new AndroidSmsSender();
Tweeter tweeter = new SmsTweeter(sender);
TwitterClient client = new TwitterClient(shortener, tweeter);

74. Constructor Parameters
... Leave the Burden to the Client
HttpConnection http = new HttpConnection(“..”);
SoapConnection soap = new SoapConnection(http);
Shortener shortener = new TinyUrlShortener(soap);
AndroidSmsSender sender = new AndroidSmsSender();
Tweeter tweeter = new SmsTweeter(sender);
TwitterClient client = new TwitterClient(shortener, tweeter);
client.send(“Hello World”);

76. Constructor Parameters
... Revisited
public class TwitterClient {
private Shortener shortener; private Tweeter tweeter;
public TwitterClient(Shortener shortener, Tweeter tweeter) {
this.shortener = shortener;
this.tweeter = tweeter;
}
void send(String message) {
..
}
}

77. Constructor Parameters
... Revisited
public class TwitterClient {
private Shortener shortener; private Tweeter tweeter;
@Inject
public TwitterClient(Shortener shortener, Tweeter tweeter) {
this.shortener = shortener;
this.tweeter = tweeter;
}
void send(String message) {
..
}
}

78. Constructor Parameters
... Revisited
// Initialize the component graph
Injector i = Guice.createInjector(new TweetModule());
// Obtain main component
TwitterClient client = i.getInstance(TwitterClient.class);
// Do something meaningful
client.send(“Hello Guice!”);

79. Remember This?

80. Encapsulated Dependencies
class TweetModule extends AbstractModule {
protected void configure() {
bind(Shortener.class).to(TinyUrlShortener.class);
bind(Tweeter.class).to(SmsTweeter.class);
}
}

81. Modern API
Design

82. Modern API
Design
Easy To Use

83. Modern API
Design
Easy To Use
Consistent

84. Modern API
Design
Easy To Use
Consistent
Hard To Misuse

85. Modern API
Design
Easy To Use
Consistent
Hard To Misuse
Easy To Read !

86. Half-caf venti
non-fat Latte to go.

87. Half-caf venti
non-fat Latte to go.

88. Fluent Interfaces
Half-caf venti
non-fat Latte to go.

89. Fluent Interfaces
CoffeeOrder order = new Latte();
order.setSize(Size.VENTI);
order.setCaffeine(Caffeine.HALF);
order.setMilk(MilkType.NONFAT);
order.setFoam(false);
Coffee coffee = order.prepare(true);

90. Fluent Interfaces
Coffee coffee = new Latte()
.venti()
.halfCaf()
.nonFat()
.prepare(TO_GO);

91. Fluent Interfaces
Chained Method-
Calls That Read Like
Natural Language

92. Fluent Interfaces
Chained Method-
Calls That Read Like
Natural Language
http://www.wikihow.com/Order-at-Starbucks

93. Fluent Interfaces
StringBuilder builder = ..;
return builder
.append(“The result is “)
.append(result)
.append(‘.’)
.toString();

94. Fluent Interfaces
How To:

95. Fluent Interfaces
How To:
1. Methods Modify Internal State and

96. Fluent Interfaces
How To:
1. Methods Modify Internal State and
2. Return self or new Object

97. Fluent Interfaces
How To:
1. Methods Modify Internal State and
2. Return self or new Object
3. Until Result is Returned

98. Fluent Interfaces
Examples: Guice Binder API
bind(Service.class)
.to(Implementation.class)
.in(Scopes.REQUEST);

99. Fluent Interfaces
Examples: EasyMock
LinkedList mocked = mock(LinkedList.class);
when(mocked.get(0)).thenReturn(“first”);

100. Fluent Interfaces
Examples: Google Guava MapMaker
ConcurrentMap<Key, Value> map = new MapMaker()
.softKeys()
.weakValues()
.expiration(30, MINUTES)
.makeComputingMap(
new Function<Key, Value>() {
public Value apply(Key key) {
return createExpensiveValue(key);
}
});

101. Fluent Interfaces
Examples: Google Guava MapMaker
With Closures
ConcurrentMap<Key, Value> map = new MapMaker()
.softKeys()
.weakValues()
.expiration(30, MINUTES)
.makeComputingMap(k|createExpensiveValue(k));

102. Visitor Pattern (GoF)
... separating an algorithm
from an object structure it
operates on...

104. Polymorphic Dispatching

105. Polymorphic Dispatching
Visitor visitor = new ExternalVisitor();
visitor.visit(car);
visitor.visit(bus);
visitor.visit(engine);
visitor.visit(wheel);

106. Polymorphic Dispatching
class ExternalVisitor {
String visit(Object o) {
if (o instanceof Bus) {
..
} else if (o instanceof Car) {
..
} else if (o instanceof Engine) {
..
} else ..
}
}

107. Polymorphic Dispatching
Dispatcher dispatcher = new Dispatcher(this, “doVisit”);
String visit(Object o) {
return dispatcher.dispatch(o);
}
String doVisit(Bus b) {return “Bus: ” + print(b.getParts());}
String doVisit(Car c) {return “Car: ” + print(c.getParts());}
String doVisit(Engine e) { ... }
String doVisit(Collection<?> parts) { ... }

108. Polymorphic Dispatching
• Non Invasive External Visitor

109. Polymorphic Dispatching
• Non Invasive External Visitor
• Handle Arbitrary Object Graphs

110. Polymorphic Dispatching
• Non Invasive External Visitor
• Handle Arbitrary Object Graphs
• Eliminate if-instanceof-else Cascades

111. Polymorphic Dispatching
• Non Invasive External Visitor
• Handle Arbitrary Object Graphs
• Eliminate if-instanceof-else Cascades
• Dispatch According to Runtime Type of Arguments
(Like switch-Statement on Types)

112. Annotation-based APIs

113. Annotation-based APIs
addAction(new AbstractAction(“Exit”) {
{
putValue(MNEMONIC_KEY, “E”);
putValue(SHORT_DESCRIPTION, “Exit App”);
}
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});

114. Annotation-based APIs
@Action(“Exit”, mnemonic=”E”, desc=”Exit App”)
public void exit(ActionEvent e) {
System.exit(0);
}

115. Annotation-based APIs
Examples: Property Change Events
@PropertyChangeListener({“size”})
public void invalidateLayout(PropertyChangeEvent e) {
..
}
@PropertyChangeListener({“value”, “selectedItem”})
public void revalidate(PropertyChangeEvent e) {
..
}

116. Annotation-based APIs
Examples: Validation
@Validate(OnSave, nullIsOk=true, property=”EMail”)
ValidationResult matchesPattern(String s) {
if (!s.matches(PATTERN)) {
return ValidationResult.createError(..);
}
return OK;
}

117. Annotation-based APIs
• More Concise Code

118. Annotation-based APIs
• More Concise Code
• Avoid Anonymous Classes

119. Annotation-based APIs
• More Concise Code
• Avoid Anonymous Classes
• Easier to Understand

120. Annotation-based APIs
• More Concise Code
• Avoid Anonymous Classes
• Easier to Understand
• Less Code to Maintain

121. Annotation-based APIs
• More Concise Code
• Avoid Anonymous Classes
• Easier to Understand
• Less Code to Maintain
• Method can be overwritten
(Extensibility, Testability)

122. Recab

123. Recab
Construction of Data Objects

124. Recab
Construction of Data Objects
Dependency Injection

125. Recab
Construction of Data Objects
Dependency Injection
Fluent Interfaces

126. Recab
Construction of Data Objects
Dependency Injection
Fluent Interfaces
Polymorphic Dispatch

127. Recab
Construction of Data Objects
Dependency Injection
Fluent Interfaces
Polymorphic Dispatch
Annotation-based APIs

128. The Good News?
• One Day Java May Have

129. The Good News?
• One Day Java May Have
• Closures (Java 8 - JSR 335)

130. The Good News?
• One Day Java May Have
• Closures (Java 8 - JSR 335)
• Improved Type Inference (Java 7 - JSR 334)

131. The Good News?
• One Day Java May Have
• Closures (Java 8 - JSR 335)
• Improved Type Inference (Java 7 - JSR 334)
• ...

132. The Good News?
• One Day Java May Have
• Closures (Java 8 - JSR 335)
• Improved Type Inference (Java 7 - JSR 334)
• ...
• Due 2011 & 2012

133. Thanks.