Set Difference and Get in object-oriented programming

Question

What is the basic difference of set and get in object-oriented programming?

Answer 1

Assuming you want to know about a property or prefix method set and get, this pattern is used to abstract a state that must be internal to the object. They are used as facilitators in cases of fields that must be accessed in a simple and direct way for take the value of an attribute (get) or to change the value of this attribute (set).

They are also called accessors and changers.

In general it is said that they cause a encapsulation, because real encapsulating is create methods that do something special that does not encapsulate only the access or assignment, is to create a meaning for the method. It is an abstraction but not an encapsulation.

They are used to hide the detail of how the state is stored and/or calculated, validated, etc. Hiding the detail is an abstraction.

There is a chain that says they should always be used, even if they do not do any further processing other than take the value (get) or assign the value (ser) to the class variable. So if one day you need to put something just change the implementation of this pair of methods and everyone who consumes the object starts to use the new way. This is a indirect.

But there are those who are more pragmatic and only use when necessary, because in general it is easy to refactor.

There are still those who say that they are always a mistake because the methods should have a function of their own, just let take or change the data of a field is to expose detail in disguise.

Some languages have facilities for this pair of methods to look like a simple variable, is the case of C#. It can be seen as it is different in Java.

They can be used separately. In fact it is common to have one get and not a set. In some cases the set is private or protected so that only the object itself can access it.

Behold arguments to use in Java.

There’s a explanation when use in PHP.

Behold as used in Python.

Example in pseudocode:

class Cliente { //exemplo bem meia boa
    private string nome; //note que é privado
    public string getNome() => return nome; //aqui pega a variável interna e retorna
    public void setNome(string nome) => this.nome = nome; //aqui joga o parâmetro na variável da classe
    private decimal saldo;
    public decimal getSaldo() => return saldo - 100; //dá uma margem de erro
    public void setSaldo(decimal valor) => if (valor > 200) saldo = valor; //só aceita um mínimo de 200
}

I put in the Github for future reference.

Answer 2

The method (GET) serves to recover a data and the method (SET) is used to modify a data

In fact, there are many good reasons to consider using methods (getters and setters) instead of directly exposing fields of a class - beyond the encapsulation argument and facilitating future changes.

Here are some of the reasons:

• Encapsulation of the behavior associated with the acquisition or configuration property - this allows additional functionality (such as the validation) is added more easily later.
• Hiding the internal representation of the property when exposing a property using an alternate representation.
• Isolating your public interface from change - allowing the public interface remains constant as implementation changes without affecting existing consumers.
• Controlling the semantics of life and memory management (disposal) of property - particularly important in environments unmanaged memory (such as C++ or Objective-C).
• Provide a debug intercept point for when a property changes at runtime - debugging when and where a property changed to a specific value can be quite difficult without that in some languages.
• Allow heirs to change semantics of how the property behaves and is exposed by replacing getter / Setter methods.
• Getters and setters can allow different levels of access - for example, get can be public, but the set can be protected.