<p>When learning a new programming language, one of the possible roadblocks you might encounter is the question whether the language is, by default, <em>pass-by-value or pass-by-reference</em>.</p>

<p>So here is my question to all of you, in your favorite language, <em>how</em> is it actually done? And what are the <em>possible pitfalls</em>?</p>

<p>Your favorite language can, of course, be anything you have ever played with: <a href="http://www.ruby-lang.org/en/" rel="noreferrer">popular</a>, <a href="http://www.devtopics.com/a-obscure-programming-language-of-the-month/" rel="noreferrer">obscure</a>, <a href="http://en.wikipedia.org/wiki/Brainfuck" rel="noreferrer">esoteric</a>, <a href="http://www.nvidia.com/object/cuda_get.html" rel="noreferrer">new</a>, <a href="http://en.wikipedia.org/wiki/FORTRAN" rel="noreferrer">old</a>...</p>

Here is my own contribution for the
Java programming language
.
first some code:
```
```
public void swap(int x, int y)
{
  int tmp = x;
  x = y;
  y = tmp;
}
```
```
calling this method will result in this:
```
```
int pi = 3;
int everything = 42;

swap(pi, everything);

System.out.println("pi: " + pi);
System.out.println("everything: " + everything);

"Output:
pi: 3
everything: 42"
```
```
even using 'real' objects will show a similar result:
```
```
public class MyObj {
    private String msg;
    private int number;

    //getters and setters
    public String getMsg() {
        return this.msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getNumber() {
        return this.number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    //constructor
    public MyObj(String msg, int number) {
        setMsg(msg);
        setNumber(number);
    }
}

public static void swap(MyObj x, MyObj y)
{
    MyObj tmp = x;
    x = y;
    y = tmp;
}

public static void main(String args[]) {
    MyObj x = new MyObj("Hello world", 1);
    MyObj y = new MyObj("Goodbye Cruel World", -1); 

    swap(x, y);

    System.out.println(x.getMsg() + " -- "+  x.getNumber());
    System.out.println(y.getMsg() + " -- "+  y.getNumber());
}

"Output:
Hello world -- 1
Goodbye Cruel World -- -1"
```
```
thus it is clear that Java passes its parameters
by value
, as the value for
pi
and
everything
and the
MyObj objects
aren't swapped.
be aware that "by value" is the
only way
in java to pass parameters to a method. (for example a language like c++ allows the developer to pass a parameter by reference using '
&
' after the parameter's type)
now the
tricky part
, or at least the part that will confuse most of the new java developers: (borrowed from
javaworld
)
Original author: Tony Sintes
```
```
public void tricky(Point arg1, Point arg2)
{
    arg1.x = 100;
    arg1.y = 100;
    Point temp = arg1;
    arg1 = arg2;
    arg2 = temp;
}
public static void main(String [] args)
{
    Point pnt1 = new Point(0,0);
    Point pnt2 = new Point(0,0);
    System.out.println("X: " + pnt1.x + " Y: " +pnt1.y); 
    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);
    System.out.println(" ");
    tricky(pnt1,pnt2);
    System.out.println("X: " + pnt1.x + " Y:" + pnt1.y); 
    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);  
}

"Output
X: 0 Y: 0
X: 0 Y: 0
X: 100 Y: 100
X: 0 Y: 0"
```
```
tricky
successfully changes the value of pnt1!
This would imply that Objects are passed by reference, this is not the case!
A correct statement would be:
the
Object references
are passed by value.
more from Tony Sintes:
The method successfully alters the
  value of pnt1, even though it is
  passed by value; however, a swap of
  pnt1 and pnt2 fails! This is the major
  source of confusion. In the main()
  method, pnt1 and pnt2 are nothing more
  than object references. When you pass
  pnt1 and pnt2 to the tricky() method,
  Java passes the references by value
  just like any other parameter. This
  means the references passed to the
  method are actually copies of the
  original references. Figure 1 below
  shows two references pointing to the
  same object after Java passes an
  object to a method.
(source:
javaworld.com
)
Conclusion
or a long story short:
Java passes it parameters
by value
"by value"
is the
only way
in java to pass a parameter to a method
using
methods from the object
given as parameter
will alter
the object as the references point to the original objects. (if that method itself alters some values)
useful links:
http://www.javaworld.com/javaworld/javaqa/2000-05/03-qa-0526-pass.html
http://www.ibm.com/developerworks/java/library/j-passbyval/
http://www.ibm.com/developerworks/library/j-praxis/pr1.html
http://javadude.com/articles/passbyvalue.htm