an interface, not an implementation – Favor object composition over class inheritance Side note: The Gof doesn't respect its own principles => abstract classes are harmful !
Substitution Principle Interface Segregation Principle Dependency Inversion Principle @FunctionalInterface interface DoIt { int apply(int val1, int val2); } a functional interface has only one abstract method
val1, int val2); } a functional interface has only one abstract method Conceptually equivalent to typedef DoIt = (int, int) → int DoIt add = (x, y) -> x + y; DoIt mul = (a, b) -> a * b;
seen through GoF Principles: – Program to an interface, not an implementation – Favor object composition over class inheritance => no class, no inheritance, only functions => function composition <=> object composition
function (also called curryfication) interface DoIt { int apply(int x, int y); } interface DoIt1 { int apply(int x); } DoIt add = (x, y) -> x + y; DoIt1 add1 = x -> add.apply(x, 1); DoIt mul = (a, b) - > a * b; DoIt1 mulBy2 = a - > mul.apply(2, a);
reference an existing method BiConsumer<PrintStream, Object> cons = PrintStream::println; type package java.util.function; public interface Consumer<T> { public void accept(T t); } public interface BiConsumer<T, U> { public void accept(T t, U u); }
to do partial application on the receiver BiConsumer<PrintStream, Object> consumer = PrintStream::println; PrintStream out = System.out; Consumer<Object> consumer2 = out::println; type instance
in Open/Close Principle) public interface Observer { public void data(double value); } public class CSVParser { public static void parse(Path path, Observer observer) throws … { ... } } public class SumCSV { public double parseAndSum(Path path) throws … { CSVParser.parse(path, ...); ... } }
write than an Iterator public class ArrayList<E> { private E[] elementData; private int size; public void forEach(Consumer<E> consumer) { for(int I = 0; i < size; i++) { consumer.accept(elementData[i]); } } public Iterator<E> iterator() { return new Iterator<E>() { private int i; public boolean hasNext() { return i < size; } public E next() { return elementData[i++]; } }; } }
allowed ! List<Double> list = … Internal: double sum = 0; list.forEach(value -> sum += value); External: for(double value: list) { sum += value; } sum is not effectively final
} public class Car implements Vehicle { … } public class Moto implements Vehicle { … } want to close it but allow to add new operations and new subtypes !
Car implements Vehicle { public Car(Color color) { … } } public class Moto implements Vehicle { public Moto(Color color) { … } } I want to create only either 5 red cars or 5 blue motos ?
b; public A(Function<A, B> fun) { this.b = fun.apply(this); } } public class B { private final A a; public B(A a) { this.a = a; } } A a = new A(B::new);
register(String name, Supplier<Vehicle> supplier) { ... } public Vehicle create(String name) { ... } } How to separate the registering step from the creation step ?
= new User("bob", 12); if (user.getName() == null) { throw new IllegalStateException("name is null"); } if (user.getName().isEmpty()) { throw new IllegalStateException("name is empty"); } if (!(user.getAge() > 0 && user.getAge() < 50)) { throw new IllegalStateException("age isn't between 0 and 50"); } public class User { private final String name; private final int age; ... }
in order to compose transformations public static User validateName(User user) { if (user.getName() == null) { throw new IllegalStateException("..."); } return user; } validate User User Exception
forax
neruneruo
kokuyouwind
kishikawakatsumi
isax1015
yumechi
nearme_tech
htkym
tsukuha
javiergs
ajstarks
uyuki234
koxya
varn
jonoalderson
mojombo
brettharned
schroneko
frankvandijk
schlessera
honzajavorek
techseoconnect
addyosmani
inesmontani
marcelosomers
