Java allows casting to an intersection of types, e.g. (Number & Comparable)5. When combined with default methods on interfaces, it provides a way to combine behaviour from multiple types into a single type, without a named class or interface to combine them.<\/p>\n
Let’s say we have two interfaces that provide behaviour for Quack and Waddle.<\/p>\n
\r\ninterface Quacks {\r\n default void quack() {\r\n System.out.println(\"Quack\");\r\n }\r\n}\r\ninterface Waddles {\r\n default void waddle() {\r\n System.out.println(\"Waddle\");\r\n }\r\n}\r\n<\/pre>\nIf we wanted something that did both we’d normally declare a Duck type that combines them, something like <\/p>\n
\r\ninterface Duck extends Quacks, Waddles {}\r\n<\/pre>\nHowever, casting to an intersection of types we can do something like <\/p>\n
\r\nwith((Anon & Quacks & Waddles)i->i, ducklike -> {\r\n ducklike.quack();\r\n ducklike.waddle();\r\n});\r\n<\/pre>\nWhat’s going on here? Anon is a functional interface compatible with the identity lambda, so we can safely cast the identity lambda i->i to Anon.<\/p>\n
\r\ninterface Anon {\r\n Object f(Object o);\r\n}\r\n<\/pre>\nSince Quacks and Waddles are both interfaces with no abstract methods, we can also cast to those and there’s still only a single abstract method, which is compatible with our lambda expression. So the cast to (Anon & Quacks & Waddles) creates an anonymous type that can both quack() and waddle().<\/p>\n
The with() method is just a helper that also accepts a consumer of our anonymous type and makes it possible to use it.<\/p>\n
\r\nstatic void with(T t, Consumer consumer) {\r\n consumer.accept(t);\r\n}\r\n<\/pre>\nThis also works when calling a method that accepts an intersection type. We might have a method that accepts anything that quacks and waddles.<\/p>\n
\r\npublic static void doDucklikeThings(Ducklike ducklike) {\r\n ducklike.quack();\r\n ducklike.waddle();\r\n}\r\n<\/pre>\nWe can now invoke the above method with an intersection cast<\/p>\n
\r\ndoDucklikeThings((Anon & Quacks & Waddles)i->i);\r\n<\/pre>\nSource code<\/h2>\n
You can find complete examples on github<\/a><\/p>\nEnhancing existing objects<\/h2>\n
Some have asked whether one can use this to add functionality to existing objects. This trick only works with lambdas, but we can make use of a delegating lambda, for common types like List that we might want to enhance.<\/p>\n
Let’s say we are fed up of having to call list.stream().map(f).collect(toList()) and wish List had a map() method on it directly.<\/p>\n
We could do the following<\/p>\n
\r\nList stringList = asList(\"alpha\",\"bravo\");\r\nwith((ForwardingList & Mappable)() -> stringList, list -> {\r\n List strings = list.map(String::toUpperCase);\r\n strings.forEach(System.out::println);\r\n});\r\n<\/pre>\nWhere Mappable declares our new method<\/p>\n\r\ninterface Mappable extends DelegatesTo> {\r\n default List map(Function mapper) {\r\n return delegate().stream().map(mapper).collect(Collectors.toList());\r\n }\r\n}\r\n<\/pre>\nAnd DelegatesTo is a common ancestor with our ForwardingList <\/p>\n\r\ninterface DelegatesTo {\r\n T delegate();\r\n}\r\ninterface ForwardingList extends DelegatesTo>, List {\r\n default int size() {\r\n return delegate().size();\r\n }\r\n \/\/... and so on\r\n}\r\n<\/pre>\nHere’s a full example<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"Java allows casting to an intersection of types, e.g. (Number & Comparable)5. When combined with default methods on interfaces, it provides a way to combine behaviour from multiple types into a single type, without a named class or interface to combine them. Let’s say we have two interfaces that provide behaviour for Quack and Waddle…. Read more »<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[8],"tags":[],"yoast_head":"\n\n\n\n\n\n\n\n\n\n\n\n