Envio y recepcuion de parametros entre metodos...

Recuerda que en Java tienes tipos primitivos y tienes objetos. Los tipos primitivos se pasan siempre por valor y los objetos se pasan siempre por referencia.

si en una clase tienes dos métodos, uno llama al otro de esta manera:

El método m1 imprimirá 1 y luego imprimirá "Juan". Esto porque el parámetro tipo int se pasa por valor. Esto significa que la variable x dentro de m1 mantiene su valor; se pasa el contenido de la variable (el 1) como parámetro a m2, que ahora tiene ese 1 en el parámetro a. Al asignarle 5 a la variable a, solamente se afecta dentro de m2. La variable x en m1 sigue siendo 1.

En cambio, el objeto "obj" de m1 se pasa por referencia a m2, es decir, son como apuntadores al mismo objeto realmente, no se hace una copia ni nada. Por eso el cambio que se hace al nombre del objeto, se ve reflejado después en m2.

@ezamudio: Más o menos. En Java, todo se pasa por valor, incluyendo los objetos. Lo que sucede es que el valor que se pasa con los objetos es una copia del valor de la referencia. Pero Java mismo no soporta el "pase por referencia".

En un lenguaje donde pasas la variable por referencia ( como C++, o VB por ejemplo ) un cambio en la variable pasada, afecta el original.

Por ejemplo, considerando el siguiente código.
 

En un lenguaje donde los objetos se pasan por referencia, la invocación del método change haría que la referencia del objeto cambiara y como resultado, la variable final no tendría como valor el 42, sino el 1024 asignado al final.

Como en Java las referencias se pasan también por valor, la referencia llamada "object" no cambia, cuando es pasada por el método "change", y conserva el 42 al final del ejemplo.

Pero como lo que nos es pasado es una copia de la referencia, podemos modificar el atributo del objeto al que ese objeto "apunta"

Si el código fuera:

Entonces el valor final, no sería 42, sino 256.

Links:

( al final donde dice: "Passing Reference Data Type Arguments" )

Respecto a tu duda, no dices que es lo que llevas o que es lo que si entiendes y lo que no. Así que ahi te va algo que quizá te parezca muy básico ( o quizá no, no lo sé )

Si tienes un método 1 que le envía una variable A a un método 2, en programación orientada a objectos esto se llama como "mandarle un mensaje" y la variable es el "argumento", el metodo 2 debe de definir un parametro, para recibir ese argumento.

Entonces:

Como te decía antes, esto puede ser muy básico, pero es el inicio. El metodoUno, llamó al metodoDos pasando la variableA ( que en el métodoDos se define como el parametro a ) , hace con el un procesamiento ( que este caso fue dividirlo entre dos ) y lo regresa y se le asigna a la variable b

mmmmm, pues no estoy muy de acuerdo en lo que dicen (Foros,Blogs,etc..) que en Java no Existen paso de parametros por Referencia.

Estoy de acuerdo en lo que dice @Ezamudio
 

Primero definiremos los terminos
 

Y como yo veo, en el ejemplo que dio ezamudio se cumple la definicion de paso por Referencia.
Se da como parametro un Objeto, Objeto que despues utiliza el metodo Setter para cambiar el Valor de la Variable "Nombre", la misma Variable "Nombre" que estaba antes de haberse agregado el parametro.

Aqui les muestro otro ejemplo que refuerza lo que digo
 

Y da como resultado
 

Por estas razones, creo que:

"Java no permite pasar Tipos Primitivos como parametros "Directamente" por Referencia"

En Java Si existe el paso de parametros por Referencia pero esta limitado a los Objetos que no son Primitivos,

Y digo "Directamente" por que si no me ensartaria con los ejemplos que dio "@OscarRyz".

¿Entonces que tendriamos que hacer, para poder pasar un tipo Primitivo y/o String por Referencia?
Respuesta: Tenemos que Usar un Objeto que enmascare al tipo Primitivo y/o String ,tal como lo hizo "@OscarRyz" en su ejemplo

¿Pero existe alguna forma de hacerlo trasparente, sin necesidad de crear metodos (Setter) para modificar la variable?
Respuesta: Si Existe, se puede hacer con StringBuilder

Aqui un Ejemplo con paso de referencia con un Tipo String:

Aqui un Ejemplo con paso de referencia con un Tipo Int:
 

