CODEWITHSUNDEEP
javaoopinheritance
daniel sp
daniel sp

Reputation: 1000

Accessing protected variables in the super class

I have recently joined a new company and I am trying to get used to their coding style guidelines. I have no problem changing my coding style, but one particular point, I am not sure whether they are right or not.

For my first task I had to extend one of the existing abstract classes to develop a particular functionality. Thus I needed to access many attributes declared in this abstract superclass. To do so I proposed to change the visibility of these attributes and declare them as protected. My surprise came with their reply:

"Never! That is absolutely against OOP and you would produce obscure and difficult to maintain code! What you have to do is creating a getter in the super class and using it from the subclass in order to access these attributes".

Well, I have been always using protected attributes in an abstract superclass and accessing them from the subclass directly and I always thought there was nothing wrong with it. Even I would say that calling all the time the getter to access an attributes in the super class is slower than using it by its name...

What do you think about it? Is it normal/standard coding style declaring the attributes in a superclass and accessing them directly or are you of the oppinion that is better creating getters for these attributes.

To sumarize, my way:

public abstract class A {

    protected String variableA="a";

    public abstract methodToImplement();    

}

public MyClass B extends A {

    public methodToImplement() {
        System.out.println(variableA.length());
    }

}

Their way:

abstract class A {
    protected String variableA="a";
    public String getVariableA() {
        return variableA;
    }
    public abstract methodToImplement();
}

MyClass B extends A {
    public methodToImplement() {
        System.out.println(getVariableA().length());
    }
}

Thanks.

Upvotes: 1

Views: 2021

Answers (1)

Christophe De Troyer
Christophe De Troyer

Reputation: 2922

So as other threads already point out it appears to be so that it's indeed recommended to use getters and setters. The reason being that if you ever plan to change the representation of that value (StringBuilder instead of String for example) you will have to change your code. A getter/setter allow you to program in a way that you send the getters/setters the data you want, and they will store it in the proper field for you (e.g., appending it to the StringBuilder). So yes, it apears to have a lot of advantages, even though it's not your coding style. However, declaring the variable as protected seems pretty weird when you use a getter and a setter as well..

I personally try to avoid getters/setters when they are a bit of overkill. To me they are overkill for value variables. For reference variables they are however a good idea.

However, I think there is no right or wrong here..

Upvotes: 1

Related Questions