What are the possibilities for using getter / setters in Java?

Encapsulation

You also mentioned C # properties. These are really just getters / setters under the hood, but with a more concise syntax.

This is so that you can change the getter or setter implementation in your public API after it's released. By using public fields, you will not be able to check the values ​​for validity.

This is part of encapsulation : abstraction of the class interface ("getters" and "setters") from its implementation (using an instance variable). While you may decide to implement the behavior through direct access to an instance variable today, you may want to do it differently tomorrow. Let's say you need to retrieve a value over the network instead of storing it locally - if you've encapsulated the behavior, that's a trivial change. If other objects rely on direct access to an instance variable, you're stuck.

The most important use for getters and setters in Java is to annoy developers. The second most important thing is to clutter your code with useless noise. Plus, it forces you to use a different name for the same thing, depending on where you are (inside or outside the class). Don't forget about the added ambiguity (are you calling the getter inside the class, or are you using that field directly?) They are then used to allow access to sensitive data, but that's just a minor side effect;)

In other programming languages, the compiler will generate them for you (unless, of course, you provide your own implementations). For example, in Delphi you have modifiers read

and write

for the fields (in the same way as private

, static

or final

in Java). Determine if you will have a receiver or setter generated for you.

Unlike the Delphi guys, the Java guys wanted it to be explicit. "If it's not in the source, it isn't." So the only solution was to get people to write all getters and setters by hand. Even worse, people have to use a different name for the same thing.

Getters and setters may very well be the greatest lies ever told. They are considered a sign of good design, and vice versa. New programmers should teach proper encapsulation rather than writing dumb data carrier classes that contain nothing but getters and setters.

(The idea that you need getters and setters for future code if you want to change the implementation later is the obvious case of YAGNI . But that really is beside the point.)

The most common reason is poor understanding of encapsulation. When the developer thinks that encapsulating material really only means getters and setters, not encapsulating behavior.

Valid reasons for having getters / setters are:

1) You are making a generic¹ object like JComponent. Using getter / setter instead of directly accessing the variable means that you can preprocess the specified variable first (for example, check it with a given range) or change the base implementation (go from int to BigInteger without changing the public API).

2) Your DI framework does not support ctor injection. With just a setter, you can ensure that the variable is only set once.

3) (C # Binding 1) So that tools can interact with your object. Using such a simple convention, GUI tools can easily retrieve all the settings for a given component. An example of this is the UI Creator in NetBeans.

¹ Of non-generic type. Bad word to use. I know please suggest an alternative.

Having a setter allows you

• check
• to fire a property changed event if the new value is different from the previous value

In this case, there is no need for getter and setter if the value is simply read or written.

Well,

OOP .;)

Or a little more accurate:

Getters and Setters are used to provide a specific interface to property classes. Check out the OOP link, it goes into more detail on the concepts ...

TO

Some Java frameworks require them (JavaBeans I think).

- Change

Some posters try to talk about encapsulation. This is not true.

Encapsulation is all about hiding the implementation details of your object and showing only the relevant functions.

A get / set grant that does nothing other than the given value does not do it at all, and the only reason for them is:

• Do some extra checking before installing / get
• Get a variable from elsewhere
• Integration with frameworks (EJB)

You need to encapsulate these attributes if there are, for example, limitations or do general validation or post change events or whatever. The main use is to hide an attribute from the "outside world".

There are several reasons:

• Some Java APIs rely on them (for example, the Servlet API);
• creating a non-final public variable is considered bad style;

• additional code support: if in the future you need to perform some actions before each access / mutation (get / set) of a variable, you will have less problems with it. In C # constructs like

  public int Age {get {return (int) (today () - m_BirthDate); }}

is just syntactic sugar.