Posts Categorized: Java

One of the language features many people miss in Java is pattern matching, and/or an equivalent of Scala case classes. In Scala we can match on types and structure. We have “switch” in Java, but it’s much less powerful and it can’t even be used as an expression. It’s possible to simulate matching in Java… Read more »

Java 8 not only gives us both default and static methods on interfaces. One of the consequences of this is you can create simple value objects using interfaces alone, without the need to define a class. Here’s an example. We define a Paint type which is composed of an amount of red/green/blue paint. We can… Read more »

Java 8’s default methods on interfaces means we can implement the decorator pattern much less verbosely. The decorator pattern allows us to add behaviour to an object without using inheritance. I often find myself using it to “extend” third party interfaces with useful additional behaviour. Let’s say we wanted to add a map method to… Read more »

I’ve been thinking about how to express joins in my pure Java query library. Hibernate and other ORMs allow you to map collection fields via join tables. They will take care of cascading inserts and deletes from multiple tables for you. While this is nice and easy, it can to cause problems with bigger object… Read more »

There are different viewpoints on how to use exceptions effectively in Java. Some people like checked exceptions, some argue they are a failed experiment and prefer exclusive use of unchecked exceptions. Others eschew exceptions entirely in favour of passing and returning types like Optional or Maybe. Whatever your view, you are likely to need to… Read more »

One of the complaints that often comes up in any discussion on Java is getters/setters. If there are c# developers present they sometimes suggest that Java would be better off with c# style properties. c# properties, replace separate getters and setter methods that often clutter Java code. They allow the getters/setters to be combined together,… Read more »

Method references in Java 8 will allow us to build much nicer APIs for interacting with databases. For example when you combine method references with features we already had in Java it’s possible to create clean, typesafe queries without needing code generation. Full examples and implementation available on github. Here’s an example of what’s possible… Read more »

SQL gives us a “coalesce” function, which returns the first non-null argument. This seems to be a common operation in Java too, since Java unfortunately burdens us with the concept of nulls. We have been able to do something similar with Java for some time using a varargs method like this: public static <T> T… Read more »