CODEWITHSUNDEEP
javacoding-style
jedwards
jedwards

Reputation: 30250

Methods using private members or public accessors

I realize this probably cannot be answered, but I'm looking for whether there is some sort of guidance about whether to use private members directly or public accessors inside class methods.

For example, consider the following code (in Java, but it would look very similar in C++):

public class Matrix {

    // Private Members
    private int[][] e;
    private int numRows;
    private int numCols;

    // Accessors
    public int rows(){ return this.numRows; }
    public int cols(){ return this.numCols; }

    // Class Methods
    // ...
    public void printDimensions()
    {
        // [A] Using private members
        System.out.format("Matrix[%d*%d]\n", this.numRows, this.numCols);


        // [B] Using accessors
        System.out.format("Matrix[%d*%d]\n", this.rows(), this.cols());
    }

The printDimensions() function illustrates two ways to get the same information, [A] using private members (this.numRows, this.numCols) or [B] via accessors (this.rows(), this.cols()).

On one hand, you may prefer using the accessors since there is no way you could inadvertently change the value of the private member variables. On the other, you may prefer accessing the private members directly in hopes that it would remove the unnecessary function call.

I guess my question is, is either the de-facto standard or preferred?

Upvotes: 7

Views: 2044

Answers (3)

Fritz
Fritz

Reputation: 10055

IMHO, accessors are more a matter of structure and data management rather than accessors per se. Sometimes, you need to preprocess some data before returning it. Think about this example:

public class Foo {

    private List<Bar> bars = null;

    //Methods and stuff

    public List<Bar> getBars() {
        if(bars == null)
            bars = SomeClass.loadBars();
            // You can also use 
            // setBars(SomeClass.loadBars());
        return bars;
    }

}

In this case, your getter is not only wrapping your field, but returning an initialized field whenever you invoke it. Using the accessors inside a class gives the same benefits that for outsiders, you abstract yourself from the particular details of a field and you can obtain it after processing it.

On the other hand, if your field is returned directly (say, a String) it doesn't matter if you use a get or you don't, but you might want to use a get to respect a standard in your code.

In the end, it all boils down to coding style.

Upvotes: 3

Nathan Hughes
Nathan Hughes

Reputation: 96444

I have other objects, including subclasses of the object, use the accessors, but have the object itself use the fields. That way there is a clear distinction between the internals and the interface with the rest of the world. Hiding the contents of the class from itself seems unnecessary and potentially confusing. If something really benefits from having its implementation hidden from other parts of the object then break it out into a separate object.

Upvotes: 2

theglauber
theglauber

Reputation: 29665

It's a style call. I prefer to use accessors, because IMHO the function call overhead is small enough that in most cases it doesn't matter, and this usage preserves the data abstraction. If i later want to change the way the data is stored, i only need to change the accessors, instead of hunting for all the places where i touched the variables.

I don't feel strongly about it, though, and i would break this "rule" if i thought i had a good reason to.

Upvotes: 8

Related Questions