@Getter and @Setter


You can annotate any field with @Getter and/or @Setter, to let lombok generate the default getter/setter automatically.
A default getter simply returns the field, and is named getFoo if the field is called foo (or isFoo if the field's type is boolean). A default setter is named setFoo if the field is called foo, returns void, and takes 1 parameter of the same type as the field. It simply sets the field to this value.

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.

You can also put a @Getter and/or @Setter annotation on a class. In that case, it's as if you annotate all the non-static fields in that class with the annotation.

You can always manually disable getter/setter generation for any field by using the special AccessLevel.NONE access level. This lets you override the behaviour of a @Getter, @Setter or @Data annotation on a class.

To put annotations on the generated method, you can use onMethod=@_({@AnnotationsHere}); to put annotations on the only parameter of a generated setter method, you can use onParam=@_({@AnnotationsHere}). Be careful though! This is an experimental feature. For more details see the documentation on the onX feature.

NEW in lombok v1.12.0: javadoc on the field will now be copied to generated getters and setters. Normally, all text is copied, and @return is moved to the getter, whilst @param lines are moved to the setter. Moved means: Deleted from the field's javadoc. It is also possible to define unique text for each getter/setter. To do that, you create a 'section' named GETTER and/or SETTER. A section is a line in your javadoc containing 2 or more dashes, then the text 'GETTER' or 'SETTER', followed by 2 or more dashes, and nothing else on the line. If you use sections, @return and @param stripping for that section is no longer done (move the @return or @param line into the section).

With Lombok

01 import lombok.AccessLevel;
02 import lombok.Getter;
03 import lombok.Setter;
05 public class GetterSetterExample {
06   /**
07    * Age of the person. Water is wet.
09    @param age New value for this person's age. Sky is blue.
10    @return The current value of this person's age. Circles are round.
11    */
12   @Getter @Setter private int age = 10;
14   /**
15    * Name of the person.
16    * -- SETTER --
17    * Changes the name of this person.
19    @param name The new value.
20    */
21   @Setter(AccessLevel.PROTECTEDprivate String name;
23   @Override public String toString() {
24     return String.format("%s (age: %d)", name, age);
25   }
26 }

Vanilla Java

01 public class GetterSetterExample {
02   /**
03    * Age of the person. Water is wet.
04    */
05   private int age = 10;
07   /**
08    * Name of the person.
09    */
10   private String name;
12   @Override public String toString() {
13     return String.format("%s (age: %d)", name, age);
14   }
16   /**
17    * Age of the person. Water is wet.
18    *
19    @return The current value of this person's age. Circles are round.
20    */
21   public int getAge() {
22     return age;
23   }
25   /**
26    * Age of the person. Water is wet.
27    *
28    @param age New value for this person's age. Sky is blue.
29    */
30   public void setAge(int age) {
31     this.age = age;
32   }
34   /**
35    * Changes the name of this person.
36    *
37    @param name The new value.
38    */
39   protected void setName(String name) {
40     this.name = name;
41   }
42 }

Small print

For generating the method names, the first character of the field, if it is a lowercase character, is title-cased, otherwise, it is left unmodified. Then, get/set/is is prefixed.

No method is generated if any method already exists with the same name (case insensitive) and same parameter count. For example, getFoo() will not be generated if there's already a method getFoo(String... x) even though it is technically possible to make the method. This caveat exists to prevent confusion. If the generation of a method is skipped for this reason, a warning is emitted instead. Varargs count as 0 to N parameters.

For boolean fields that start with is immediately followed by a title-case letter, nothing is prefixed to generate the getter name.

Any variation on boolean will not result in using the is prefix instead of the get prefix; for example, returning java.lang.Boolean results in a get prefix, not an is prefix.

Any annotations named @NonNull (case insensitive) on the field are interpreted as: This field must not ever hold null. Therefore, these annotations result in an explicit null check in the generated setter. Also, these annotations (as well as any annotation named @Nullable or @CheckForNull) are copied to setter parameter and getter method.

You can annotate a class with a @Getter or @Setter annotation. Doing so is equivalent to annotating all non-static fields in that class with that annotation. @Getter/@Setter annotations on fields take precedence over the ones on classes.

Using the AccessLevel.NONE access level simply generates nothing. It's useful only in combination with @Data or a class-wide @Getter or @Setter.

@Getter can also be used on enums. @Setter can't, not for a technical reason, but for a pragmatic one: Setters on enums are an extremely bad idea.