Vanilla Java
@HTML_POST@
Any class definition may be annotated with @Data to let lombok generate all the boilerplate that is associated with simple POJOs
(Plain Old Java Objects) and beans: getters for all fields, setters for all non-final fields, a useful toString, and implementations
of hashCode and equals which consider any two objects of this type with the same values for each field as equal. A
constructor is also generated containing 1 parameter for each final field, in the order the fields are defined. This constructor simply assigns
each parameter to the appropriate field.
To override the access level of any getter/setter for any field, annotate the field with a @Setter or @Getter annotation
with the appropriate AccessLevel value. See the example below. For more information on how the getters/setters are generated,
see the documentation for @Getter and @Setter.
All fields marked as transient will not be considered for hashCode and equals. All static fields will be
skipped entirely (not considered for any of the generated methods, and no setter/getter will be made for them).
The generated getter/setter method will be public unless you explicitly specify an AccessLevel, as shown in the example below.
Legal access levels are PUBLIC, PROTECTED, PACKAGE, and PRIVATE.
If any method that would normally be generated exists in name that method will not be generated, and no warning or error is emitted. For example,
if you already have a method with signature void hashCode(int a, int b, int c), no int hashCode() method will be generated,
even though technically int hashCode() is an entirely different method. The same rule applies to the constructor, toString,
hashCode, and all getters and setters.
@Data can handle generics parameters for fields just fine. In order to reduce the boilerplate when constructing objects for classes with
generics, you can use the staticConstructor parameter to generate a private constructor, as well as a static method that returns a new
instance. This way, javac will infer the variable name. Thus, by declaring like so: @Data(staticConstructor="of") class Foo<T> { private T x;}
you can create new instances of Foo by writing: Foo.of(5); instead of having to write: new Foo<Integer>(5);.
Arrays are 'deep' compared/printed/hashCoded, which means that arrays that contain themselves will result in StackOverflowErrors. However,
this behaviour is no different from e.g. ArrayList.
You may safely presume that the hashCode implementation used will not change between versions of lombok, however this guarantee is not set in stone; if there's a significant performance improvement to be gained from using an alternate hash algorithm, that will be substituted in a future version.
For a general idea of how lombok generated the equals, hashCode, and toString methods, check the example after.
For the purposes of equality, 2 NaN (not a number) values for floats and doubles are considered equal, eventhough 'NaN == NaN' would
return false. This is analogous to java.lang.Double's equals method, and is in fact required to ensure that comparing an object
to an exact copy of itself returns true for equality.