Classes with "Setters" and "Getters" only - advantages

Question

I've had often the case that an API defines a class which only consists of its fields with the appropriated setters and getters.

However, they have had a specific role. So from a real life (OOP) point of view they actually were meaningful. The last time I've stumbled about this was the schema in Olingo. It's used to set a few properties.

My question is, is there any advantage over "just setting variables" from a technical point of view or are these classes only used to stick to OOP (and have clean code and so on)?

Edit: Please note that I'm not asking why we are using "Setters" and "Getters". Try to look at it from another perspective. Let's say you have to define three Strings to use them further in your code. Instead of defining them as "on the fly" private Strings, you decide to create a class storing these three strings as fields and defining setters and getters for them. Is there any technical advantage to do so?

Sample code for "schema":

public List<Schema> getSchemas() throws ODataException {
List<Schema> schemas = new ArrayList<Schema>();

Schema schema = new Schema();
schema.setNamespace(NAMESPACE);

List<EntityType> entityTypes = new ArrayList<EntityType>();
entityTypes.add(getEntityType(ENTITY_TYPE_1_1));
entityTypes.add(getEntityType(ENTITY_TYPE_1_2));
schema.setEntityTypes(entityTypes);

List<ComplexType> complexTypes = new ArrayList<ComplexType>();
complexTypes.add(getComplexType(COMPLEX_TYPE));
schema.setComplexTypes(complexTypes);

List<Association> associations = new ArrayList<Association>();
associations.add(getAssociation(ASSOCIATION_CAR_MANUFACTURER));
schema.setAssociations(associations);

List<EntityContainer> entityContainers = new ArrayList<EntityContainer>();
EntityContainer entityContainer = new EntityContainer();
entityContainer.setName(ENTITY_CONTAINER).setDefaultEntityContainer(true);

List<EntitySet> entitySets = new ArrayList<EntitySet>();
entitySets.add(getEntitySet(ENTITY_CONTAINER, ENTITY_SET_NAME_CARS));
entitySets.add(getEntitySet(ENTITY_CONTAINER, ENTITY_SET_NAME_MANUFACTURERS));
entityContainer.setEntitySets(entitySets);

List<AssociationSet> associationSets = new ArrayList<AssociationSet>();
associationSets.add(getAssociationSet(ENTITY_CONTAINER, ASSOCIATION_CAR_MANUFACTURER, ENTITY_SET_NAME_MANUFACTURERS, ROLE_1_2));
entityContainer.setAssociationSets(associationSets);

entityContainers.add(entityContainer);
schema.setEntityContainers(entityContainers);

schemas.add(schema);

return schemas;
}

Added an example which contains exactly the content I'm questioning. Consider the class "test" as a class which contains two fields "a" and "b" and the appropriated "setters" and "getters". Simple example:

public class Main {
    public static void main(String[] args) {

        //Version 1: Common practice

        test asdf = new test();
        asdf.setA("asdf");
        asdf.setB("asdf2");

        //Doing something with "asdf" and "asdf2"

        //Version 2: My request

        String a = "asdf";
        String b = "asdf2";

        //Doing something with "asdf" and "asdf2"

    }
}

Answer 1

There are lots of real-world practical advantages to getters/setters:

• If you need to add logic to them (usually a setter), you can do so without breaking your API.

• When debugging, if you need to know when a field is changed, you can set a breakpoint in the setter.

• You can use an interface to define your API.

• Subclasses can add logic to them.

• If appropriate, the exposed type of the getter/setter can be a more generic or limited version of the actual field being used (for instance, a getter can be a read-only List), allowing you to change the implementation (perhaps an ArrayList becomes a LinkedList) without, again, breaking your API.

• They can be proxied for testing.

In theory, the real-world, practical disadvantage is that you're making method calls rather than just setting fields. But if it's important from a performance standpoint, the JVM's just-in-time optimizing compiler will inline simple getters/setters.

Answer 2

Definitely there are advantage.

With this setter and getter you allowing other to access you property when you monitoring.

Which I mean, You are giving a controlled access. You can filter and check the value that other object setting to the fields.

Answer 3

It is useful to have methods to access and set the attributes (consistency check, encapsulation...), but it is boilerplate having to do it explicitly when the getter/setter has the default action.

Many languages now use myObject.attr as the only syntax, be it for attributes or getters. Default getters and setters are automatically (and silently) generated if the attributes are visible. Scala is one of those languages and to me, that's the best solution.

Answer 4

With Setters , we can abstract away the logic for setting the variable.

For Ex : Minimum Balance can't be negative. If we use the variable directly to set the balance, we may set it to negative value by mistake. This can be avoided with the setters.

public Class Account {

    public int minBalance;

    public void setMinBalance(int amount) {
        if(amount < 0) minBalance = 0;
        else minBalance = amount;
    }
}