The term "value object" gets confusing in Java circles with various different interpretations. When I think about these I have my own very specific interpretation, which I'm christening VALJOs.
The Wikipedia article on value objects gives this definition:
In computer science, a value object is a small object that represents a simple entity whose equality is not based on identity: i.e. two value objects are equal when they have the same value, not necessarily being the same object.
I agree with the Wikipedia definition, however there is still a lot of detail to be added. What does it take to write a value object in Java - is there a set of rules?
Recently, life has got more complicated with talk of adding value types to a future Java release:
"A future version of Java" will almost certainly have support for "value types", "user-defined primitives", "identity-less aggregates", "structs", or whatever you would like to call them.
Work on value types is focussed on extending the JVM, language and libraries to support values. Key benefits revolve and memory usage and performance, particularly in enabling the JVM to be much more efficient. Since this post isn't about value types, I'll direct curious readers to the JEP and various articles on John Rose's blog.
JVM supported value types may be the future, but how far can be go today?
VALue Java Objects - VALJOs
What I want to achieve is a set of criteria for well-written value objects in Java today. Although written for today, the criteria have one eye on what value types of the future may look like.
As the term "value object" is overloaded, I'm giving these the name VALJO. Obviously this is based on the popular POJO naming.
- The class must be immutable, which implies the final keyword and thread-safety.
- The class name must be simple and direct, focussed on the value.
- Instances must be obtained using static factory methods. All constructors must be private.
- The state that defines the value must be clearly specified. It will consist of one or more elements.
- The elements of the state must be other values, which includes primitive types.
hashCode()methods must check all the elements of the state and nothing else.
- If the class implements Comparable, then it must check all the elements of the state and nothing else.
If the class implements Comparable, the
compareTo()method must be consistent with equals.
toString()method must return a formally-defined string fully exposing the state and nothing else.
toString()for two equal values must be the same. For two non-equal values it must be different.
There must be a static factory method capable of creating an instance from the formal string representation.
It is strongly recommended to use the method name
clone()method should not be public.
- Provide methods, typically simple getters, to get the elements of the state.
with()methods to obtain a copy of the original with different state.
- Other methods should be pure functions, depending only on the arguments are the state or derived state.
- Consider providing a link to the JDK 8 value-based classes documentation.
It is important to note that the state of a VALJO is not necessarily identical to the instance variables of the
Class. This happens in two different ways:
Firstly, the state could be stored using different instance variables to those in the definition.
For example, the state definition and public variables may expose an
int but the instance variable might be a
byte, because the validated number only needs 8 bit storage, not 32 bit.
Similarly, the state definition might expose an enum, but store the instance variable as an
In this case, the difference is merely an implementation detail - the VALJO rules apply to the logical state.
Secondly, there may be more instance variables than those in the state definition.
For example, a
Currency is represented in ISO 4217 with two codes, a three letter string and a three digit number.
Since it is possible to derive the numeric code from the string code (or vice versa), the state should consist only of the string.
However, rather than looking up the number each time it is needed, it is perfectly acceptable to store the numeric code in an instance variable that is not part of the state.
What would not be acceptable for
Currency is including numeric code in the
toString (as the numeric code is not part of the state, only the string code is).
In effect, the previous paragraph simply permits caching of related data within a VALJO so long as it can be derived from the state.
Extending this logic further, it is acceptable to cache the
On parsing, I recommend using
of(String) if the state of the VALJO consists entirely of a single element which is naturally a string, such as
parse(String) where the state consists of more than one element, or where the single element is not a string, such as
It is acceptable for the parse method to accept alternate string representations.
Currency parsing method might accept both the standard three letter code and the string version of the numeric code.
On immutability, it is allowed to have an abstract VALJO class providing the constructor is private scoped and all the implementations are immutable private static final nested classes. The need for this is rare however.
It is best practice to use VALJOs in a specific way tailored for potential future conversion to JVM value types:
Do not use
==, only compare using
Do not rely on
- Do not synchronize on instances.
Do not use the
The first of these rules is stronger than absolutely necessary given we are talking about normal Java objects in a current JVM.
Basically, so long as your VALJO implementation promises to provide a singleton cached instance for each distinct state then using
== is acceptable, because
equals() will always return the same result.
The real issue to be stopped here is using
== to distinguish between two objects that are equal via
Separately from these restrictions, the intention of VALJOs is that users should refer to the concrete type, not an interface.
For example, users refer to the JSR-310
LocalDate, not the
Temporal interface that it implements.
The reason for this is that VALJOs are, of necessity, simple basic types, and hiding them behind an interface is not helpful.
Actually writing VALJO classes is boring and tedious. The rules and implications need to be carefully thought through on occasion. Some projects provide tools which may assist to some degree.
Joda-Convert provides annotations for
@FromString which can be used to identify the round-trippable string format.
Joda-Beans provides a source code generation system that includes immutable beans. They are not instant VALJOs, but can be customised.
Auto-Value provides a bytecode generation system that converts abstract classes into immutable value objects. They are not instant VALJOs, but can be customised.
Project Lombok provides a customised compiler and IDE plugin which includes value object generation. They are not instant VALJOs, but can be customised.
In general however, if you want to write a really good VALJO, you need to do it by hand. And if that VALJO will be used by many others, such as in JSR-310, it is worth doing correctly.
The aim of this blog was to define VALJOs, a specific set of rules for value objects in Java. The rules are intended to be on the strict side - all VALJOs are value objects, but not all value objects are VALJOs.
Did I miss anything? Get something wrong? Let me know!