Suerte :)

...la función recibe la dirección de memoria del valor original, no la copia del valor...

Lo que pasa es que cuando se trata de objetos, lo que se recibe es "la copia del valor, de la referencia" ( esto hay que repetirlo hasta que quede claro)

Es decir, en Java, nunca y repito nunca se obtiene la referencia a un objeto ( como en Pascal/Delphi, C++ , VB, y otros lenguajes ) lo que se obtiene es el valor de la referencia. Cuando lo pasas entre métodos, lo que pasas el es valor de la referencia. Cuando cambias una variable, lo que cambias es el valor de la referencia por uno nuevo.

Ejemplo

El objeto creado se va la memoria de Java ( al monton ) y la variable "o" tiene el "valor" de la referencia de ese objeto.

Si se define luego:

La variable "p" tiene el mismo "valor" que la variable "o", pero si se cambia luego:

La variable p sigue teniendo el valor anterior y la variable o uno nuevo.

En los lenguajes de programaicón que tiene paso por referencia cuando se cambia el segundo el primero también se modifica. Esto no es posible en Java.

El efecto que ves cuando le asignas otro valor de referencia a un atributo, es que en realidad sí le estas cambiando el valor por uno nuevo, pero parece que cambias la referencia:

Demo:
 

De nuevo, en los lenguajes que soportan pase por referencia, cuando la referencia es cambiada, todos las referencia al mismo objeto cambian tambien, es decir lo anterior imprimiría true en ambos casos.

Otros dos links:

Gracias a los 3 me han ayudado a entender un poco mas de la forma de pasar estos valores.
saludos desde venezuela.

El paso por valor y el paso por referencias en lenguajes como Java y C++ tiene mucho que ver con los modelos de objetos que usa uno y otro lenguaje.
C++ utiliza un modelo de objetos "híbrido", producto de su relación muy estrecha con el lenguaje C de donde proviene. C++ es "híbrido" también en lo que se refiere al scope donde se pueden definir funciones.

En C++ se dice que existe un modelo de objetos por valor y un modelo de objetos por referencia o apuntadores como se le quiera llamar.

En el modelo de objetos por valor, la memoria asignada al objeto se localiza en el scope donde se crea, y la creación del objeto usa una sintaxis similar al la creación de variables de tipos definidos por el lenguaje.

El modelo de objetos por referencia (que para la creación de objetos usa al operador new) localiza la dirección o apuntador del objeto en el scope donde se crea, pero el espacio para el objeto se crea en otro lugar. Nos referimos a ese lugar como el espacio de objetos.

Java solamente tiene ese modelo de objetos por referencia.

Para lidear con un modelo de objetos por valor, C++ introduce el constructor copia o copy constructor, el que se invoca para varias cosas, entre ellas la del paso de objetos por valor.

C++ también introduce el tipo referencia, para hacer varias cosas, y entre ellas brindar lo que se denomina sintaxis de paso por valor con semántica de paso por referencia. Con esos tipos referencias podemos entonces decir que C++ incluye paso por valor y paso por referencia de los argumentos pasados a las funciones. Depende enteramente del compilador si crea en el espacio de las funciones un apuntador para "apuntar" al objeto de tipo referencia, pero para el programador eso es transparente: dispones de una sintaxis por valor con una semántica de apuntadores.

A continuación un ejemplo de esto en C++:
 

Al ejecutar este código obtenemos lo siguiente:

El resultado expresa la localización de los objetos pasados por valor y pasados por referencia y la modificación de los atributos x, y para el caso de pasar un tipo referencia. También muestra el uso del constructor copia para el paso por valor.

Chale dos contra uno ni como decir que no, me lincha. jajaja!!! ntc!!!!

Sip @OscarRyz tienes razon :) con el ejemplo me quedo muy Claro tienes Razon :)

Aquí va una variación al ejemplo de bferro. Le quité las llamadas a cout ( solo para mejorar la legibilidad ) e hice que dentro de los métodos se cree un nuevo objeto y se asigne al argumento pasado. El código dentro del los métodos es (casi) identico.

En uno ( byRef ) el argumento pasado toma el valor del nuevo objeto y al salir del método, conserva ese valor.

En otro ( byValue ) el argumento pasado toma el valor de nuevo objeto, pero lo descarta al salir del método ( como en Java ) y después de la invocación, conserva su valor original.