What is the Java Equivalent of Python's property()?

Question

I'm new to Java, and I'd like to create some class variables that are dynamically calculated when accessed, as you can do in Python by using the property() method. However, I'm not really sure how to describe this, so Googling shows me lots about the Java "Property" class, but this doesn't appear to be the same thing. What is the Java equivalent of Python's property()?

Answer 1

There's no such facility built into Java language. You have to write all the getters and setters explicitly by yourself. IDEs like Eclipse can generate this boilerplate code for you though.

For example :

class Point{
  private int x, y;

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

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

  public int getX(){
    return x;
  }

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

  public int getY(){
    return y;
  }
}

---

You might want to have a look at Project Lombok which provides the annotations @Getter and @Setter that are somewhat similar to Python's property.

With Lombok, the above example reduces to :

class Point{
  @Getter @Setter private int x, y;

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

Answer 2

the built-in property() function does exactly the opposite of what's described here in the answers. it's not about generating getters and setters for member variables. it just allows you to call a method by accessing a property (so, although you just access a variable in te Python class, a function will be called). (this post ecplains how and why to use it.)
this said, Java doesn't offer anything like this. even more, property access is discouraged in Java. i guess you could do it in Groovy script language and the meta magic though. but i don't know out of my head how to do this.

Answer 3

They don't really exist. In Java it's common practice to declare members as private or protected and only allow access to them via methods. Often this leads to lots of small getFoo() and setFoo(newFoo) methods. Python doesn't really have private and protected and it's more common to allow direct access to members.

Answer 4

As others have noted, java has getters and setters, but there is no strict analogon. There is a third party library called Project Lombok tha uses annotation to generate the getters and setters in the .class files at comile time. This could be used to make things a little less verbose.