Java patterns in Scala

Java design patterns in
Scala
Radim Pavlicek

About me
● Java/Scala developer
● bogey golfer
● piano player

Part I - OO Patterns
Functional Interface
Command
Builder
Iterator
Template method
Strategy
Null Object

Functional Interface
encapsulate a bit of program logic and treated
like any other first-class construct

Java
Collections.sort(people,
new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return p1.getFirstName().compareTo(
ps.getFirstName())
}
})

Java
other use-cases
● runnable
● callable
Java 8 has solved

Scala
people.sortWith(
(p1, p2) => p1.firstName < p2.firstName
)

Command
Turn a method invocation into an object
and execute it in a central location

Java
public class PrintCommand implements Runnable {
private final String s;
PrintCommand(String s) { this.s = s; }
public void run() { System.out.println(s); }
}
public class Invoker {
private final List<Runnable> history = new ArrayList<>();
void invoke(Runnable command) {
command.run();
history.add(command);
}
}
Invoker invoker = new Invoker();
invoker.invoke( new PrintCommand( "Scala"));
invoker.invoke( new PrintCommand( "Vienna"));

Scala
object Invoker {
private var history: Seq[() => Unit] = Seq.empty
def invoke(command: => Unit) { // by-name parameter
command
history :+= command _
}
}
Invoker.invoke(println( "foo"))

Scala advanced
def makePurchase(register: CaschRegister, amount: Int) =
{
() = {
println("Purchase in amount: " + amount)
register.addCash(amount)
}
}
// how to create purchase functions using closure

Builder
to create an immutable object using a friendly
syntax

Java
Issues
● constructor arguments
Person(String n,String n2,String nick
● Defaults (telescoping constructor problem)
Person()
Person(String name)
Person(String name, String name2)...

Java code
public class ImmutablePerson {
private final String firstName;
public String getFirstName() {
return firstName;}
private ImmetablePerson(Builder builder) {
firstName = builder.firstName;
}
public static Builder newBuilder() {
return new Builder();
}
}
public static class Builder {
private String firstName;
public Builder withFirstName(String
firstName) {
this.firstName = firstName;
return this;
}
public ImmutablePerson build () {
return new ImmutablePerson(this);
}
}

Scala - Case Class
case class Person {
firstName: String,
LastName: String,
nick: String = "")
val p = Person(firstName = “Radim”, lastName = “Pavlicek”)
val cloneMe = Person(firstName = “Radim”, lastName = “Pavlicek”)
p.equals(cloneMe) // true
val brother = p.copy(firstName = “Libor”) // Libor Pavlicek
p.toString // Person[firstName=”Radim”, lastName= “Pavlicek”]

Scala - Tuples
● for explorative development
def p = (“Radim”, “Pavlicek”)
p._1 // Radim
p._2 // Pavlicek

Iterator
iterate through the elements of a sequence
without having to index into it

Java
public Set<Char> vowelsCount(String s) {
Set<Char> l = new HashSet<Char>();
for (Char c : s.toLowerCase().toCharArray())
if (isVowel(c))
l.add(c)
}

Scala
● filter
● map
● reduce

Scala filter
filtering certain elements from collection
def vowelsNumber(word : String) =
word.filter(isVowel).toSet
vowelsNumber(“Radim”) // Set(‘a’, ‘i’)

Scala map
function is applied to each element
def prependHello(names : Seq[String]) =
names.map((name) => “Hello, “ + name)

Scala reduce
reduce sequence to a single value
def sum(sq : Seq[Int]) =
if (sq.isEmpty) 0
else
sq.reduce((acc,curr) => acc + curr)

Scala comprehensions
● guard
for (a <- list if isEven(a))
● pattern matching
for (Person(name, address) <- people)
● still no mutable state

Scala for comprehensions
case class Person(name: String, addr: Address)
case class Address(zip: Int)
def greetings(people: Seq[Person]) =
for (Person(name, address) <-
people if isCloseZip(address.zip) )
yield “Hello, %s”.format(name)

Template method
defines the program skeleton of an algorithm in
a method, called template method, which defers
some steps to subclasses

Java
public abstract class Template {
public void doStuff() {
beforeStuff(); afterStuff();
}
protected abstract void beforeStuff();
protected abstract void afterStuff();
}

Scala Function Builder
def doStuff(
beforeStuff: () => Unit,
afterStuff: () => Unit) =
() = {
beforeSuff()
afterStuff()
}

Scala Function Builder
def beforeStuff() = Console.println(“before”)
def afterStuff() = Console.println(“after”)
val test= doStuff(beforeStuff, afterStuff)
scala> test

Strategy
define an algorithm in abstract terms and make
it interchangeable within family

Java
public interface Strategy {
int compute(int a, int b);
}
public class Add implements Strategy {
public int compute(int a, int b) { return a + b; }
}
public class Multiply implements Strategy {
public int compute(int a, int b) { return a * b; }
}
public class Context {
private final Strategy strategy;
public Context(Strategy strategy) { this.strategy = strategy; }
public void use(int a, int b) { strategy.compute(a, b); }
}
new Context(new Multiply()).use(2, 3);

Scala
define type alias and use first-class functions
type Strategy = (Int, Int) => Int
class Context(computer: Strategy) {
def use(a: Int, b: Int) { computer(a, b) }
}
val add: Strategy = _ + _
val multiply: Strategy = _ * _
new Context(multiply).use( 2, 3)

Null Object
avoid null checks in code and
centralize logic that deals with handling the
absence of a value

Java
class NullPerson extends Person {....}
public Person build(String first, String last) {
if (first == null || last == null)
return new NullPerson();
return new Person (first, last);
}

Scala
val nullPerson = Person() // case class
def build(first: Option[String],
last: Option[String]) =
(for (f <- first; l <- last)
yield Person(f, l)
).getOrElse(nullPerson)

Decorator
add behaviour to an existing class
aka “there is a bug in the API class”

Java
public interface OutputStream {
void write(byte b);
void write(byte[] b);
}
public class FileOutputStream implements OutputStream { /* ... */ }
public abstract class OutputStreamDecorator implements OutputStream {
protected final OutputStream delegate;
protected OutputStreamDecorator(OutputStream delegate) {
this.delegate = delegate;
}
public void write(byte b) { delegate.write(b); }
public void write(byte[] b) { delegate.write(b); }
}

Scala
def add(a: Int, b: Int) = a + b
def decorateLogger(calcF: (Int, Int) => Int) =
(a: Int, b: Int) => {
val result = calcF(a, b)
println(“Result is: “ + result) // here it comes
result
}

Scala
val loggingAdd = decorateLogger(add)
scala> loggingAdd(1,4)
Result is 5

Sources
http://pavelfatin.com/design-patterns-in-scala

Java patterns in Scala

More Related Content

What's hot (20)

Similar to Java patterns in Scala (20)

Recently uploaded (20)

Java patterns in Scala