Java encapsulation [duplicate]

Answer 1

I like the explanation when taking into consideration threads. If you made your fields public, how is your instance going to know when a certain thread changed one of its fields?

The only way to do it would be with encapsulation, or simpler put give getters and setters to that field, thus you always know and can check/react to fields updates, for example.

Answer 2

In general, encapsulation of fields by getters and setters leaves more flexibility for changes.

If fields are accessed directly you are stuck with "stupid fields". Fields can only be written and read. Nothing else can be done while accessing a field.

When using methods you can do whatever you want while setting / reading the value. As markus and Jigar mentioned, validation is possible. In addition, you could decide some day that the value is derived from another value or some actions must be executed if the value changes.

how come data is hidden or safe

Data is neither hidden nor safe by using getters and setters. It just gives you the possibility to make it safe. What is hidden is the implementation and not the data.

Answer 3

Encapsulation makes code more easy to reuse by other people. Another key reason to use encapsulation is that interfaces can not declare fields, but they can declare methods, which can refer to a field!

Methods are properly named with a verb at the beginning. Such as: getName(), setName(),isDying(). Which can help read code!

Answer 4

Continuing Jigar's answer: There are a couple of things that come under encapsulation.

1. Contract Management: If you make it public, you are literally making anyone to change it to whatever they want. You can't protect it by adding a constraint. Your setter can make sure data gets modified in an appropriate way.

2. Mutability: You do not always have to have a setter. If there is a property that you wanted to keep immutable for the life span of the object. You just make it private and have no setter for it. It will probably be set via constructor. Then your getter will just return the attribute (if it's immutable) or a copy of the attribute (if attribute is mutable).

Answer 5

The data is safe, because you can do additional logic in your getter / setter, and it's not possible to change the values of your variable. Imagine your code did not work with a null variable, so in your setter you can check against null values and assign a default value which is != null. So your code is still working, regardless of whether someone tries to set your variable to null.

Answer 6

My question is if we can access the variables (data) though via getters and setters, how come data is hidden or safe?

You can encapsulate the logic under getters/setters. For example,

public void setAge(int age) {
    if (age < 0) {
        this.age = 0;
    }
    else {
        this.age = age;
    }
}