getter/setter在封装中的作用是什么？

Question

As per my knowledge, encapsulation hides your data member from an outsider and only allows it access using methods of the same class. So that they're not able to show your personal data to outsiders. Following way it's true,

private double amount;

public void add(double value) {
    return this.amount + value;
}

Here your amount variable doesn't share with outsiders using private and they don't know about the variable name you used.

But in similar case we also provide getter / setter for access them so how can encapsulation become secure from outsiders?

public void setAmount(double value) {
    this.amount = value;
}

public double getAmount() {
    return this.amount;
}

This means most probably getter or setter method has the same pattern and outsider which has a basic knowledge about this. So I suppose after doing some attempt he is able to get using getter or change using setter. In such case, defining amount directly public or providing getter both becomes the same.

Can someone explain it?

Answer 1

Imagine you have a program with a million lines of code, including the ones you've already provided. Except your amount property is public.

Now, imagine that in that code, you set up in line 600 that amount is equal to 300.00 Then in line 4547 you set it again to 500.50

Then in line 585676 you do it one more time.

Then you run your program and you run into errors. You don't know where this error is coming from because it's all valid code. Then you realize that it must be something wrong with amount, but since you were just directly accesing your amount property, you end up having a horrible time trying to debug that.

And then, imagine in partícular, that you created a bunch of separate classes and all of them were accesing that amount property and changing it. So you're never getting the amount you want and you don't know where it's changing.

Lastly, imagine that you decide that you want to add a sales tax of 14% to your amount, so that every amount will be x * 0.14. You may add the logic in the class, but since you have the property set as public, that logic won't be enforced in all of the instances where you directly assigned the value to amount.

Basically: setters and getters are safety measures. You do not want other classes being able to change the properties in OTHER classes. The example we used was simple but imagine you had a class with really complex properties, and you ended up changing the logic of these properties accidentally because you didn't use a setter.

Same goes for getters. Imagine the opposite case, you change the internal logic of the class, but you were getting the values of its properties through some other way that wasn't a getter, now all of your code is broken because the other classes that were accessing the property were not made aware of the changes in logic.