Question

Let’s assume I have a class and whenever I set certain attributes bla, foo (which can be set externally and internally) I want to call another method of the class, let’s call it onChangeFunction().

Would it be a good way to simply call onChangeFunction() when setting internal values directly, e.g.

function someFunction()
  // Some Calculations here ...
  this.bla = some_value;
  this.onChangeFunction()
end

or would it be better to also set those variables bla and foo ONLY by using the internal setter-methods because there is a certain action triggered with it and thus it would be a more clearly arranged code.

I even go a step further: Let’s say I don’t need an extern setter which can be called from outside (access type = public), would it than still be good to invent a private setter to do the same approach and only use the setter because of the triggered set-action?
EDIT: What I mean is the following: Even if I would NOT have a public setter (because there should not be a public access to set the variable, because it’s only an internal variable) would it be still good to have a setter which is private-only just because of the triggered action thing?

Thanks in advance!

Answer 1

I think in the long term it is much less error-prone to always use a setter, and to call onChangeFunction() from within the setter.

You don’t specify which programming languages you have in mind, but some languages allow one to define a “property” that looks like a data member but always calls a function when an attempt is made to change it. See, for example, property et al in Python.

As to your second question, I don’t think there’s anything wrong with having a private setter.