getters & setters is the Java equivalent of .NET properties.

Arne

They're standard, in that other APIs expect them and work with them
already.  The GUI, Swing, is based heavily on use of getters and setters.

Just curious: how would you expect things to work instead?  Accessing
properties through a method is pretty standard software engineering in
OOD.  Java does have the option of using public properties if you really
want to.  The get/set part is just a standardized naming convention.
(But still useful.)

The idea behind {g,s}etters is that it gives the person who writes the
class a chance to catch all access to a variable. Publicly exposing the
variable is often a bad thing, and is highly warned against.

An example of when {g,s}etters are useful would be in a point class:

class Point {
    private double x, y;
    private double r, theta;

    double getX();
    double getY();
    double getR();
    double getTheta();
    double setX(double x);
    double setY(double y);
    double setR(double r);
    double setTheta(double theta);
}

[ Method bodies not shown for conciseness ]

If the variables were made public, it would be the client's job to
ensure that the rectangular/polar coordinates were kept in sync. With
the {g,s}etters, the class can transparently maintain the two variables,
potentially even removing the r and theta variables.

In short, {g,s}etters:
1. allow the class to internally keep related variables in sync.
2. provide for pseudo-variable support.
3. allow the internal structure to be modified without affecting the
public API.
4. allow the class to keep track of accesses and perform sanity checks.
5. shift the burden of bookkeeping away from the clients.

There are some OO languages that even have get/set overloading (e.g.,
PHP, Python).

get and set methods make it easier to make changes in one place.

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

what if you need to run some test on the parm, because you want to check for
something? Example:

public void setX(int parm) {
  if(parm<0) {
     this.x = 0;
 }
 else {
     this.x = parm;
 }
}

so you just add the test in one place, instead of EVERY PLACE where x is
used.

tnx a lot to all :)

    Getters and setters are simply a way to control and monitor
access to the internal state of an object.  They tend to be overused
by many Java programmers.  I recommend that you read Joshua Bloch's
"Effective Java" and take his advice to prefer immutable objects
wherever possible.

Regards,

Patrick

------------------------------------------------------------------------
S P Engineering, Inc.  | Large scale, mission-critical, distributed OO
                      | systems design and implementation.
         pjm@spe.com  | (C++, Java, Common Lisp, Jini, middleware, SOA)

see http://mindprod.com/jgloss/getter.html
http://mindprod.com/jgloss/setter.html