CODEWITHSUNDEEP
javaoopget
stfxc
stfxc

Reputation: 174

Can I use the accessor methods (getter and setter) of a java class inside this class?

private int x;
private int y;

public Point(int x, int y){
    this.x = x;
    this.y = y;
}

public void setY(int y){
    this.y = y;
}    

public int getY() {
    return y;
}

public void setX(int x){
    this.x = x;
}

public int getX() {
    return x;
}

I want to implement the Sum method. But I can't seem to find a good practice for using accessors within a class. Which is the better approach for this?

public int sum(){
    return x + y;
}

Or

public int sum(){
    return getX() + getY();
}

Upvotes: 1

Views: 553

Answers (2)

sunrise
sunrise

Reputation: 404

You can omit the 'this' as it is clear from context that you are using class variables, just as you have already done in the getters. 'This' in the constructor and setter methods serves to distinguish the class variable from the input parameter where both have the same name.

public int summ(){
    x + y;
}

Points to note:

  1. Please fix the spelling issue, 'sum' only has one 'm'.
  2. Please don't forget to include a return statement :)
  3. The name of the proposed method could be clearer, e.g. sumOfCoordinates. Naming stuff is a bit of an art form, always challenge yourself on your method and variable names and be prepared to play around with different ideas until you find something which you are really happy with (e.g. I just changed the suggested alternative three times while reviewing this answer!). Don't be overly long-winded, but do prefer clarity over brevity.

Upvotes: 0

chrylis -cautiouslyoptimistic-
chrylis -cautiouslyoptimistic-

Reputation: 77177

Certainly you can, as you just showed! There's one important distinction in general, though: The methods can be overridden by a subclass, but the field access can't.

There's a guideline that items that aren't intended to be overridden should be made final, but if you want someone to be able to create a new LoggingPoint extends Point that prints log messages when it's accessed, then you should usually access the properties through the accessors so that the subclass can override getX() and getY().

(The one exception is in a constructor, where the subclass's initialization might not have run yet. This kind of complication is the reason some people prefer to make everything final by default: You can always "open" a final class later on if extension is needed, but it's difficult to "close" a class that wasn't final.)

Upvotes: 1

Related Questions